systemverilog assertion without using dist

Charlotte

2 min read

·

27-02-2025

1

0

Share

SystemVerilog Assertions (SVAs) are a powerful mechanism for verifying the functional correctness of hardware designs. While the dist (distributed) operator is often used for concisely expressing complex assertions, it's possible and sometimes preferable to achieve the same results without it. This article explores how to write effective SVAs without relying on dist. We'll focus on clarity and maintainability, demonstrating that avoiding dist doesn't necessarily mean sacrificing conciseness.

Why Avoid dist?

The dist operator, while convenient, can sometimes lead to less readable and harder-to-debug assertions, especially for complex scenarios. Overuse of dist can obscure the underlying logic. Furthermore, some simulation tools might have different interpretations or optimizations for dist, potentially leading to unexpected behavior or inconsistencies across different verification environments. By explicitly writing out the logic, you gain better control and understanding.

Fundamental Assertion Constructs

Before diving into complex examples, let's review the basic building blocks of SVAs:

• assert property: This is the core construct for specifying a property that should always hold true.
• assume property: Used to specify assumptions about the design's behavior. Violations indicate a problem with the assumptions, not necessarily the design.
• covergroup: For functional coverage analysis, tracking different aspects of the design's behavior.
• Temporal Operators: ## (sequence concatenation), |-> (implication), always (always true), eventually (true at some point), nexttime (true in the next cycle).

Replacing dist with Explicit Logic

Let's consider a scenario where dist is commonly used: checking for multiple conditions simultaneously across different parts of a design.

Example using dist:

dist {
  a;
  b;
  c;
}

This assertion passes if at least one of the signals a, b, or c is true.

Equivalent without dist:

a | b | c;

This achieves the same result more simply and directly. The | operator (logical OR) naturally expresses the "at least one" condition.

More Complex Scenarios

Consider a scenario where we want to check that if signal req is high, then eventually ack will be high within a certain timeframe. A dist approach might be tempting, but explicit logic offers better clarity:

Example with implication and eventually:

property req_implies_ack;
  req |-> ##[1:10] ack;
endproperty

assert property (req_implies_ack);

This assertion checks that if req is high, then within 1 to 10 cycles, ack will become high. This clearly expresses the timing relationship without the need for dist.

Handling Multiple Conditions with Concatenation and Implication

Let's say we need to verify that several conditions must hold sequentially. Instead of using dist within a sequence, we can use sequence concatenation (##).

Example with Sequence Concatenation:

Imagine verifying a protocol where start, data, and end signals must occur in order.

property correct_sequence;
  start ## data ## end;
endproperty

assert property (correct_sequence);

This concisely expresses the required ordering without dist.

Conclusion

While the dist operator can be a useful shorthand, it's often possible and preferable to write clearer, more maintainable SVAs without it. By using fundamental logical operators and temporal operators appropriately, we can achieve the same functionality with improved readability and reduced risk of ambiguity. Prioritizing clarity in your assertion code improves debugging and collaboration within your verification team. Remember to carefully consider the specific requirements of your verification task and choose the approach that maximizes clarity and maintainability.