SystemVerilog Randomization

This article introduces the building blocks of the Randomization chapter: what randomization is and why it matters, the two ways to trigger it depending on where your variable lives, why checking its return value matters, and how a basic constraint lets you target stimulus toward specific scenarios.

6 min read | Intermediate Level

What You'll Learn

• Why constrained-random verification exists and what problem it solves
• The two ways to trigger randomization: rand/randc class properties and std::randomize() for plain variables
• Why checking the return value of randomize() matters
• How a basic constraint targets random stimulus toward specific scenarios

What Is Randomization and Why Does It Help?

Directed tests take a long time to develop because you have to think through every scenario you want to check, and there's a high chance you'll miss some corner case. Randomization flips this around: rather than hand-picking every value, you let SystemVerilog's constraint solver pick legal values that fall within a valid range and apply them to the signals you're interested in, run after run.

A single randomized run only exercises one legal combination out of many. Run the same randomized test dozens or hundreds of times, though, and the solver's picks spread across the entire legal space — including combinations you would never have thought to write a directed test for.

Two Ways to Randomize

SystemVerilog gives you two ways to trigger randomization, depending on where the variable you want to randomize lives: mark a class property with rand or randc and call the object's built-in randomize() method, or call std::randomize() directly on a variable that isn't part of a class at all.

Randomizing Class Properties

Randomization is enabled per-variable by adding the rand or randc qualifier to a class member. SystemVerilog Random covers the difference between the two in depth, along with how they apply to arrays, queues, and dynamic arrays — for now, just know that both keywords make a property randomizable when you call randomize().

rand   <type> <variable_name>;   // random, any legal value each call
randc  <type> <variable_name>;   // random-cyclic, no repeats until the full set is exhausted

Parameters:

• rand — marks the variable for standard randomization (required keyword)
• randc — marks the variable for cyclic randomization (required keyword)
• <type> — any legal data type such as bit, int, or an enum

Here's the simplest possible use of rand — no constraint block at all yet, just a property and a call to randomize():

class myPacket;
  rand bit [3:0] mode;   // no constraint - any value 0 to 15 is equally likely
endclass

module tb_top;
  myPacket pkt;

  initial begin
    pkt = new();
    pkt.randomize();
    $display("mode = %0d", pkt.mode);
  end
endmodule

Because there's no constraint block, mode can land anywhere from 0 to 15 with equal probability on every call to randomize(). Once you add a constraint block (covered later in this article), you narrow that range down to only the values you actually want.

Randomizing Plain Variables with std::randomize()

Not everything you want to randomize lives inside a class. std::randomize() is a built-in function that randomizes one or more plain variables directly — local variables in a task or function, module-level variables, or anything else that isn't a class property — without requiring the rand/randc qualifier or a surrounding class at all.

module tb_top;
  initial begin
    int addr, data;

    // Randomize plain (non-rand) local variables directly, with an inline constraint
    if (std::randomize(addr, data) with { addr inside {[0:255]}; data < 100; }) begin
      $display("addr = %0d data = %0d", addr, data);
    end else begin
      $display("randomization failed");
    end
  end
endmodule

The with { ... } clause works exactly like an inline constraint on a class object — it applies only to that one call. The std:: prefix explicitly calls the global randomize function rather than a class's own randomize() method, which matters once you're calling it from inside a class (see Mistake #3 below).

Always Check the Return Value

Either way you randomize, randomize() and std::randomize() both return 1 on success and 0 if the constraints can't be satisfied — and on failure, the variables simply keep their previous values.

Always check the return value of randomize() (or std::randomize()), typically with assert(). Ignoring a failed call means your test silently continues with stale, non-random data instead of flagging a broken constraint.

"Checking the return value" means wrapping the call in an if (or assert) and reacting when it's 0, instead of calling randomize() as a bare statement. The example below randomizes the same object twice: once normally, and once with an inline constraint that deliberately conflicts with the class-level constraint, so you can see what a caught failure looks like.

class myPacket;
  rand bit [1:0] mode;
  constraint c_mode { mode < 3; }   // mode can only be 0, 1, or 2
endclass

module tb_top;
  myPacket pkt;

  initial begin
    pkt = new();

    // Effective pattern: branch on the return value instead of trusting it blindly
    if (pkt.randomize()) begin
      $display("Randomization OK   -> mode = %0d", pkt.mode);
    end else begin
      $display("Randomization FAIL -> mode unchanged, still = %0d", pkt.mode);
    end

    // mode == 5 can never satisfy c_mode (mode < 3), so this call is
    // guaranteed to fail - a deliberate example of a caught failure
    if (pkt.randomize() with { mode == 5; }) begin
      $display("Randomization OK   -> mode = %0d", pkt.mode);
    end else begin
      $display("Randomization FAIL -> mode unchanged, still = %0d", pkt.mode);
    end
  end
endmodule

The first call has no conflict, so it succeeds and pkt.mode gets a fresh random value from {0, 1, 2}. The second call adds an inline constraint (mode == 5) that can never be true alongside c_mode (mode < 3), so randomize() returns 0, the else branch runs, and pkt.mode is left exactly as it was — it is not set to 5. That's the practical meaning of "checking the return value": it's the difference between silently running with unintended data and actively catching the exact constraint that broke.

What Are Constraints?

A rand or randc property with no constraint block, like the first mode example above, can take on any legal value in its declared range. Most of the time, though, you don't want the entire range — you want to target a specific subset of scenarios: legal opcodes, valid address windows, or corner cases you're specifically trying to hit. A constraint block narrows the random search space down to exactly the values that matter, using one or more relational expressions. The simplest form is a plain comparison:

class myPacket;
  rand bit [7:0] mode;
  constraint c_mode { mode > 2; }   // mode can only be 3 through 255
endclass

Adding c_mode here means every call to randomize() is guaranteed to produce a mode value greater than 2 — the solver simply won't pick anything outside that window. This is the mechanism behind targeted stimulus: instead of hoping a wide random range eventually lands on the scenario you care about, a constraint steers every single randomization attempt toward it.

Beyond simple comparisons like this, SystemVerilog also supports range checks with inside, weighted random distributions with dist, and constraints that reference other variables. Those styles deserve their own space rather than a quick summary here — see SystemVerilog Constraints and the worked Constraint Examples article for the full picture.

rand, randc, and constraint are testbench (verification) constructs, not synthesizable RTL. You'll find them inside classes used to build stimulus and check responses in a testbench, not inside a synthesizable design module.

Common Beginner Mistakes

module tb_top;
  initial begin
    int delay;

    if (std::randomize(delay) with { delay inside {[5:20]}; }) begin
      $display("delay = %0d", delay);
    end else begin
      $display("ERROR: randomization of delay failed");
    end
  end
endmodule