System Verilog
CLASSES
Introduction
System Verilog introduces an object-oriented class data
type.
Classes allow objects to be dynamically created, deleted,
assigned, and accessed via object handles.
A class is a type that includes data and subroutines
(functions and tasks) that operate on that data.
class’s data is referred to as class properties, and its
subroutines are called methods.
Futurewiz
www.futurewiz.co.in
Example1
class rectangle;
int length, width; //class properties
function int area(); //class method
return length * width;
endfunction
function int perimeter(); //class method
return 2*(length + width);
endfunction
endclass
Futurewiz
www.futurewiz.co.in
Example2
class person;
string name, address; //class properties
int number;
function void set_name(string user); //class method
name=user;
endfunction
endclass
Futurewiz
www.futurewiz.co.in
Example3
class packet;
bit [7:0] data; //class property
tast randomize(); //class method
data=$random;
endtask
task display();
$display(“data is %d”, data);
endtask
endclass
Futurewiz
www.futurewiz.co.in
Objects
A class defines a data type. An object is an instance of that
class.
An object is created by defining a handler of class type and
then calling new function which allocates memory to the
object.
packet p; //p is handler to class packet
initial
p=new(); //Object is constructed
If objects are not created then handler points to null.
Futurewiz
www.futurewiz.co.in
Default Constructor
new() is a default constructor which allocates memory and
initializes class variables for an object.
rectangle rec;
initial begin
rec=new; //memory allocated to length and width
int a, p;
rec.set_size(3, 5);
a=rec.area;
p=rec.perimeter; end
Futurewiz
www.futurewiz.co.in
Constructor
User can define customized constructers by writing there
own new function inside a class.
The new method is defined as a function with no return
type.
It is also possible to pass arguments to the constructor,
which allows run-time customization of an object.
function new (int x=0, y=0);
length=x;
width=y;
endfunction Futurewiz
www.futurewiz.co.in
Example
class rectangle; rectangle r1, r2, r3;
int lenght, width; int a1, a3, p1;
function new(int
x=1,y=1);..... initial begin
function int area(); r1=new(3, 5);
............. r2=new(4);
function int perimeter(); a1=r1.area;
.......... p1=r2.perimeter;
endclass
a3=r3.area; //error r3 is null
Result: a1=15 p1=10 end
Futurewiz
www.futurewiz.co.in
Parameterized Class
class packet #(number=10, type dtype= bit);
dtype data [number];
function void randomize1();
foreach(data[i]) data[i]=$random;
endfunction
function void display();
foreach(data[i]) $display(“data[%0d”]=%0d”, i, data[i]);
endfunction
endclass
Futurewiz
www.futurewiz.co.in
Parameterized Class
packet p1; //number=10, dtype=bit
packet #(20)p2; //number=20, dtype=bit
packet #( .dtype(int)) p3; //number=10, dtype=int
packet #(30, bit [3:0])p4; //number=30, dtype=bit [3:0]
initial begin
p1=new(); p2=new(); p3=new(); p4=new();
p4.display;
p4.randomize;
p4.display;
end
Futurewiz
www.futurewiz.co.in
This
The this keyword is used to unambiguously refer to class
properties or methods of the current instance.
The this keyword shall only be used within non-static
class methods, otherwise an error shall be issued.
class example;
Now a is property of class as well as
int a;
argument of function new.
function new(int a);
a=a; SV will look in local scope to resolve
endfunction reference to a, which in this case is
endclass subroutine argument.
Futurewiz
www.futurewiz.co.in
This
To solve this issue this keyword is used which now refers
to property a in current class instance.
class example; example x, y;
int a; initial begin
function new(int a); x=new(5);
this.a=a; y=new(3);
endfunction $display(x.a);
endclass $display(y.a);
end
Futurewiz
www.futurewiz.co.in
Fundamental Principles of OOP
Encapsulation
o It’s a concept that binds together the data and functions
that manipulate the data.
o Encapsulation keeps both data and function safe from
outside world i.e. data hiding.
Abstraction
o Abstraction is the concept of moving the focus from the
details and concrete implementation of things, to the
types of things, the operations available thus making
the programming simpler, more general.
Futurewiz
www.futurewiz.co.in
Fundamental Principles of OOP
Inheritance
o New classes are created by inheriting properties and
method defined in an existing class.
o Existing class is called the base class(parent class),
and the new class is referred to as
the derived class(child class).
Polymorphism
o polymorphism means having many forms.
o A member function will cause a different function to be
executed depending on the type of object that invokes
the function. Futurewiz
www.futurewiz.co.in
Inheritance
Inheritance allows user to create classes which are
derived from other classes.
The derived class (child class) inherits all the properties
and methods defined in base class (parent class).
Additional properties and methods can be defined in child
class.
properties and methods defined in base class can be
overridden by redefining them in child class. This
phenomenon is called as overriding.
Futurewiz
www.futurewiz.co.in
Example1
class parent; class child extends parent;
int a, b; int c;
task display(); task print();
$display(“Parent $display(“Child Class”);
Class”); endtask
endtask endclass
endclass
Futurewiz
www.futurewiz.co.in
Example1
parent p; parent p child c
child c; a=4 ; a=3 ;
initial begin b=0; b=0;
p=new; c=0;
c=new;
c.print;
Child Class
c.display;
Parent
c.a=3; Class
p.a=4;
end
Futurewiz
www.futurewiz.co.in
Example2
class parent; class child extends
int a, b; parent;
task display(); int a;
$display(“Parent task display();
Class”); $display(“Child Class”);
endtask endtask
endclass endclass
Display method and property a is overridden in child
class
Futurewiz
www.futurewiz.co.in
Example2
parent p;
parent p child c
child c;
a=2 ; a=7 ;
initial begin b=0; b=0;
p=new; c=0;
c=new;
c.display;
p.display; Child Class
Parent
c.a=7;
Class
p.a=2;
end
Futurewiz
www.futurewiz.co.in
Example3
A super keyword can be used to access properties and
methods defined in parent class from a child class.
class parent; class child extends
int a; parent;
task display(); int a, b;
$display(“Parent task display();
Class”); $display(“Child Class”);
endtask super.display;
endclass $display(super.a);
endtask
endclass Futurewiz
www.futurewiz.co.in
Example3
parent p;
parent p child c
child c;
a=5 ; a=6 ;
initial begin b=0;
p=new;
c=new;
p.a=5; Parent
Class
c.a=6;
Child Class
p.display; Parent
c.display; Class
end 0
Futurewiz
www.futurewiz.co.in
Inheritance
Every time when child object is created, constructer of
parent (super.new) is called first implicitly.
If a new function has been defined in parent which
accepts a set of arguments and arguments don’t have
default values. In such a case super.new has to be
explicitly specified with required arguments.
It is because of this reason that child class is able to
access properties and methods defined in parent class.
Futurewiz
www.futurewiz.co.in
Example4
class parent; class child extends
function new(); parent;
$display(“Parent function new();
Class”); $display(“Child Class”);
endfunction endfunction
endclass endclass
initial begin
Parent
child c;
Class
c=new; Child Class
end
Futurewiz
www.futurewiz.co.in
Example5
class parent; class child extends
function new(string parent;
str); function new();
$display(str); $display(“Child Class”);
endfunction endfunction
endclass endclass
initial begin
child c;
Error super.new is not
c=new;
called
end
Futurewiz
www.futurewiz.co.in
Example6
class parent; class child extends
function new(string str=“ parent;
”); function new();
$display(str); $display(“Child Class”);
endfunction endfunction
endclass endclass
initial begin
child c; Child Class
c=new;
end No error, parent constructor has default
value
Futurewiz
www.futurewiz.co.in
Example7
class parent; class child extends
function new(string parent;
str); function new();
$display(str); super.new(“Parent
endfunction Class”);
endclass $display(“Child Class”);
initial begin endfunction
child c; endclass
c=new; Parent
Class
end
Child Class
Futurewiz
www.futurewiz.co.in
Example8
class rectangle; class square extends
int length, width; rectangle;
int size;
function new(int x, y); function new(int size);
this.length=x; this.size=size;
this.width=y; super.new(size, size);
endfunction endfunction
function int area(int x, y);.... endclass
function int perimeter(int x, square sq=
y);... new(5);
sq.area;
endclass sq.perimeter;
Futurewiz
www.futurewiz.co.in
Encapsulation
Till now classes have members which were accessible to
rest of the program. However in many situation such
functionality are not desired.
Example: In cars we are not concerned by how engine
works but we focus on how to control it.
System Verilog provides various ways of hiding class
members:
o local keyword will ensure that the members are
available only to the method of the same class.
o protected keyword is similar to local keyword but
members can also be accessed by child class.Futurewiz
www.futurewiz.co.in
Example1
class rectangle; rectangle rec;
int length, width;
initial begin
function new(int x, y); rec=new(2, 3);
this.length=x; rec.area;
this.width=y; rec.length=5; //length is
endfunction modified
rec.area;
function int area; ….
endclass end
Futurewiz
www.futurewiz.co.in
Example2
class rectangle; rectangle rec;
local int length, width;
initial begin
function new(int x, y); rec=new(2, 3);
this.length=x; rec.area;
this.width=y; rec.length=5; //error
endfunction rec.area;
function int area; ….
end
endclass
Futurewiz
www.futurewiz.co.in
Example3
class rectangle; class square extends rectangle;
local int length, width; function new (int x);
function new(int x, y); super.new(x, x);
this.length=x; endfunction
this.width=y; endclass
endfunction
square sq;
function int area; …. initial sq=new(3);
endclass Error length and width are local to class
rectangle
Futurewiz
www.futurewiz.co.in
Example4
class rectangle; class square extends rectangle;
protected int length, width; function new (int x);
super.new(x, x);
function new(int x, y);
endfunction
this.length=x;
endclass
this.width=y;
endfunction square sq;
initial sq=new(3);
function int area; ….
endclass
Now length and width are accessible to both rectangle and
square Futurewiz
www.futurewiz.co.in
Lifetime in Class
By default properties and methods defined inside a class
have automatic lifetime.
Memory to properties are allocated dynamically when a
new instance of the class is created.
User can define properties and methods as static. A static
property is a class variable that is associated with the
class, rather than an instance of the class.
Futurewiz
www.futurewiz.co.in
Lifetime in Class
Memory to static properties and methods are allocated
during elaboration time.
Scope resolution operator ( :: ) can be used to access
static property and methods defined inside a class.
Static properties and methods can be accessed without
creating any instance of a class.
Futurewiz
www.futurewiz.co.in
Example1
packet p1, p2, p3;
class packet;
static int id; initial begin
int val; //default: automatic p1=new; $display(p1.id, p1.val);
p2=new; $display(p2.id, p2.val);
function new();
p3=new; $display(p3.id, p3.val);
id++;
p2.id=7; p2.val=3;
val++;
$display(p1.id, p1.val);
endfunction
$display(p2.id, p2.val);
endclass $display(packet :: id);
end
Futurewiz
www.futurewiz.co.in
Example1
Result :
p1.id= 1 p1.val=1
p2.id= 2 p2.val=1
p3.id= 3 p3.val=1
p1.id= 7 p1.val=1
p2.id= 7 p2.val=3
packet :: 7
Futurewiz
www.futurewiz.co.in
Example2
initial begin
class packet;
packet:: id=3;
static int id;
$display(packet::id);
int val; //default: automatic
packet p1;
function new(); p1=new;
id=id+1; $display(packet::id);
val=val+1; end
endfunction
Result
endclass id=3; id=4;
Futurewiz
www.futurewiz.co.in
Functions and Tasks
Task and Functions defined inside class have automatic
lifetime for their arguments and variables.
A static keyword can be added after Task/Function to
make arguments and variables static in nature.
A function prototype can be declared inside a class and
body can be defined outside class with help of extern
keyword.
Futurewiz
www.futurewiz.co.in
Example1
class test;
initial begin
task increment; test t1;
Result
int i; t1=new; :
i++; t1.increment; i=1
$display(“i=%d”, i); t1.increment; i=1
endtask t1.increment; i=1
end
endclass
Futurewiz
www.futurewiz.co.in
Example2
class test;
initial begin
task increment;
test t1;
static int x; Result:
t1=new;
int y; x=1 y=1
t1.increment;
x++; y++; x=2 y=1
t1.increment;
$display(“x=%d y=%d”, x, x=3 y=1
y); t1.increment;
endtask end
endclass
Futurewiz
www.futurewiz.co.in
Example3
class test;
task static increment; initial begin
int x; test t1; Result:
int y; t1=new; x=1 y=1
x++; y++; t1.increment; x=2 y=2
$display(“x=%d y=%d”, x, t1.increment; x=3 y=3
y); t1.increment;
endtask end
endclass
Futurewiz
www.futurewiz.co.in
Example4
class test;
initial begin
task static increment;
test t1; Result:
int x;
t1=new; x=1 y=1
automatic int y;
t1.increment; x=2 y=1
x++; y++;
t1.increment; x=3 y=1
$display(“x=%d y=%d”, x,
y); t1.increment;
endtask end
endclass
Futurewiz
www.futurewiz.co.in
Example5
function rectangle :: new(int
class rectangle; x, y);
local int length, width; this.length=x;
this.widht=y;
extern function new(int x, y);
endfunction
extern function int area();
endclass function int rectangle::area();
return length*width;
endfunction
Futurewiz
www.futurewiz.co.in
Functions and Tasks
Functions and Tasks can be local as well as protected.
Functions and Tasks can also be declared as static. The lifetime of
variables inside static methods are automatic by default.
Memory to static methods are allocated during elaboration time.
A static methods can only access static members of a class.
A static method can be called without creating instance of a class.
They can be accessed by scope resolution operator(::).
Futurewiz
www.futurewiz.co.in
Example1
class test;
int i;
initial begin
local function void increment; test t1;
i++; $display(“i=%0d”, i); t1=new; Result
endtask t1.inc; :
t1.inc; i=1
function void inc;
//t1.increment; will give
increment; i=2
//compilation error
endfunction
end
endclass
Futurewiz
www.futurewiz.co.in
Example2
class test;
initial begin
static function int add(int x, $display(test::add(3,2));
y); $display(test::add(1,1));
int i; end
i++;
$display(“i=%0d”, i); Result:
return x + y; 5 i=1
endfunction 2 i=1
endclass
Futurewiz
www.futurewiz.co.in
Example3
class test;
initial begin
int i;
$display(test::add(3,2));
static function int add(int x, $display(test::add(1,1));
y); end
i++;
$display(“i=%0d”, i);
return x + y; Result :
endfunction Error, Static function cannot access
non-static class properties
endclass
Futurewiz
www.futurewiz.co.in
Example4
class test;
initial begin
static int i;
$display(test::add(3,2));
static function int add(int x, $display(test::add(1,1));
y); end
i++;
$display(“i=%0d”, i); Result:
return x + y; 5 i=1
endfunction 2 i=2
endclass
Futurewiz
www.futurewiz.co.in
