# SystemVerilog Assertion

## Sequence Repetition Operators

A sequence repetition operator indicates that the sequence occurs a number of times. The number of times the sequence repeats is always a non-negative number (i.e. zero or positive number) and can be specified either as a fixed number or a range. If it is a range, then the maximum limit of the range can also be specified as '\$', which indicates a finite but unbounded maximum.

There are three types of repetition operators.

• Consecutive Repetition Operator [* ]
• Goto Repetition Operator [-> ]
• Non-consecutive Repetition Operator [= ]
The last two of these operators actually work on boolean expressions rather than on sequences. Next sections describe these repetition operators.

## Consecutive Repetition Operator [* ]

The consecutive repetition operator applied to a sequence indicates that the sequence repeates itself a specified number of times with one clock cycle of delay between two repetitions. For example,

```s1 ##2 s2 [*4] ##5 s3
```
is same as
```s1 ##2 (s2 ##1 s2 ##1 s2 ##1 s2) ##5 s3
```
or, simply,
```s1 ##2 s2 ##1 s2 ##1 s2 ##1 s2 ##5 s3
```
Note that the repetition operation ([*4]) is on s2, but not on the delay ##2 that preceeds it.

### Empty Sequence [*0]

A repetition of 0 times indicates that the resultant sequence is empty. So if s1 is a sequence, s1 [*0] does not match any event(s) regardless of what s1 is.

An empty sequence can be used in a sequence operation with the following rules. Here e is an empty sequence and s is not.

1. Neither (e ##0 s) nor (s ##0 e) matches any sequence.
2. (e ##n s) is equivalent to (##(n-1) s), if n > 0
3. (s ##n e) is equivalent to (s ##(n-1) `true), if n > 0

### Repetition with a Range

A range specified for a repetition simply menas that the match may be for any of the combinations of the repetition. Thus, a range of s1 given as

```s1 [*2:3]
```
is equivalent to
```   s1 ##1 s1          // two times of s1
or s1 ##1 s1 ##1 s1   // or three times of s1
```

A range repetition is applicable to a chain of sequences (or events) as well.

```(s1 ##5 s2) [*2:3]
```
is equivalent to
```   (s1 ##5 s2) ##1 (s1 ##5 s2)                  // two times of (s1 #5 s2)
or (s1 ##5 s2) ##1 (s1 ##5 s2) ##1 (s1 ##5 s2)  // or three times of (s1 #5 s2)
```

Lastly, an upper bound of '\$' in a range indicates the sequence repeats at least the number of times specified by the lower bound. So, s1[*2:\$] means s1 occurs at least 2 times. As another example, s0 ##3 s1[*2:\$] ##2 s2 indicates that s0 occurs first followed by at least 2 occurances of s1 after 3 clock cycles and then s2 occurs 2 clock cycles after the last s1 finishes.

## Goto Repetition Operator [-> ]

The Goto is a 'non-consecutive exact repetition' operator for boolean expression, meaning it checks if a boolean expression has been true for specified number of times but not necessarily on consecutive clock cycles. The sequence starts with the first occurance of the boolean expression and ends with the last one (i.e. there is no gap before the first one and after the last one). The following are few cases of using the Goto operator.

1. b [->3]: The boolean expression b has been true thrice, but not necessarily on successive clocks.
2. b [->3:5]: Here, b has been true 3, 4 or 5 times, once again not necessarily on consecutive clocks.
3. a ##2 b [->3] ##4 c: The boolean expression b has been true thrice, but not necessarily on successive clocks. The first occurance of b happens after two clocks cycles of a. The last one occurs four clock cycles before c.

## Non-consecutive Repetition Operator [= ]

The non-consecutive exact repetition operator is also for boolean expression and is very similar to the goto repetition operator. When the goto repetition operation ends with the last true value of the operand, the non-consecutive repetition operation may extend beyond such last true value. An example will clarify this.

1. b [=3]: The boolean expression b has been true thrice, but not necessarily on successive clocks and there may be additional clock cycles after the last true b before the sequence completes.
2. b [=3:5]: Here, b has been true 3, 4 or 5 times, once again not necessarily on consecutive clocks, and with possible additional clocks afterwords when b is not true.
3. a ##2 b [=3] ##4 c: The boolean expression b has been true thrice, but not necessarily on successive clocks. The first occurance of b happens after two clocks cycles of a. The last one occurs at least four clock cycles before c.

## Can You?

The new intern Smart Assert can not write simple assertions. He wrote:

```((!b[*0:\$] ##1 b) [*3:5])
```
While the assertion works correctly, can you help him write it in a simplified form?

We wrap up our Part 2 of this series on SystemVerilog Assertion with this. In Part 3, we will look into other types of sequence operation and how they make building sequences easier for you.

 Join Verification Management Group

Shop Amazon - Contract Cell Phones & Service Plans

 Book of the Month