Example:

 bit[1:0], int, byte etc

struct
{
   type1 field_name1;
   type2 field_name2;
   ....

} <struct_name>;

Access to a certain field: <struct_name>.<field_name>

struct packed
{
   type1 field_name1;
   ....

}<struct_name>;

Members of a packed structure can be accessed either by their name, or by indexing a vector. By default the first field will be the leftmost item in the vector:

Example:

struct packed 
{
   bit id;
   int addr;
   bit[7:0] data;

}my_struct;

In this case my_struct[0] is my_struct.data[0]

Example:

int my_array[];

my_array = new[10];           //an array of 10 elements

my_array = new[20];           //doubles the array size, discarding previous values

my_array = new[20](my_array); //doubles the array size, preserving previous values

int array_size;

array_size = my_array.size();

Example:

my_array.delete();

class my_class;
   static int number_of_instances = 0;

   function new();
      ++number_of_instances;
   endfunction

   static function int get_count()
      return number_of_instances;
   endfunction

endclass
instances_count = my_class::get_count();

Example:

class  my_class;
   int x;

   function new(int x);
      this.x = x;
   endfunction

endclass

Example:

class parent;
   //constructor
   string name = “parent”;
endclass

class child extends parent;
   //constructor
   string name = “child”;  //override
   function void get_parent_name();
      return super.name;
   endfunction
endclass

child c = new();

initial begin
   $display(c.name);            // child
   $display(c.get_parent_name); // parent
   ...
end

Example:

class my_class;
   const int id;
endclass

class my_class;
   //constructor;
   local int private;
   function void set_private(int x);
      private = x;
   endfunction
endclass

my_class  instance = new();
initial begin
   instance.private = 1;    // ERROR
   instance.set_private(1); // OK
   ...
end

class my_class;
   //constructor;
   protected int private;
endclass

class my_extended_class extends my_class
   //constructor;
   function void set_private(int x);
      private = x;
   endfunction
endclass

my_extended_class  instance = new();
initial begin
   instance.private = 1;      // ERROR
   instance.set_private(1);   // OK
   ...
end

class base_calculator;
   int result;
   function void sum(int a, int b)
      result = a + b;
   endfunction
endclass

class smart_calculator extends base_calculator;
   function void mul(int a, int b)
      result = a * b;
   endfunction
endclass

class base_class;
   int A = 1;
   int B = 2;
   function void printA();
      $display(“A from base: %d”, A)
   endfunction
   virtual function void printB();
      $display(“B from base: %d”, B)
   endfunction
endclass

class extended_class extends base_class;
   int A = 3;
   int B = 4;
   function void printA();
      $display(“A from extended: %d”, A)
   endfunction
   virtual function void printB();
      $display(“B from extended: %d”, B)
   endfunction
endclass

base_class base = new();
extended_class child = new();
initial begin
   base.printA;  // A from base 1
   base.printB;  // B from base 2
   base = child;
   base.printA;  // A from base 1
   base.printB;  // B from extended 4
   child.printA;  // A from extended 3
   child.printB;  // B from extended 4
end

^  ~^

Example:

&y will return the result of an AND operation between all the bits of y

Unlike logical equality operator, this operators can identify x and z.

rand int variable_name;

randc bit [1:0] x;

X can take on values in rage of 0 to 3. Randomize will compute an initial random permutation of the range values and return them in order on successive calls.

Initial permutation 0,2,1,3

next permutation 2,3,0,1

The values will be generated in the following order  0,2,1,3,2,3,0,1.

rand int random_value;
if(randomize(random_value))
   $display(“Successful randomization”);

The randomize function will return 1 if the randomization was successful or 0 otherwise.

Cannot be overridden!

class my_class;
   rand int random_value1, random_value2;
   int value;
enclass
my_class rand_obj;

obj.randomize(); // will randomize rand_value1 and rand_value2
obj.randomize(value) // will randomize value as declared as a rand property

class my_class
rand bit[27:0] data;
bit[3:0] crc;
constraint data_constraint{ data <= 32000}
function void pre_randomization()
   //disable constraint before randomization
   data_constraint.constraint_mode(0);
endfunction
endclass

class my_class;
rand bit[27:0] data;
bit[3:0] crc;
function void post_randomization()
   crc = compute_crc(data);
endfunction
endclass

Syntax:

solve rand_variable1 before rand_variable2

Example without solve…before…:

class  latch;
   rand bit set,reset;
   constraint random_value_c{
      set == 1 -> reset == 0;
   }
endclass
// ”->” will be explained in the next section

In this case we have three possible combinations (set,reset) = {(0,0);(0,1);(1,0)} each having a 33% chance of occurring.

Example with solve…before…:

class  latch;
   rand bit set,reset;
   constraint random_value_c{
      set == 1 -> reset == 0;
      solve set before reset;
   }
endclass

In this case set is solved first, so (set,reset) = (1,0) has a 50% chance of occurring, instead of 33%.

class my_class;
rand int my_array[100];
constraint my_constraint
{
   foreach(my_array[i])
   my_array[i] < 100;
}
endclass

class my_class;
rand int my_int;
constraint my_constraint
{
   soft my_int < 100;
}
endclass

my_class  rand_int = new();
rand_int.randomize() with { my_int >1000; }

class my_class;
   rand int random_value;
   constraint random_value_c{
      random_value  inside {[0:15]};
   }
endclass

Syntax:

variable_name dist {<range> <operator> <weight>};

The operator is one of the following

• := attributes the range a specific weight
• :/ equally divides the specified weight to all members of the range

Example:

class my_class;
   rand int random_value;
   constraint random_value_c{
      random_value  dist {
      0:=20,
      [1:10] :/ 80};
   }
endclass

Syntax:

randomize([properties]) [with {<constraints>};]

rand int random_value;
if(randomize(random_value) with {random_value < 50;})
   $display(“Successful randomization”);

Syntax:

boolean_statement -> constraint_item

Similar to:

if(boolean_statement)
   constraint_item

Syntax:

//[enables|disable] all class constraints
object.constraint_mode([1|0])
//[enables|disable] a certain constraint
objects.constraint_name.constraint_mode([1|0])

Syntax:

objects.constraint_name.constraint_mode()

range_list1 => range_list2
1,2 => 3,4
// This is equivalent to : (1 => 3), (1 => 4), (2 => 3), (2 => 4)

transition_item[*repeat_range]
1[*3] is equivalent to 1 => 1 => 1

transition_item[* low_limit:high_limit]

Example:

1[*2:3] is equivalent to (1 => 1), (1 => 1 => 1)

transfer_item[->repeat_range]

Examples:

1[->3] is equivalent to …=>1 … =>1 …=>1

Where … is any transition that does not contain the value 1

0 => 1[->3] => 0 // is equivalent to 0=>…=>1 … =>1 …=>1=>0

Notice that the last transition happens immediately after the second 1 to 1 transition.

transfer_item[=repeat_range]

Example:

1[->3] is equivalent to …=>1 … =>1 …=>1...

Where … is any transition that does not contain the value 1

0 => 1[->3] => 0 is equivalent to 0=>…=>1 … =>1 …=>1...=>0

Notice that the transition following the nonconsecutive repetition may occur after any number of transition as long as the value 1 doesn’t occur again.

bins name = {range};

wildcard bins name = {‘b11xx};

coverpoint addr iff(rst_n);
{
   bins null_addr = {0};
   bins valid_addr = {[10:20]};
   bins invalid_addr = default;
}

[label:]assert (boolean_expresion)
   // pass block
else
   //fail block
SIGNAL_ASSERTED_ERR: assert(signal) // pass block omitted
            else $error(“Assertion failed”);

[label:] assert property (property_name);
property my_property;
   @(posedge clk) (rst_n !== x && rst_n != Z)
endproperty
assert property (my_property);

[label:] cover property (property_name);
property my_property;
   @(posedge clk) (rst_n !== x && rst_n != Z)
endproperty
cover property (my_property);

signal_1 ##1 signal_2

signal_1 ##[0:2] signal_2 

 
      delay = 0

 
      delay = 1

 
      delay = 2

signal_1[*1:2] ##1 signal_2

 
      The length of signal1 is 1 clock cycle

      The length of signal1 is 2 clock cycle

signal_1[=2]

This is a shortcut for the following sequence

!start[*0:$] ##1 start ##1 !start[*0:$] ##1 start ##1 !start[*0:$] 

Example 2:

signal_1[=2] ##1 signal_2

signal_1[->2]

The difference between the two non-consecutive repetition is that the pattern
matching is finished after the last active pulse. This is a shortcut for the following sequence:

!start[*0:$] ##1 start ##1 !start[*0:$] ##1 start ##1

Observe that signal_1 is matched before returning to the LOW state.

Example 2:

signal_1[=2] ##1 signal2

sequence_1 |-> sequence_2

sequence_2 will start in the same clock cycle in which sequence_1 will end

Example:

signal_1 ##1 signal_2 |-> signal_3 ##1 signal_4

sequence_1 |=> sequence_2

sequence_2 will start one clock cycle after sequence_1 has ended

Example:

signal_1 ##1 signal_2 |=> signal_3 ##1 signal_4

Observation!
Seq1 |=> Seq2 is the same as Seq1 |-> ##1 Seq2

module my_module (input input_signal1,
                  input input_signal2,
                  output reg output_signal1);
   //module logic
endmodule
 
reg input1, input2;
wire output;
my_module module_name (.input_signal1(input1),
                       .input_signal2(input2)
                       .output_signal1(output))

interface my_interface(port1, port2...)
   //<parameters>
   //<modports>
endinterface

An interface can have different views by defining modports.

interface my_interface(input clk,
                       input rst);
   logic input_signal1, input_signal2, output_signal1;
 
   modport  transmit (
      input input_signal1, input_signal2,
      output output_signal1);
 
   modport receive (
      output input_signal1, input_signal2,
      input output_signal1);
endinterface

Module declaration:

module my_module (my_interface.transmit my_name);

virtual intarface_name virtual_interface_name;
 
interface my_interface(input logic clk, input logic rst_n)
   logic signal;
endinterface
   
class my_class;
virtual my_interface my_virtual_interface;
   //...
endclass