SystemVerilog Sequence Repetition Operator

Writing out a ##1 a ##1 a to say "a should be true for 3 cycles in a row" gets unwieldy fast, especially once the count grows. SystemVerilog provides three repetition operators that express this compactly — and two of them, despite looking similar, behave in a genuinely different way that's worth understanding precisely.

13 min read | Intermediate Level

What You'll Learn

• How [*n] compactly expresses n consecutive repetitions of the same condition
• How [->n] (goto repetition) finds the nth occurrence of a condition, with gaps allowed in between
• How [=n] (non-consecutive repetition) differs from goto in exactly where its match is allowed to end
• Why the exact same signal trace can pass under [=n] but fail under [->n]

Consecutive Repetition: [*n]

expr[*n] requires expr to be true for n consecutive clock cycles in a row. req2[*3] is exactly equivalent to writing req2 ##1 req2 ##1 req2 — the repetition operator just avoids spelling that out by hand:

module tb;
  bit req1, req2;
  bit clk;

  always #10 clk = ~clk;

  // Once req1 is seen, req2 must stay high for 3 consecutive
  // cycles starting the very next cycle
  sequence s_consec;
    @(posedge clk) req1 ##1 req2[*3];
  endsequence

  assert property (s_consec)
    $display ("[%0t] Match: req2 held high for 3 consecutive cycles", $time);

  initial begin
    req1 <= 1; req2 <= 0;
    @(posedge clk);                 // 10ns: req1=1

    req1 <= 0; req2 <= 1;
    @(posedge clk);                 // 30ns: req2's 1st consecutive cycle

    @(posedge clk);                 // 50ns: req2's 2nd consecutive cycle

    @(posedge clk);                 // 70ns: req2's 3rd consecutive cycle - match completes

    req2 <= 0;
    @(posedge clk);                 // 90ns

    #20 $finish;
  end
endmodule

req1 is seen at 10ns, and req2 stays high for exactly three cycles afterward — 30ns, 50ns, and 70ns — so the sequence completes and the assertion's action block fires at 70ns, printing "Match: req2 held high for 3 consecutive cycles". Every other independent attempt starting at 30ns, 50ns, 70ns, or 90ns fails immediately, since req1 is 0 at each of those points — only the attempt that started with req1=1 at 10ns has any chance of succeeding.

Range Repetition: [*n:m] and [*n:$]

A range works the same way, just with flexible bounds instead of a fixed count:

req2[*2:4]    // req2 true for anywhere between 2 and 4 consecutive cycles
req2[*2:$]    // req2 true for 2 or more consecutive cycles, with no upper limit

Goto Repetition: [->n]

expr[->n] waits for expr to become true a total of n times — the occurrences don't need to be consecutive, gaps are allowed in between. The important detail: the sequence's own match point is fixed exactly at the cycle of the nth occurrence, with no flexibility about where that match "ends."

sequence s_goto;
  @(posedge clk) a[->2] ##1 b;
endsequence

This says: wait for a to occur twice (with any gap in between), and b must be true in the cycle immediately following that 2nd occurrence — no later.

Non-Consecutive Repetition: [=n]

expr[=n] also waits for expr to become true n times with gaps allowed, but differs from goto in one specific way: its match point does not have to be exactly the nth occurrence — it can be any later cycle too, as long as expr stays false the whole way there:

sequence s_nonconsec;
  @(posedge clk) a[=2] ##1 b;
endsequence

Because [=n]'s match point can slide forward through any number of additional false cycles, this is effectively evaluated as several candidate possibilities in parallel — the property succeeds overall if any valid placement makes the rest of the sequence hold true.

Comparing goto and non-consecutive on the Same Trace

Here's a trace where a occurs at cycles 1 and 3 (with a gap at cycle 2), and b doesn't show up until cycle 5, staying false at cycles 2 and 4:

a[->2] ##1 b (goto): a's 2nd occurrence is at cycle 3, so the goto match ends exactly there — no flexibility. ##1 b then requires b to be true precisely at cycle 4. But b=0 at cycle 4, so this fails.

a[=2] ##1 b (non-consecutive): the match point for the [=2] portion doesn't have to be cycle 3 — it can also be cycle 4, since a stays false there. Using that later match point, ##1 b now requires b at cycle 5 instead — and b=1 there, so this passes.