SystemVerilog ConstraintsConcepts and Interview QuestionsYou Should Master

rand samples a legal value on each successful randomization and may repeat immediately. randc keeps cyclic state so successive calls on the same object visit each value in its legal domain before repeating.

object.randomize() solves the active constraints of one class instance. std::randomize() applies inline constraints to variables in the current scope. $urandom_range() is a procedural random-number function and does not invoke the constraint solver.

pre_randomize() runs first, the solver searches for one assignment to the selected variables, and post_randomize() runs only after a successful solve. The caller must check the returned bit.

Use $urandom() for an unsigned 32-bit procedural value, $urandom_range(max, min) for one inclusive bounded choice, and the $dist_* functions only when a specific statistical distribution is the model. $random is the legacy signed function.

randcase procedurally chooses one statement branch using relative weights. A dist constraint biases values while the solver still satisfies every active relationship in the object model.

The variable list selects which class properties may change in that call. Other properties become fixed state, while the active constraints are still evaluated against the complete object.

inside tests membership in a set of individual values and inclusive ranges. Negate the complete membership expression when you need to exclude a set.

For a range, := gives the stated weight to every value, while :/ divides one stated weight across the entire range. For a single value, the two forms are equivalent.

A soft expression supplies a default that yields to a conflicting hard constraint. An inline hard constraint is added to the active class hard constraints, while constraint_mode() and rand_mode() change which blocks and variables participate.

A constraint describes relationships that must hold in the final assignment. It does not execute statements from top to bottom or designate the left side of == as an output.

solve a before b changes the sampling order and therefore the marginal distribution of a. It does not add or remove legal solutions, and it is not a remedy for a circular equation.

A derived class inherits its base constraints. A derived constraint block with the same name replaces the inherited block; a differently named block is added and must remain compatible.

Equality is always active, implication activates its right-hand rule only when the left condition is true, and biconditional requires both conditions to have the same truth value.

The parent handle must be declared rand and must already refer to a constructed child object. The solver can then include the child's random properties and any cross-object constraints in one solve.

Enumerate the bounded candidate space, apply each relationship as a filter, and show at least one surviving assignment. The survivors also reveal the actual sampling space.

Constrain size() to establish the dynamic array's shape, then use foreach to contribute one declarative element rule for every valid index.

An array reduction returns a value derived from the element or with-expression type. If that type is too narrow, the sum can wrap before it is compared, so cast each contribution to a width that can represent the maximum total.

Use unique to require different values across a set in one solve, randc to avoid repeats across successive calls for one cyclic variable, and shuffle() to procedurally permute an existing collection.

The with expression maps every array element to a temporary contribution, and sum() reduces those mapped contributions. It does not necessarily add the original elements.

Use $countones() on an integral expression. Constrain the count to one for one-hot, to m for m-hot, or apply it to an XOR to constrain Hamming distance.

Build a queue containing the full domain, shuffle it once, consume one entry per successful transaction, and rebuild only when the queue is empty.

Constrain every cell to 0 through 3, then require each row and each projected column to contain unique values. Four unique values drawn from a four-value domain form a permutation.

Give every element the complete 0 through N-1 domain and require the array to be unique. With N elements, that proves the result is a permutation; additional index and cross-element rules can then narrow it.

With type_a as one bit and val as two bits, the legal pairs are (0,0), (0,1), (0,2), (0,3), and (1,3). In the uniform legal-pair model, type_a is 1 for one of five pairs, so its probability is 1/5.

The inline hard restriction intersects the dist domain. The surviving values keep their relative bias and the solver normalizes probability over the reduced legal set.

A bin hit with independent probability p has expected first-hit time 1/p. The chance it is still unhit after k tests is (1-p)^k, so rare bins dominate regression length.

If IDLE permits one length, SLOW permits three, and FAST permits seven, the legal-pair space has 11 assignments. Uniform sampling of complete pairs gives FAST seven of them, or about 63.6 percent.

The hit count is binomial under independent identical trials. Its mean is np = 100/11, about 9.09 hits, and its standard deviation is sqrt(np(1-p)), about 2.87.

Randomize the payload and an error-intent flag, compute correct parity procedurally in post_randomize(), then flip the parity only when the flag requests a negative test.

Constrain each start and finish pair locally, then relate each window to its predecessor with foreach. Add duration rules only for the indices that require them.

Preserve the failing seed and object state, confirm the return value, inspect fixed variables and active modes, then disable the smallest constraint blocks until the empty intersection becomes identifiable.

Constrain length to the legal aligned range, tie payload.size() to length, add the opcode implication, and compute the payload reduction with a width-safe contribution.

Create a genuinely empty hard intersection, check that randomize() returns 0, then change one documented requirement at a time. A soft default may yield, but conflicting hard rules never override one another.

A process seed controls procedural calls made by that thread, while an object's random stream controls its constrained randomization. Reproducing a mixed testbench requires the original test seed, object creation order, and any explicit reseeding operations.

Keep each named block focused on one requirement, bound collection sizes, prefer direct declarative relationships, check every solve, and use coverage plus solver diagnostics as feedback.