ENCS5337: Chip Design Verification
Spring 2023/2024
SystemVerilog II
Dr. Ayman Hroub
Outline
Classes
Static Properties and Methods
Aggregate Classes
Inheritance
Polymorphism
Randomization
2
Classes (1)
Class is a user-defined data type
Classes must be declared in a module, package, interface, or a
program.
Class declaration contains data items (attributes/properties), and
subroutines (tasks and functions) operate on these data items
Class objects can be dynamically created and deleted during
simulation
Used in Object-Oriented (OO) programming for testbenches and
simulation models
module myModule
class myClass
bit[7:0] address;
bit[7:0] data;
endclass
…
3
Classes (2)
A variable of a class type is called a handle whose unintialized
value is null.
A class instance must be created for handle using a constructor.
Procedural call to function new
It allocates memory area to hold the instance
SystemVerilog has no destructor, i.e., automatic garbage
collection
module myModule
class myClass
bit[7:0] address;
bit[7:0] data;
endclass
myClass obj1 = new;
…
4
Class Attributes and Methods
class myClass
int address;
int data;
task setData (input int newData)
data = newData
endtask
function int getData()
return data;
endfunction
...
endclass
myClass obj1 = new;
initial begin
obj1.data = 10; // or obj1.setData(10)
end
5
External Method Declaration
It is used for better readability
Define the method prototype in the class prefixed by the
keyword extern
The prototype is the first line that identifies the method
type, name, and arguments
extern function int getData();
Then, the method is implemented outside the class
declaration, but in the same scope
function int myClass::getData();
return data;
endfunction
6
External Method Example
7
Implicit (Default) Class Constructor
Method new is special class method called
constructor.
Defined by default for all classes.
When the object is created using the new
constructor, the object’s fields are
initialized to their default initial values
based on their data type
8
Explicit Class Constructor
You can explicitly define the constructor to
initialize the object’s fields
The function new will not have a return
type, even it is not allowed to have a void
as a return value
class myClass
int address;
function new()
address = 100;;
endfunction
...
endclass
myClass obj1 = new; //obj1.data is 100
9
Explicit Constructor with Arguments
class myClass
int address;
function new(input int a)
address = a;;
endfunction
...
endclass
myClass obj1 = new (200); //obj1.data is initialized to 200
10
Complete Class Example
11
this Keyword
The this keyword is used to unambiguously refer to
class properties, value parameters, local value
parameters, or methods of the current instance.
this keyword shall be used within non-static class
methods, constraints, etc.
class Demo;
integer x;
function new (integer x);
this.x = x;
endfunction
endclass
12
Outline
Classes
Static Properties and Methods
Aggregate Classes
Inheritance
Polymorphism
Randomization
13
Static Attributes
The class attributes are dynamic by default,
i.e., each class instance has its own copy of
the attributes
Regarding static attributes, one copy of the
attribute is shared among all class objects
They are allocated in memory at elaboration
They can be accessed using null handles
14
Static Attributes: Example
15
Static Methods
Can only access static attributes or other
static methods
Besides any class handle, they can be
called from the class name using the
resolution operator ::
16
Static Methods Example
17
Outline
Classes
Static Properties and Methods
Aggregate Classes
Inheritance
Polymorphism
Randomization
18
Aggregate Classes
A class attribute can be an instance of
another class
The constructors of the class attributes
must be called explicitly.
Instance handles must be chained to
reach into hierarchy
19
Aggregate Class Example
20
Outline
Classes
Static Properties and Methods
Aggregate Classes
Inheritance
Polymorphism
Randomization
21
Inheritance (1)
A class extends another class using the keyword extends.
Only single inheritance is allowed, i.e., each subclass has
only one parent
The subclass inherits all the members of the parent class
It can add more members
It can re-declare (override) parent members
Parent members are accessed as if they were members of
the subclass
The parent’s constructor is automatically called by the
subclass constructor
As the first line of the of the subclass’s constructor
22
Inheritance (2)
23
Inheritance (3)
Super keyword allows the subclass to access the parent
members
You can only pass arguments one level at a time.
super.super.new() is NOT allowed
24
Simple Inheritance Example
25
Inheritance with Constructors Example
26
Polymorphism (I)
Polymorphism allows the use of a variable of the
superclass (even if it is an abstract class) type to hold
subclass objects and to reference the methods of those
subclasses directly from the superclass variable
(handle).
packets[1].send(); shall invoke the send method
associated with the TokenPacket class
BasePacket packets[100];
EtherPacket ep = new; // extends BasePacket
TokenPacket tp = new; // extends BasePacket
packets[0] = ep;
packets[1] = tp;
27
Polymorphism (II)
28
Virtual Methods
A method of a class may be identified with the keyword
virtual
A virtual method shall override a method in all of its base classes
A non-virtual method shall only override a method in that class
and its descendants
Virtual method overrides in subclasses shall have the same
prototype of the function in the superclass including the
arguments names.
However, the return type of a virtual function shall be either a
matching type or a derived class type
29
Virtual Methods Example
30
Abstract Classes & Pure Virtual Methods (1)
A base class may be characterized as being abstract by
identifying it with the keyword virtual
We cannot construct objects directly from an abstract class
The abstract class constructor may only be called indirectly
through the chaining of constructor calls originating in an
extended non-abstract object.
A pure virtual is a method in an abstract class that is declared
as a prototype only without providing an implementation
The pure virtual method shall be indicated with the
keyword pure together without an implementation
An extended subclass may provide an implementation by
overriding the pure virtual method with a virtual method
having a method body.
31
Abstract Classes & Pure Virtual Methods (2)
Abstract classes may be extended to further abstract
classes
But, all pure virtual methods shall have overridden
implementations in order to be extended by a non-
abstract class
Any class may be extended into an abstract class, and
may provide additional or overridden pure virtual
methods.
32
Abstract Class Example
33
Outline
Classes
Static Properties and Methods
Aggregate Classes
Inheritance
Polymorphism
Randomization
34
Randomization
Class attributes can be defined as random using rand
and randc
rand: random with uniform distribution
randc : random-cyclic randomly iterates through all
values without repetition
– When an iteration is complete, a new random iteration
automatically starts
35
randomize() Function
randomize() function randomizes the object’s random
attributes.
Every class has a built-in randomize() virtual method.
You cannot re-declare this method
It returns 1 on success, 0 otherwise.
36
pre_randomize()and post_randomize()
randomize() automatically calls two “callback”
functions:
– pre_randomize() before randomization.
– post_randomize() after successful randomization.
If defined, these methods are automatically called on
randomization.
The pre/post_randomize declarations must match
the prototypes shown, i.e., they must be void functions
with no arguments.
37
pre_randomize()and post_randomize()Example
38
Randomization in Aggregate Classes
Randomize can operate hierarchically on aggregate
classes
– The class instance property must be declared as rand.
– Otherwise, that instance is skipped for randomization.
39
Randomization in Aggregate Classes: Example
40
In-Line Random Variable Control with randomize()
Specific class variables can be randomized by passing
them as arguments.
– This allows nonrandom (state) properties to be randomized (not
cyclic)
41
Controlling Randomization: rand_mode()
Every random attribute has an enable switch rand_mode
– Enabled by default (1)
– If disabled (0), the attribute will not be randomized
Mode can be written with task rand_mode and read with
function rand_mode
Called off a random property, the task changes the mode
of that property.
Called off an instance, the task changes the mode or all
random properties of the instance.
Only random attributes have rand_mode
– Calling method off a non-random attribute generates a compile
error
42
rand_mode()Example
43
Constraint Blocks
Constraints restrict the random data generation to exclude
values or change the probability distribution
Constraints can be embedded in classes using constraint
blocks
You declare a constraint block as a class member with the
constraint keyword, followed by an identifier, followed
by a list of constraint items enclosed within curly braces {}
A block can contain any number of any form of constraints
44
Constraint Blocks Example
45
Constraint Block Inheritance
Constraint blocks are class members and are inherited
just like any other members
46
inside Operator
The inside operator is particularly useful in constraint
expressions.
– The operator can also be negated to generate a value outside of a set.
47
Weight Distributions
You can change distribution by defining weights for values using
the operator dist operator .
– Default value is 1
:= operator assigns weight to the item or every value in the range
:/ operator divides the weight by the number of values in the
range, i.e., for a range of n values and a weight of w, the weight of
each individual value is w/n.
Fractional weights are possible
Negative weights are not possible
48
Weight Distributions Examples
49
Conditional Constraints
Implication, using -> operator
if … else
50
Iterative Constraints
You can use a loop to apply separate constraints to each
array element
Can affect performance for large arrays or complex
constraints.
51
Constraint_mode()
Every constraint block has an enable switch called
constraint_mode.
– Enabled by default (1).
– If disabled (0), the constraint block will not be used.
Mode can be written with task constraint_mode.
Mode can be read with function constraint_mode.
Only constraint blocks have constraint_mode.
52
Constraint_mode() Example
53
Randomization Procedure and Its Effects
Randomization proceeds as follows:
– All randc properties randomized simultaneously.
– Then all rand properties randomized simultaneously.
– Then constraints are checked.
– Cycle iterates until a solution is found or the random space is
exhausted.
▪ You can only order rand variables of integral types.
54
