{"id":10353,"date":"2026-10-23T12:50:43","date_gmt":"2026-10-23T12:50:43","guid":{"rendered":"https:\/\/inskill.in\/training\/?p=10353"},"modified":"2026-10-23T12:53:29","modified_gmt":"2026-10-23T12:53:29","slug":"systemverilog-constraint-coding-problems-verification-interviews","status":"publish","type":"post","link":"https:\/\/inskill.in\/training\/vlsi\/systemverilog-constraint-coding-problems-verification-interviews\/","title":{"rendered":"SystemVerilog Constraint Coding Problems for Verification Interviews"},"content":{"rendered":"\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

SystemVerilog constraints are an important part of functional verification because they allow engineers to generate legal, varied stimulus without manually specifying every transaction. In verification interviews, candidates are often asked to write a constraint for a packet, generate unique array values, control random distributions, or identify why <\/span>randomize()<\/span> fails.<\/span><\/p>

Interviewers are evaluating more than syntax. They want to know whether you can translate a specification into mathematical conditions, understand how constraints interact, and debug cases where the solver cannot find a valid solution.<\/span><\/p>

This guide covers practical <\/span>SystemVerilog constraint coding problems for verification interviews<\/b>, with examples, explanations, and common mistakes. The examples use class-based randomization, which is commonly used to generate transactions in <\/span>SystemVerilog<\/span><\/a> testbenches.<\/span><\/p>

Generate a Random Number Within a Range<\/span><\/h3>

Interview problem:<\/b> Write a constraint that generates an 8-bit address between 32 and 127, inclusive.<\/span><\/p>

class address_item;<\/span><\/p>

\u00a0\u00a0rand bit [7:0] addr;<\/span><\/p>

\u00a0<\/p>

\u00a0\u00a0constraint addr_range_c {<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0addr inside {[8’d32:8’d127]};<\/span><\/p>

\u00a0\u00a0}<\/span><\/p>

endclass<\/span><\/p>

Explanation:<\/b> The <\/span>inside<\/span> operator restricts <\/span>addr<\/span> to the specified inclusive range. Because <\/span>addr<\/span> is an 8-bit unsigned variable, its normal representable values are 0 through 255, but the constraint narrows the legal set to 32 through 127.<\/span><\/p>

To test the constraint:<\/span><\/p>

address_item item = new();<\/span><\/p>

\u00a0<\/p>

repeat (10) begin<\/span><\/p>

\u00a0\u00a0if (!item.randomize())<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0$error(“Randomization failed”);<\/span><\/p>

\u00a0\u00a0else<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0$display(“Address = %0d”, item.addr);<\/span><\/p>

end<\/span><\/p>

The example checks the return value of <\/span>randomize()<\/span> rather than assuming every call succeeds.<\/span><\/p>

Follow-up question:<\/b> How would you allow only even addresses in the same range? Add <\/span>addr[0] == 1’b0;<\/span> to the constraint block. The least significant bit of an even unsigned integer is zero.<\/span><\/p>

Generate Only Even or Odd Random Numbers<\/span><\/h3>

Interview problem:<\/b> Generate a random 8-bit number that is always even.<\/span><\/p>

class number_item;<\/span><\/p>

\u00a0\u00a0rand bit [7:0] value;<\/span><\/p>

\u00a0<\/p>

\u00a0\u00a0constraint even_c {<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0value[0] == 1’b0;<\/span><\/p>

\u00a0\u00a0}<\/span><\/p>

endclass<\/span><\/p>

For odd values, change the condition to:<\/span><\/p>

constraint odd_c {<\/span><\/p>

\u00a0\u00a0value[0] == 1’b1;<\/span><\/p>

}<\/span><\/p>

Why this works:<\/b> In binary representation, the least significant bit determines whether an unsigned integer is even or odd. An even number ends in zero, while an odd number ends in one.<\/span><\/p>

Practical use:<\/b> This type of constraint can model aligned addresses, where a bus or memory protocol requires addresses to be aligned to a particular boundary.<\/span><\/p>

For example, a four-byte-aligned address must have its two least significant bits equal to zero:<\/span><\/p>

constraint align_4_c {<\/span><\/p>

\u00a0\u00a0addr[1:0] == 2’b00;<\/span><\/p>

}<\/span><\/p>

Make sure the alignment condition matches the actual protocol specification. Not every interface requires the same alignment.<\/span><\/p>

Generate Unique Values in an Array<\/span><\/h3>

Interview problem:<\/b> Generate four distinct random values, each between 1 and 15.<\/span><\/p>

class unique_array_item;<\/span><\/p>

\u00a0\u00a0rand bit [3:0] data[4];<\/span><\/p>

\u00a0<\/p>

\u00a0\u00a0constraint data_range_c {<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0foreach (data[i])<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0data[i] inside {[1:15]};<\/span><\/p>

\u00a0\u00a0}<\/span><\/p>

\u00a0<\/p>

\u00a0\u00a0constraint data_unique_c {<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0unique {data};<\/span><\/p>

\u00a0\u00a0}<\/span><\/p>

endclass<\/span><\/p>

Explanation:<\/b> The <\/span>foreach<\/span> constraint applies the range restriction to every array element. The <\/span>unique<\/span> constraint requires all listed elements to have different values.<\/span><\/p>

Since there are four elements and fifteen possible values, a solution exists.<\/span><\/p>

Common mistake:<\/b> Trying to generate more unique elements than the number of legal values. For example, requiring sixteen distinct 4-bit values while excluding zero leaves only fifteen legal values, so randomization cannot satisfy the constraint.<\/span><\/p>

This problem tests whether you understand both syntax and the number of available solutions.<\/span><\/p>

Constrain One Random Variable Based on Another<\/span><\/h3>

Interview problem:<\/b> A transaction has a <\/span>write<\/span> flag and an 8-bit address. Require write transactions to use addresses from <\/span>0x80<\/span> to <\/span>0xFF<\/span>, and read transactions to use addresses from <\/span>0x00<\/span> to <\/span>0x7F<\/span>.<\/span><\/p>

class bus_transaction;<\/span><\/p>

\u00a0\u00a0rand bit \u00a0 \u00a0 \u00a0 write;<\/span><\/p>

\u00a0\u00a0rand bit [7:0] addr;<\/span><\/p>

\u00a0<\/p>

\u00a0\u00a0constraint addr_by_type_c {<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0if (write)<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0addr inside {[8’h80:8’hFF]};<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0else<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0addr inside {[8’h00:8’h7F]};<\/span><\/p>

\u00a0\u00a0}<\/span><\/p>

endclass<\/span><\/p>

Explanation:<\/b> The <\/span>if-else<\/span> constraint expresses two mutually exclusive conditions. When <\/span>write<\/span> is one, the upper half of the address range is legal. When <\/span>write<\/span> is zero, the lower half is legal.<\/span><\/p>

An equivalent logical relationship can be written with implication:<\/span><\/p>

constraint addr_by_type_c {<\/span><\/p>

\u00a0\u00a0(write == 1’b1) -> (addr inside {[8’h80:8’hFF]});<\/span><\/p>

\u00a0\u00a0(write == 1’b0) -> (addr inside {[8’h00:8’h7F]});<\/span><\/p>

}<\/span><\/p>

Interview follow-up:<\/b> What if both branches accidentally restrict <\/span>addr<\/span> to non-overlapping values while another constraint forces it into a third range? The combined constraints may become unsatisfiable. Always consider all active constraints together.<\/span><\/p>

Constrain Packet Length and Payload Size<\/span><\/h3>

Interview problem:<\/b> A packet has a randomized length and a payload array. Generate packets containing between 1 and 16 payload bytes, with the array size matching the length.<\/span><\/p>

class packet_item;<\/span><\/p>

\u00a0\u00a0rand bit [4:0] length;<\/span><\/p>

\u00a0\u00a0rand byte unsigned payload[];<\/span><\/p>

\u00a0<\/p>

\u00a0\u00a0constraint length_c {<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0length inside {[1:16]};<\/span><\/p>

\u00a0\u00a0\u00a0\u00a0payload.size() == length;<\/span><\/p>

\u00a0\u00a0}<\/span><\/p>

endclass<\/span><\/p>

Explanation:<\/b> The length is limited to the range 1 through 16. The dynamic array size must equal the randomized length, so the generated transaction has a consistent number of payload bytes.<\/span><\/p>

This is a useful example because real verification environments often need relationships between transaction metadata and data structures.<\/span><\/p>

Follow-up questions:<\/b><\/p>