Verilog Math Functions

Verilog provides built-in math system functions that can be used in place of hand-calculated constants. Instead of working out how many address bits a memory needs and typing the number, you can let the compiler calculate it from a parameter. There are functions for integer values, mainly $clog2, and a set of functions for real numbers, such as $sqrt, $pow and $sin. They were added to Verilog in the IEEE 1364-2005 revision.

9 min read | Beginner Level

What You'll Learn

• How $clog2 calculates the number of bits needed for a value or an address
• How to size ports and signals automatically from parameters
• Which real math functions exist and how to use them in testbenches and models
• Which math functions synthesis accepts, and the common off-by-one mistakes

Integer Math Functions

The function $clog2 returns the ceiling of the base-2 logarithm of its argument: the smallest number n such that 2ⁿ is greater than or equal to the argument. This is exactly the number of bits needed to give a unique number to each of that many items, which is why it is used to calculate address widths from the size of a memory or the number of units.

For example, if a design contains 7 parallel adders and a signal selects which one is active, $clog2(7) gives 3, the minimum number of bits needed to number all 7 units.

module des
  #(parameter NUM_UNITS = 7)

  // Use of this system function helps to reduce the
  // number of input wires to this module
  (input [$clog2(NUM_UNITS)-1:0] active_unit);

  initial
    $monitor("active_unit = %b", active_unit);
endmodule

`define NUM_UNITS 5

module tb;
  integer i;
  reg [`NUM_UNITS-1:0]  active_unit;

  des #(.NUM_UNITS(`NUM_UNITS)) u0(active_unit);

  initial begin
    active_unit     = 1;
    #10 active_unit = 7;
    #10 active_unit = 8;
  end
endmodule

xcelium> run
active_unit = 001
active_unit = 111
active_unit = 000
xmsim: *W,RNQUIE: Simulation is complete.

The testbench overrides NUM_UNITS with 5, so the port active_unit of des is $clog2(5) = 3 bits wide, enough to select one of 5 units. The testbench, however, drives it from a 5-bit reg, so only the lowest 3 bits arrive at the port. Values 1 and 7 fit and are printed as 001 and 111. The value 8 is 01000 in binary, its lowest 3 bits are 000, and the module sees 0. Most simulators print a port size mismatch warning for this connection, which is a useful hint that the widths on the two sides were calculated differently.

Synthesis result: $clog2 with a constant argument, such as a parameter, is evaluated by the compiler before synthesis, so it is fully synthesizable and produces no hardware itself. It only decides how wide the port, register or counter is. Here, des gets a 3-bit input bus.

Real Math Functions

The real math functions take real arguments and return a real result. They behave like the equivalent functions of the C math library.

The testbench below calls most of these functions and prints the results. The trigonometric functions work in radians, so the example converts degrees to radians with an approximation of π as 22/7.

module tb;
  real x, y;

  initial begin
    x = 10000;
    $display("$log10(%0.3f) = %0.3f", x, $log10(x));

    x = 1;
    $display("$ln(%0.3f) = %0.3f", x, $ln(x));

    x = 2;
    $display("$exp(%0.3f) = %0.3f", x, $exp(x));

    x = 25;
    $display("$sqrt(%0.3f) = %0.3f", x, $sqrt(x));

    x = 5;
    y = 3;
    $display("$pow(%0.3f, %0.3f) = %0.3f", x, y, $pow(x, y));

    x = 2.7813;
    $display("$floor(%0.3f) = %0.3f", x, $floor(x));

    x = 7.1111;
    $display("$ceil(%0.3f) = %0.3f", x, $ceil(x));

    x = 30 * (22.0/7.0) / 180;   // convert 30 degrees to radians
    $display("$sin(%0.3f) = %0.3f", x, $sin(x));

    x = 90 * (22.0/7.0) / 180;
    $display("$cos(%0.3f) = %0.3f", x, $cos(x));

    x = 45 * (22.0/7.0) / 180;
    $display("$tan(%0.3f) = %0.3f", x, $tan(x));

    x = 0.5;
    $display("$asin(%0.3f) = %0.3f rad, %0.3f deg", x, $asin(x), $asin(x) * 7.0/22.0 * 180);

    x = 0;
    $display("$acos(%0.3f) = %0.3f rad, %0.3f deg", x, $acos(x), $acos(x) * 7.0/22.0 * 180);

    x = 1;
    $display("$atan(%0.3f) = %0.3f rad, %f deg", x, $atan(x), $atan(x) * 7.0/22.0 * 180);
  end
endmodule

xcelium> run
$log10(10000.000) = 4.000
$ln(1.000) = 0.000
$exp(2.000) = 7.389
$sqrt(25.000) = 5.000
$pow(5.000, 3.000) = 125.000
$floor(2.781) = 2.000
$ceil(7.111) = 8.000
$sin(0.524) = 0.500
$cos(1.571) = -0.001
$tan(0.786) = 1.001
$asin(0.500) = 0.524 rad, 29.988 deg
$acos(0.000) = 1.571 rad, 89.964 deg
$atan(1.000) = 0.785 rad, 44.981895 deg
xmsim: *W,RNQUIE: Simulation is complete.

Most results are exact, but the trigonometric lines show small errors: $cos of 90 degrees gives -0.001 instead of 0, and the angles come back as 29.988, 89.964 and 44.98 degrees instead of 30, 90 and 45. The functions themselves are accurate; the error comes from 22/7, which is 3.142857 instead of π = 3.141593. Calculating π as $acos(-1.0), or writing it with more digits, removes these errors. The last line also uses %f instead of %0.3f, which is why it prints six decimal places.

Synthesis result: Real variables and real math functions are not synthesizable as hardware. Some synthesis tools evaluate them when they only calculate a constant at elaboration time, for example a parameter derived from $ln or $sqrt, but that support varies between tools. Real math belongs in testbenches and behavioral models.

Common Beginner Mistakes

module mem #(parameter DEPTH = 100, parameter WIDTH = 8)
  (input                      clk, we,
   input  [$clog2(DEPTH)-1:0] addr,
   input  [WIDTH-1:0]         wdata,
   output reg [WIDTH-1:0]     rdata);

  reg [WIDTH-1:0] ram [0:DEPTH-1];

  always @(posedge clk) begin
    if (we) ram[addr] <= wdata;
    rdata <= ram[addr];
  end
endmodule

// In the testbench:
initial $display("Address width for 100 entries = %0d", $clog2(100));