Steering constraints toward holes

When triage says needs-constraint-change, the cheapest fix is usually an inline constraint that biases randomization onto the hole ranges. The base constraints stay untouched, so the steering is additive and visible.

The listing below is not run in this course's checks: it is a fragment that calls the base test's driver.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// not-run: fragment (drive_burst is the base test's driver task)
class dma_txn;
  typedef enum {INCR, FIXED, WRAP} btype_e;
  rand btype_e btype;
  rand int unsigned blen;
  rand bit [31:0] addr;
  constraint c_basic {
    blen inside {[1:16]};
    (btype == WRAP) -> (blen inside {2, 4, 8, 16});
  }
  constraint c_close_fixed {
    btype dist {FIXED := 6, INCR := 3, WRAP := 1};   // below-at_least reshaping
  }
endclass

// Hole: <incr, max_len, unaligned> never hit — alignment starved it.
// Closure sequence: same transaction class, steered at the call site.
// drive_burst is the existing bus-driver task from the base test.
task automatic run_closure_burst(int n);
  dma_txn t = new();
  repeat (n) begin
    if (!t.randomize() with {
          btype == INCR;
          blen == 16;                  // the max_len bin
          addr[1:0] != 2'b00;          // force unaligned
        })
      $fatal(1, "closure randomize found no solution");
    drive_burst(t);
  end
endtask

• Inline constraints compose with class constraints. A randomize() failure here means the hole may be constraint-unreachable, so go back to triage.

• dist reshaping closes below-at_least holes without excluding the rest of the space.

• Keep steering in clearly named closure sequences. Reviewers must see that mainline stimulus was not narrowed.

Directed tests and seed sweeps

Some corners resist steering: multi-step setups, exact timing races, or error recovery chains. These get directed tests, short and explicit, named after the hole they close.

Before writing one, try the cheaper intermediate: a seed sweep. That is more seeds of an existing test whose stimulus is already in the right neighborhood.

The listing below is not run in this course's checks because it is a fragment of a full DMA testbench: the DUT and the base-test helpers are not shown.

1
2
3
4
5
6
7
8
9
10
11
12

// not-run: fragment: needs the DMA DUT and the base-test helpers, which are not shown
// Directed test for hole: timeout recovery (cp_fsm XFER => IDLE on timeout).
// Random stimulus cannot hold the bus idle long enough, so force it.
// start_burst, stall_ready, and check_abort_status are the base-test helpers.
task automatic test_timeout_recovery();
  cfg_timeout_cycles(50);            // shortened through config, a legal knob
  start_burst(INCR, 8);
  stall_ready(100);                  // hold ready low past the timeout
  wait (fsm_state == IDLE);          // recovery observed
  check_abort_status();              // closure AND checking
  start_burst(INCR, 4);              // prove the DUT still works after
endtask

Adjusting bins and knowing when to stop

Sometimes the right fix is in the model. Add bins when triage keeps finding interesting scenarios between buckets, and widen or merge bins when distinctions carry no verification meaning.

Widening to delete a hole is legitimate only when the distinction was meaningless. That judgement belongs in review, not in a deadline commit.

Testbench

The bench reproduces hole 1 from the triage lesson. The transaction class aligns every address, so 300 random bursts never fill the unaligned column of a burst-type × alignment cross, counted with the bins model. A closure sequence then turns that one constraint off and steers at the call site, and the class goes back to normal afterwards.

1
2
3
4
5
6
7
8
9
10
11

// uses: covmodel
// Hole: unaligned INCR bursts were never sent, because one constraint aligned every address.
// The closure sequence turns that constraint off and steers at the call site.
class dma_txn;
  typedef enum {INCR, FIXED, WRAP} btype_e;
  rand btype_e btype;
  rand int unsigned blen;
  rand bit [31:0] addr;
  constraint c_basic   { blen inside {[1:16]}; (btype == WRAP) -> (blen inside {2, 4, 8, 16}); }
  constraint c_aligned { addr[1:0] == 2'b00; }           // in every sequence: this starved the unaligned cells
endclass

after 300 random bursts:
  cross x_align: 50.00% (2 of 4 bins)
    hole: <incr, unalign>
    hole: <fixed, unalign>
after 8 steered bursts:
  cross x_align: 100.00% (4 of 4 bins)
PASS: 300 random bursts left the unaligned column empty; 8 steered bursts closed it

Related topics

• Stimulus generation

• Randomization interview Q and A