soft defaults that yield

A soft constraint holds whenever it can, and it is dropped when a hard constraint contradicts it. That makes it the natural tool for defaults in reusable transactions.

While active, a soft constraint is full strength, shaping the set exactly like a hard one. Discarding is all-or-nothing per soft constraint, and only genuine contradiction triggers it.

1
2
3
4
5
6
7

// snippet: also in the bench below
class eth_pkt;
  rand bit [13:0] len;

  // Default: ordinary frame sizes, but only a preference
  constraint len_default { soft len inside {[64:1500]}; }
endclass

A plain call keeps the default range. A hard inline constraint such as len == 9000 discards the soft one and succeeds, where a hard default would fail on the empty intersection.

Discard order and soft distributions

Hard constraints always hold. Softs are kept from the highest priority down, and one is discarded only if it cannot hold together with every higher-priority soft already kept. Example: class softs x < 10 then x > 5, and an inline soft x == 20: the inline one holds, x > 5 fits with it, and x < 10 is dropped.

IEEE 1800 18.5.14.1 defines the priority: a later soft in the same class outranks an earlier one, a derived class outranks its base, and an inline with outranks the class. Keep one soft default per field anyway, so the result stays easy to read.

1
2
3
4
5
6
7
8

// snippet: also in the bench below
class prio_demo;
  rand int x;
  constraint c_low { soft x == 1; }   // declared first: lower priority
  constraint c_high { soft x == 2; }  // declared second: higher priority
endclass
// Both cannot hold, so the lower-priority (earlier) soft x==1 is discarded.
// LRM result (18.5.14.1): x == 2. Keep such chains rare.

1
2
3
4
5
6
7
8
9

// snippet: also in the bench below
class axi_txn;
  rand bit [1:0] resp;   // 0=OKAY 1=EXOKAY 2=SLVERR 3=DECERR

  // Default shape: overwhelmingly OKAY, but only a default
  constraint resp_default { soft resp dist { 0 :/ 95, [2:3] :/ 5 }; }
endclass
// An error test with a hard inline resp == 3 discards the soft dist.
// Soft cannot rescue hard-versus-hard clashes, and soft on randc is illegal.

Testbench

The classes from this lesson: the soft default, a hard override, two softs in conflict, and a soft dist.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class eth_pkt;
  rand bit [13:0] len;
  // Default: ordinary frame sizes, but only a preference
  constraint len_default { soft len inside {[64:1500]}; }
endclass

class prio_demo;
  rand int x;
  constraint c_low  { soft x == 1; }   // declared first: lower priority
  constraint c_high { soft x == 2; }   // declared second: higher priority
endclass

class axi_txn;
  rand bit [1:0] resp;   // 0=OKAY 1=EXOKAY 2=SLVERR 3=DECERR
  constraint resp_default { soft resp dist { 0 :/ 95, [2:3] :/ 5 }; }
endclass

inline len == 9000: returned 1, len = 9000
two softs in conflict: x = 2 (the later one wins)
soft dist: OKAY in 946 of 1000 (weight 95 of 100)
PASS: the soft default held until a hard rule contradicted it, and the later soft won the tie

The standard also discards a soft dist when a hard rule contradicts it. One of the simulators used here does not: a hard resp == 3 made the call fail, so the bench checks only the soft weights.

Related topics

• Next topic: Dynamic Constraint Control