Randomization contracts, domains, and distributions interview questions

Question 1

What is the difference between rand and randc?

Accepted Answer

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. Use rand for normal constrained-random stimulus. A repeated value is legal and is not evidence that randomization failed. Use randc for a small, stable scalar or enum domain when no-repeat traversal is itself the requirement. A new object starts a new randc cycle. Tight or changing constraints can exhaust the remaining cyclic choices and make a later solve fail. Why interviewers ask: Whether you distinguish independent sampling from stateful no-repeat traversal and understand that randc is not a general uniqueness solution. Common trap: randc does not make the elements of an array mutually unique in one solve. Use a unique constraint for that relationship.

Question 2

How do object.randomize(), std::randomize(), and $urandom_range() differ?

Accepted Answer

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. Both randomize forms return a bit indicating success and support an inline with clause. std::randomize() can randomize local variables that are not declared rand, which is useful for a bounded scope-level decision. $urandom(), $urandom_range(), and randcase consume procedural random state. They are useful for simple branch or delay choices, not cross-variable legality. Why interviewers ask: Whether you choose the smallest mechanism that still expresses the required relationships and check solver failure where it can occur. Common trap: Do not replace a multi-variable constraint model with repeated $urandom_range() calls and rejection loops. That obscures legality and can bias results.

Question 3

What happens before, during, and after a randomize() call?

Accepted Answer

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 pre_randomize() to prepare non-random state or modes, but keep legality in constraint blocks when possible. Use post_randomize() for procedural derivation such as checksums or intentional corruption that would be expensive or unnatural to solve. A nested object must already exist. Marking its handle rand lets the parent solve the child object's random fields as part of the same model. Why interviewers ask: Whether you understand hook order, nested-object ownership, and the difference between solver relationships and procedural derivation. Common trap: Never write void'(item.randomize()) in production stimulus. A failed call can leave old values in the object and silently drive the wrong scenario.

Question 4

How do you express ranges, sets, and exclusions with inside?

Accepted Answer

inside tests membership in a set of individual values and inclusive ranges. Negate the complete membership expression when you need to exclude a set. addr inside {[16'h1000:16'h1fff], 16'h3000} permits one range plus one discrete address. !(opcode inside {4'h0, 4'hf}) excludes both reserved opcodes. inside defines legality only. It does not guarantee an even marginal distribution after other cross-variable constraints are added. Why interviewers ask: Whether you can translate a protocol's legal domain directly and recognize that legality and probability are separate questions. Common trap: SystemVerilog ranges in an inside set use square brackets. Curly braces collect set items; they do not replace the range brackets.

Question 5

What is the difference between := and :/ in a dist constraint?

Accepted Answer

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. [0:3] := 8 gives each of the four values weight 8, so the range contributes total weight 32. [0:3] :/ 8 gives the four-value range total weight 8, so each value receives weight 2. A positive-weight dist list also identifies the candidate values. Other active constraints may narrow that set, after which the surviving weights are normalized. Why interviewers ask: Whether you can calculate per-value probability instead of reading a range weight as a decorative percentage. Common trap: Weights are relative, not percentages, and a bias does not guarantee that a rare value appears in a finite regression.

Question 6

How do soft constraints, inline constraints, constraint_mode(), and rand_mode() interact?

Accepted Answer

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. Use soft for extensible defaults such as a normal packet-size range. A test can replace that default inline without editing the base class. Two conflicting hard constraints do not override one another. Their intersection is empty and randomize() returns 0. rand_mode(0) freezes a property at its current value. Active constraints still see that fixed value, so it can cause a failure. Why interviewers ask: Whether you can layer reusable defaults and scenario intent without disabling broad parts of the model unnecessarily. Common trap: constraint_mode(0) is a debug or scenario tool, not an automatic fix. Record exactly which legality guarantee was removed.

Question 7

When should you use $urandom(), $urandom_range(), $random, or a $dist_* function?

Accepted Answer

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. $urandom_range() takes max first and an optional min second. It is convenient for a loop count or delay but does not solve relationships among fields. $dist_exponential and $dist_normal model distributions such as inter-arrival time or jitter. Their seed, mean, and deviation parameters deserve the same review as any stimulus model. Procedural functions consume a process random stream. Object randomization uses an object's stream, so a reproducible testbench records and controls both where both are used. Why interviewers ask: Whether you know the procedural random toolbox and avoid using a scalar generator where a declarative multi-variable model is required. Common trap: Random calls are not automatically independent requirements. Rejection loops around $urandom_range() can hide bias, run for an unbounded time, and bypass solver diagnostics.

Question 8

How is randcase different from a dist constraint?

Accepted Answer

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. A branch with weight w is selected with probability w divided by the sum of all positive branch weights. Use randcase when the random decision is which action to execute. Use dist when the random decision is a field value that participates in constraints and coverage. Keep the chosen scenario observable. Recording a named mode or transaction field is easier to cover and reproduce than hiding every decision inside control flow. Why interviewers ask: Whether you distinguish procedural weighted control flow from declarative weighted value selection. Common trap: Weights are relative, not percentages unless they happen to sum to 100. A zero-weight branch is disabled.

Question 9

What changes when you call randomize(var1, var2) instead of randomize()?

Accepted Answer

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. A listed property is treated as a random variable for that call even when it is not declared rand; unlisted rand properties retain their current values. Partial randomization is useful for a deliberate local update, but it can fail when a fixed property conflicts with a relationship involving a selected property. Use randomize(null) as a constraint check when supported by the intended tool flow: it asks whether the current state is legal without choosing new values. Why interviewers ask: Whether you understand that partial randomization changes the unknown set, not the active legality model. Common trap: Do not assume the solver ignores every constraint that mentions an unlisted variable. That variable is fixed, and its current value still participates.

Choice	Across calls	Best use	Main risk
`rand`	Legal values may repeat	General stimulus	Assuming every value appears quickly
`randc`	No repeat within its cycle	Small IDs or enum sweeps	State, cost, and constraint exhaustion

Mechanism	Constraint solving	Typical scope
`object.randomize()`	Class constraints plus inline with	Transaction or configuration object
`std::randomize()`	Inline with over named scope variables	Task, function, module, or program
`$urandom_range()`	No	Single procedural choice

Function	Result	Good use	Constraint solver
`$urandom()`	32-bit unsigned	General procedural choice	No
`$urandom_range(max, min)`	Inclusive bounded unsigned	Delay or loop count	No
`$random`	32-bit signed	Legacy Verilog compatibility	No
`$dist_exponential`	Exponential integer sample	Arrival-time model	No
`$dist_normal`	Normal integer sample	Jitter or variation model	No

Questions for Solver fundamentals

SystemVerilog Randomization contractKnow what the solver promises.

Randomization is a legal-solution pipeline

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

SystemVerilog Domains and distributionsShape the legal value space.

Legality and probability are different controls

Reason it through

Reason it through

Reason it through

Solver fundamentalsRandomization contracts, domains, and distributionsInterview guide

SystemVerilog Randomization contractKnow what the solver promises.

Randomization is a legal-solution pipeline

What is the difference between rand and randc?+

Reason it through

How do object.randomize(), std::randomize(), and $urandom_range() differ?+

Reason it through

What happens before, during, and after a randomize() call?+

Reason it through

When should you use $urandom(), $urandom_range(), $random, or a $dist_* function?+

Reason it through

How is randcase different from a dist constraint?+

Reason it through

What changes when you call randomize(var1, var2) instead of randomize()?+

Reason it through

SystemVerilog Domains and distributionsShape the legal value space.

Legality and probability are different controls

How do you express ranges, sets, and exclusions with inside?+

Reason it through

What is the difference between := and :/ in a dist constraint?+

Reason it through

How do soft constraints, inline constraints, constraint_mode(), and rand_mode() interact?+

Reason it through