UVM实战 卷I学习笔记15——附录A SystemVerilog使用简介

---

SystemVerilog是一种面向对象的编程语言。与非面向对象的编程语言相比，面向对象语言最重要的特点是所有功能都要在类(class)里实现。

结构体的使用

非面向对象编程最常用的是函数。要实现一个功能，就要实现相应函数。要实现的功能较简单时，函数可轻易完成目标。如计算一串数据流的CRC校验值，虽然CRC的算法比较复杂，但完全可以用一个函数实现。但当要实现的功能比较复杂时，仅使用函数实现会显得比较笨拙。

假设某动物园要实现一个简单的园内动物管理系统，这个系统要具有如下的功能：

• 统计园内所有的动物的信息，如名字、出生年月、类别（是否能飞翔）、每天进食量、是否健康等。
• 打印动物园内所有动物的信息。

要实现上述这些功能，仅考虑如何写函数是不够的，需要考虑如何存储这些信息，即要考虑数据结构。程序设计=算法+数据结构。所以在程序设计开始阶段定一个好的数据结构就相当于成功了一半。在程序设计语言中，一般都支持结构体。以C语言为例，可使用struct声明一个结构体：

struct animal {
	char name[20];
	int birthday;/*example: 20030910*/
	char category[20];/*example: bird, non_bird*/
	int food_weight;
	int is_healthy;
};

当声明结构体后可以定义结构变量，并将结构变量作为函数的参数来实现上述功能：

void print_animal(struct animal * zoo_member){
	printf("My name is %s\n", zoo_member->name);
	printf("My birthday is %d\n", zoo_member->birthday);
	printf("I am a %s\n", zoo_member->category);
	printf("I could eat %d gram food one day\n", zoo_member->food_weight);
	printf("My healthy status is %d\n", zoo_member->is_healthy);
}
void main()
{
	struct animal members[20];
	strcpy(members[0].name, "parrot");
	members[0].birthday = 20091021;
	strcpy(members[0].category, "bird");
	members[0].food_weight = 20;
	members[0].is_healthy = 1;
	print_animal(&members[0]);
}

从结构体到类

结构体简单地将不同类型的数据放在一起，使它们的集合体具有某种特定意义。与这个结构体相对应的是一些函数操作。对于这些函数来说，如果没有了结构体变量，它们就无法使用；对结构体变量来说，如果没有这些函数，那么结构体也没有任何意义。

对于二者间如此亲密的关系，面向对象的开创者开创了类(class)的概念。类将结构体和其相应函数集合在一起，成为一种新数据组织形式。在这种新数据组织形式有两种成分，一种是来自结构体的数据变量，在类中被称为成员变量；另一种来自与结构体相对应的函数，被称为一个类的接口：

class animal;
	string name;
	int birthday;/*example: 20030910*/
	string category;/*example: bird, non_bird*/
	int food_weight;
	int is_healthy;
	function void print();
		$display("My name is %s", name);
		$display("My birthday is %d", birthday);
		$display("I am a %s", category);
		$display("I could eat %d gram food one day", food_weight);
		$display("My healthy status is %d", is_healthy);
	endfunction
endclass

当一个类被定义好后需将其实例化才可使用，实例化完成后可调用其中的函数：

initial begin
	animal members[20];
	members[0] = new();
	members[0].name = "parrot";
	members[0].birthday = 20091021;
	members[0].category = "bird";
	members[0].food_weight = 20;
	members[0].is_healthy = 1;
	members[0].print();
end

这里使用了new函数，这是一个比较特殊的函数，在类的定义中没有出现new的定义，但却可以直接使用它。面向对象编程的术语中，new被称为构造函数。编程语言会默认提供构造函数，故可以不定义而直接使用它。

类的封装

如果只将结构体和函数集合在一起，那类的优势并不明显，面向对象编程也不会如此流行。让面向对象编程流程的原因是类还具有一些特征。这些特征是面向对象的精髓。通常来说类有三大特征：封装、继承和多态。

上节例子中，animal所有成员变量对外部都是可见的，所以在initial语句中可直接使用直接引用的方式对其进行赋值。这种直接引用的方式某种情况下是危险的。当不小心将它们改变后，那么可能会引起致命的问题，有点类似于全局变量。由于对全局可见，所以全局变量的值可能被程序的任意部分改变，从而导致一系列问题。

为避免这种情况，面向对象的开发者们设计了私有变量（SV中为local，其他编程语言各不相同）这一类型。当一个变量被设置为local类型后，那么这个变量就会具有两大特点：

• 此变量只能在类的内部由类的函数/任务进行访问。
• 在类外部使用直接引用的方式进行访问会提示出错。

class animal;
	string name;
	local int birthday;/*example: 20030910*/
	local string category;/*example: bird, non_bird*/
	local int food_weight;
	local int is_healthy;
endclass

由于不能进行直接引用式的赋值，所以需要在类内部定义一个初始化函数对类进行初始化：

function void init(string iname, int ibirthday, string icategory, int ifood _weight, int iis_healthy);
	name = iname;
	birthday = ibirthday;
	category = icategory;
	food_weight = ifood_weight;
	is_healthy = iis_healthy;
endfunction

除成员变量可被定义为local类型外，函数/任务也可被定义为local类型。这种情况通常用于某些底层函数，如animal有函数A，它会调用函数B。B函数不会也不应被外部调用，这种情况下就可以将其声明为local类型的：

local function void B();
…
endfunction

类的继承

面向对象编程的第二大特征就是继承。在动物园中有两种动物，能飞行的鸟类和不能飞行的爬行动物。假设动物园有100只鸟类、200只爬行动物。建立动物园管理系统时需要实例化100个animal变量，这些变量的category都设置为bird；同时要实例化200个animal变量，这些变量的category都设置为non_bird。100次或200次做同样的事情比较容易出错。

考虑到这种情况，面向对象编程的开创者提出继承的概念。分析要解决的问题并找出其中的共性，用这些共性构建一个基类（父类）；在此基础上将问题分类，不同分类具有各自的共性，使用这些分类的共性构建派生类（子类） 。

一个动物园所有动物都可抽像成上节所示的animal类，在animal类的基础上派生（继承）出bird类和non_bird类：

class bird extends animal;
	function new();
		super.new();
		category = "bird";
	endfunction
endclass
class non_bird extends animal;
	function new();
		super.new();
		category = "non_bird";
	endfunction
endclass

当子类从父类派生后，子类天然地具有了父类所有特征，父类的成员变量/成员函数也是子类的成员变量/成员函数。除具有父类所有特征外，子类还能有自己额外的成员变量和成员函数，如对于bird类，可自定义fly函数：

class bird extends animal;
	function void fly();
		…
	endfunction
endclass

讲述封装时提到了local类型成员变量。如果一个变量是local类型，那么它不能被外部直接访问。如果父类中某成员变量是local类型，那么子类是否可以使用这些变量？答案是否定的。对父类来说子类算是“外人”，是比较特殊的“外人”而已。如果想访问父类中的成员变量，同时不想让这些成员变量被外部访问，那么可以将这些变量声明为protected类型：

class animal;
	string name;
	protected int birthday;/*example: 20030910*/
	protected string category;/*example: bird, non_bird*/
	protected int food_weight;
	protected int is_healthy;
endclass

与local类似，protected同样可以应用于函数/任务中。

类的多态

多态是面向对象编程中最神奇的一个特征，但同时也是最难理解的。

假设在animal中有函数print_homehown：

class animal;
	function void print_hometown();
		$display("my hometown is on the earth!");
	endfunction
endclass

同时，在bird和non_bird类中也有自己的print_hometown函数：

class bird extends animal;
	function void print_hometown();
		$display("my hometown is in sky!");
	endfunction
endclass
class non_bird extends animal;
	function void print_hometown();
		$display("my hometown is on the land!");
	endfunction
endclass

现在，有一个名字为print_animal的函数：

function automatic void print_animal(animal p_animal);
	p_animal.print();
	p_animal.print_hometown();
endfunction

print_animal的参数是一个animal类型的指针，如果实例化了一个bird并将其传递给print_animal函数，这样做是完全允许的，因为bird是从animal派生的，所以bird本质上是个animal：

initial begin
	bird members[20];
	members[0] = new();
	members[0].init("parrot", 20091021, "bird", 20, 1);
	print_animal(members[0]);
end

只是这样打印的结果是“my hometown is on the earth！ ”，而期望结果是“my hometown is in sky！”。如果要想得到正确结果，那么在print_animal函数中调用print_hometown之前要进行类型转换：

function automatic void print_animal2(animal p_animal);
	bird p_bird;
	non_bird p_nbird;
	p_animal.print();
	if($cast(p_bird, p_animal))
		p_bird.print_hometown();
	else if($cast(p_nbird, p_animal))
		p_nbird.print_hometown();
endfunction

如果将members[0]作为参数传递给此函数，那么可以得到期待的结果。cast是一个类型转换函数。从animal向bird或non_bird类型的转换是父类向子类的类型转换，这种类型转换必须通过cast来完成。而子类向父类的类型转换可以由系统自动完成，如调用print_animal时members[0]是bird类型的，系统自动将其转换成animal类型。

但print_animal2的作法显得非常复杂，且代码的可重用性不高。现在只有bird和non_bird类型，如果再多加一种类型，那么就需要重新修改这个函数。在调用print_animal和print_animal2时，传递给它们的members[0]本身是bird类型的，那么有没有一种方法可以自动调用bird的print_hometown函数呢？这个问题的答案就是虚函数。

在animal、bird、non_bird中分别定义print_hometown2函数，只是在定义时其前面要加上virtual关键字：

class animal;
	virtual function void print_hometown2();
		$display("my hometown is on the earth!");
	endfunction
endclass
class bird extends animal;
	virtual function void print_hometown2();
		$display("my hometown is in sky!");
	endfunction
endclass
class non_bird extends animal;
	virtual function void print_hometown2();
		$display("my hometown is on the land!");
	endfunction
endclass

在print_animal3中调用此函数：

function automatic void print_animal3(animal p_animal);
	p_animal.print();
	p_animal.print_hometown2();
endfunction

在initial语句中将members[0]传递给此函数后，打印出的结果就是“my hometown is in sky！”，这正是想要的结果。如果在initial中实例化了一个non_bird并将其传递给print_animal3：

initial begin
	non_bird members[20];
	members[0] = new();
	members[0].init("tiger", 20091101, "non_bird", 2000, 1);
	print_animal(members[0]);
end

打印的结果就是“my hometown is on the land！”。在print_animal3中同样都是调用print_hometown2函数，但输出结果却不同，表现出不同形态，这就是多态。多态的实现要依赖于虚函数；普通函数，如print_hometown是不能实现多态的。

randomize与constraint

SV是一门用于验证的语言。验证很重要的一条是能够产生一些随机激励。为此，SV为所有类定义了randomize方法：

class animal;
	bit [10:0] kind;
	rand bit[5:0] data;
	rand int addr;
endclass
initial begin
	animal aml;
	aml = new();
	assert(aml.randomize());
end

在一个类中只有定义为rand类型的字段才会在调用randomize方法时进行随机化。定义中的data和addr会随机化为一个随机值，而kind在randomize被调用后，依然是默认值0。

与randomize对应的是constraint，这是SV中非常有特色也是非常有用的一个功能。在不加任何约束的情况下，上述animal中的data经过随机化后，其值为0～’h3F中的任一值。可以定义一个constraint对其值进行约束：

class animal;
	rand bit[5:0] data;
	constraint data_cons{
		data > 10;
		data < 30;
	}
endclass

经过上述约束后data在随机时，其值将会介于10～30之间。

除了在类的定义时对数据进行约束外，还可以在调用randomize时对数据进行约束：

initial begin
	animal aml;
	aml = new();
	assert(aml.randomize() with {data > 10; data < 30;});
end