SystemVerilog unique Constraint

A unique constraint guarantees that a set of variables, or every element of an array, will all come out mutually distinct from one another after randomization. It's a far more concise way to express "no two of these should ever be equal" than writing out a pairwise != comparison between every possible pair by hand.

12 min read | Intermediate Level

What You'll Learn

• What unique guarantees, for both an explicit list of variables and an array
• Why unique can make randomize() fail outright when the legal range is too small for the number of values that need to be distinct
• How unique interacts with other constraints that already pin some of the values
• How to exclude a specific value from a unique set using an auxiliary variable

Syntax

// A list of variables, all mutually distinct
constraint c_name { unique {var1, var2, var3}; }

// Every element of an array, all mutually distinct
constraint c_name { unique {array}; }

unique on a List of Variables

Combined with other constraints, unique narrows down exactly what's still possible for the remaining variables. Here, two of three variables sharing a 2-bit range are pinned to specific values:

class ABC;
  rand bit [1:0] a, b, c;

  constraint c_unique { unique {a, b, c}; }
  constraint c_pin { a == 0; b == 1; }
endclass

With a fixed at 0 and b fixed at 1, unique requires c to differ from both — out of the four legal 2-bit values (0 through 3), only 2 and 3 remain available. c will always land on one of those two, chosen freely between them.

unique on an Array

Applied to an array, every element must differ from every other element:

class ABC;
  rand bit [1:0] arr[4];

  constraint c_unique { unique {arr}; }
endclass

arr has exactly 4 elements, and a 2-bit element can only hold 4 possible values (0 through 3) — an exact match. This means arr is guaranteed to contain all four of those values, each exactly once, in some order — effectively a random permutation of {0, 1, 2, 3}.

When Uniqueness Becomes Impossible

If the number of items that need to be mutually distinct exceeds the number of values actually available, unique can never be satisfied — and randomize() fails every single time, regardless of seed:

class ABC;
  rand bit a, b, c;   // each is a single bit: only 0 or 1 possible

  constraint c_unique { unique {a, b, c}; }
endclass

a, b, and c are each only 1 bit wide — just two possible values between them. Three variables can never be pairwise distinct when only two distinct values exist to assign — there's no seed, no amount of retrying, that makes this satisfiable. randomize() will fail on every call.

The exact same principle applies to arrays — a 5-element array of the same 2-bit type used earlier would also fail unconditionally, since only 4 distinct values exist for 5 elements that all need to differ.

Excluding a Specific Value From unique

unique's own list can only hold variables, not a bare literal — so excluding one specific value from the set means adding an extra variable and pinning it to that value with its own constraint, rather than writing the literal directly inside the braces:

class ABC;
  rand bit [1:0] a, b;
  rand bit [1:0] excluded;

  constraint c_unique  { unique {a, b, excluded}; }
  constraint c_exclude { excluded == 2'd2; }
endclass

Here, a and b both have to differ from excluded (pinned to 2), and from each other. Out of the four legal 2-bit values, only {0, 1, 3} remain available once 2 is excluded — a and b will always end up as two different values drawn from that remaining set of three.

Common Beginner Mistakes