Constraint probability, reusable patterns, and solver debug interview questions

Question 1

Given type_a -> val == 3, what is the probability that type_a is 1?

Accepted Answer

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 implication leaves all four val values legal when type_a is 0 but only one value legal when type_a is 1. Adding solve type_a before val changes the marginal choice of type_a to roughly one half before selecting a compatible val. A finite simulation fluctuates around the expected rate. Measure the distribution instead of expecting an exact count in every short run. Why interviewers ask: Whether you can enumerate the complete legal solution space and distinguish a marginal probability from the written appearance of the constraint. Common trap: Do not assume an unconstrained one-bit variable must be 50/50 when another constraint gives its values different numbers of compatible partners.

Question 2

How does an inline range restriction change an existing dist constraint?

Accepted Answer

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. If [8'h20:8'h7f] has total :/ weight 6 out of total weight 20, each of its 96 values has base probability 0.30 / 96. Restricting that range inline to [8'h20:8'h3f] leaves 32 values from the same weighted item, so each surviving value has conditional probability 1 / 32. With 70 percent base calls and 30 percent restricted calls, P(addr == 8'h20) is 0.7(0.30/96) + 0.3(1/32) = 0.0115625. Why interviewers ask: Whether you can combine constraint intersection, range-level weights, conditional probability, and scenario mixing. Common trap: Do not add 30 percent directly to the address probability. The 30 percent chooses the scenario; probability inside that scenario must still be calculated.

Question 3

How do constraint probabilities affect coverage closure time?

Accepted Answer

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. Expected hits after n tests are np, with standard deviation sqrt(np(1-p)) for independent Bernoulli trials. For target confidence c of at least one hit, choose k such that 1 - (1-p)^k >= c. The n ln(n) coupon-collector estimate applies to many equally likely bins. Real coverage is usually governed by the least likely reachable bins and cross combinations. Why interviewers ask: Whether you connect stimulus probability to measurable coverage risk instead of assuming constrained random automatically closes every bin. Common trap: Functional coverage is feedback, not proof that weights are correct. Unreachable bins and correlated tests violate the simple independent model.

Question 4

How would you generate valid parity most of the time but occasionally inject an error?

Accepted Answer

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. Keep the error intent as a named random field so its distribution can be covered and debugged. Deriving parity after the solve avoids asking the solver to implement a reduction calculation that is naturally procedural. The transaction should retain enough state to tell the scoreboard whether the corruption was intentional. Why interviewers ask: Whether you separate legal stimulus generation from a deliberate protocol violation while preserving observability. Common trap: Use the correct parity width. A one-bit reduction parity should not be stored in a wider field and inverted accidentally as a multi-bit value.

Question 5

How would you constrain sorted, non-overlapping time windows with a minimum gap?

Accepted Answer

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. Local bounds establish start[i] < finish[i] and the global time limit. For i > 0, start[i] >= finish[i-1] + gap simultaneously enforces ordering, non-overlap, and the minimum gap. A modulus rule on finish[i] - start[i] expresses aligned durations without introducing a procedural loop. Why interviewers ask: Whether you can decompose a structured array problem into local and neighbor relationships that remain readable and solver-friendly. Common trap: The complete set must be satisfiable within the global upper bound. Window count, minimum duration, and gap can make the model impossible.

Question 6

How do you debug a randomize() failure and reproduce it?

Accepted Answer

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. Print or record non-rand state, rand_mode(), constraint_mode(), inline conditions, and the exact object type before changing anything. Re-enable one isolated block at a time and reduce the failure to a minimal set of conflicting expressions. Use the simulator's solver diagnostics where available. Keep process-level procedural randomness and object randomization streams conceptually separate when reseeding. Why interviewers ask: Whether you use a deterministic isolation process instead of repeatedly changing seeds until the failure disappears. Common trap: A successful solve after disabling a block does not prove that block is wrong. The conflict may be the combination of two individually valid rules.

Question 7

Why is FAST selected 7/11 of the time in a mode-and-length model?

Accepted Answer

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. IDLE contributes (IDLE,0), SLOW contributes three pairs, and FAST contributes seven pairs. Adding solve mode before length selects among the three legal mode values first, making each mode roughly one third before a compatible length is chosen. The legal set is unchanged by the ordering. Only the marginal sampling distribution changes. Why interviewers ask: Whether you can count compatible partners and quantify exactly how solve ordering changes a marginal distribution. Common trap: Do not assume an enum is uniform after another field creates different numbers of legal pairs for its values.

Question 8

If a scenario has probability 1/11, how many hits should 100 tests produce?

Accepted Answer

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. A single 100-test run is not expected to produce exactly nine hits. A rough two-standard-deviation band is about three through fifteen. The binomial model assumes the probability remains fixed and trials are independent. Stateful randc variables, adaptive tests, and shared random state can violate that assumption. Use measured coverage and confidence bounds to decide whether an observed deviation is meaningful rather than judging one short regression by eye. Why interviewers ask: Whether you understand expected count, variance, and simulation fluctuation instead of treating a probability as a deterministic quota. Common trap: Do not multiply by 100 and call the result guaranteed. It is an expectation over repeated experiments.

Question 9

How do you couple packet length, payload size, opcode rules, and an even byte sum?

Accepted Answer

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. length inside {[64:1024]} plus length % 16 == 0 models the general size contract. The opcode implication narrows length to 256 or 512 only for the special opcode; other opcodes keep the general domain. A thousand-byte payload with a sum constraint is solver-heavy. If only parity matters, deriving or controlling one byte procedurally may be a clearer performance tradeoff. Why interviewers ask: Whether you can connect scalar and collection shape constraints while noticing reduction width and solver-cost risks. Common trap: Summing byte elements in byte width can overflow before the modulus is applied. Cast each contribution inside the reduction.

Question 10

How do you demonstrate an intentional inline-constraint failure and a valid recovery?

Accepted Answer

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. aligned == 1, size == 8, and addr inside 3 through 5 is impossible because none of those addresses is divisible by eight. Disabling the named alignment block permits that negative scenario, but it also removes a legality guarantee and should be explicit in the test. Alternatively, keep alignment active and use an inline range such as 0 through 15 with size 4. That hard inline range replaces the incompatible soft default and leaves legal aligned values. Why interviewers ask: Whether you can distinguish soft-default replacement from hard-constraint conflict and make every recovery auditable. Common trap: Do not say the latest inline hard constraint overrides a class hard constraint. Both are active unless a block is disabled.

Question 11

How do process and object reseeding affect reproducibility?

Accepted Answer

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. process::self().srandom(seed) affects calls such as $urandom(), $urandom_range(), and randcase in that process. An object's srandom(seed) targets that object's random stream. In UVM, reseed() reapplies UVM's type-and-instance seeding policy rather than magically synchronizing the process stream. Changing object names, construction order, fork structure, or the number of random calls can change later results even when the top-level seed is unchanged. Why interviewers ask: Whether you can separate random streams and collect enough evidence to reproduce a failure instead of treating one global seed as the whole story. Common trap: Do not call reseeding functions during diagnosis unless the original run did so. That changes the experiment you are trying to reproduce.

Question 12

What makes a constraint model maintainable and solver-friendly?

Accepted Answer

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. Orthogonal named blocks make modes, inheritance, debug isolation, and specification review easier. Avoid unnecessarily tight or redundant relationships and large unbounded collections. They enlarge or fragment the search problem without adding useful intent. Document non-obvious probability choices, solve ordering, casts, and intentional constraint disabling so future tests preserve the same contract. Why interviewers ask: Whether you can design a reusable stimulus model, not merely produce syntax that passes one example. Common trap: Solver-friendly does not mean weakening protocol legality. Optimize the expression of the requirement and measure before removing guarantees.

Quantity	Formula	Result
Mean	np	9.09 hits
Variance	np(1-p)	8.26
Standard deviation	sqrt(np(1-p))	2.87 hits
Approximate 95% band	mean ± 2 sigma	about 3 to 15 hits

Step	Evidence to collect	Question answered
Reproduce	Seed, object type, fixed state	Can the same model fail again?
Inspect	Active variables and blocks	What actually entered the solve?
Isolate	Small block combinations	Which intersection is empty?
Repair	Specification-backed rule change	Which requirement was modeled incorrectly?

Stream	Typical consumers	Control
Process or thread	`$urandom()`, `$urandom_range()`, `randcase`	`process::self()`.`srandom(seed)`
Class object	`obj.randomize()`	`obj.srandom(seed)`
UVM object	uvm_object randomization	UVM seed policy and reseed()

Concern	Preferred practice	Evidence
Legality	One concern per named block	Requirement trace or comment
Performance	Bound sizes and reduce redundant rules	Solver profile or regression timing
Probability	State intended weights and ordering	Coverage distribution
Failure	Check return and preserve seed/state	Reproducible minimal conflict

Questions for Probability + debug

SystemVerilog Solver probabilityCount solutions before predicting traffic.

Solve ordering changes sampling, not legality

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

SystemVerilog Patterns and solver debugMake failures small and reproducible.

Reconstruct the failure before changing the model

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

Probability + debugConstraint probability, reusable patterns, and solver debugInterview guide

SystemVerilog Solver probabilityCount solutions before predicting traffic.

Solve ordering changes sampling, not legality

Given type_a -> val == 3, what is the probability that type_a is 1?+

Reason it through

How does an inline range restriction change an existing dist constraint?+

Reason it through

How do constraint probabilities affect coverage closure time?+

Reason it through

Why is FAST selected 7/11 of the time in a mode-and-length model?+

Reason it through

If a scenario has probability 1/11, how many hits should 100 tests produce?+

Reason it through

SystemVerilog Patterns and solver debugMake failures small and reproducible.

Reconstruct the failure before changing the model

How would you generate valid parity most of the time but occasionally inject an error?+

Reason it through

How would you constrain sorted, non-overlapping time windows with a minimum gap?+

Reason it through

How do you debug a randomize() failure and reproduce it?+

Reason it through

How do you couple packet length, payload size, opcode rules, and an even byte sum?+

Reason it through

How do you demonstrate an intentional inline-constraint failure and a valid recovery?+

Reason it through

How do process and object reseeding affect reproducibility?+

Reason it through

What makes a constraint model maintainable and solver-friendly?+

Reason it through