system verilog 句柄 ref参数传递 C语言指针

system verilog句柄 与 C语言指针：

oop面向对象特点：封装 继承 多态

C语言指针

将变量i的地址存放到指针变量p中，p就指向i

system verilog 句柄

sv对象的引用是采用对象句柄(object handle)，它与C指针概念接近，但又不完全相同

• 句柄的基本功能跟指针一样，都是用来指向具体对象，及句柄本身的值就是对象所占内存空间的起始地址
• 但句柄与指针相比，能力有限，区别主要体现在以下几方面
  

---

SV函数传入参数类型为 input / output / ref （静态数组/动态数组/队列）：

静态数组，动态数组或队列，是一样处理的

传递数组这种大片内存的值一般只有两种规则：

• 地址传递，函数内部修改可以改变函数调用的值。
• 值传递，将整片空间复制一份，函数内部修改不会改变函数调用的值。

// 函数f传入静态数组
function void run（）；
	int r[2];     // 静态数组
	r[0]=1;
	r[1]=2;
	f(r);     // 函数f传入静态数组
	$display("%0x %0x",r[0],r[1]);
endfunction
1
2
3
4
5
6
7
8

函数传入参数类型为 input

input是标准的值传递。 值传递，将整片空间复制一份，函数内部修改不会改变函数调用的值

// 函数f的定义
function void f(input int a[2]);  // 传入数组类型为 input int
	a[0]=3;
endfunction
1
2
3
4

输出结果：1 2

1. 函数调用之后，会将 r 复制一份到 a，函数 f 中处理的是 a 这份空间
2. 函数返回之后，a 空间会被释放掉，所以 r 的值并没有被修改

函数传入参数类型为 output

output 采用的是地址传递，确切的说是反向地址传递。 用新建的数组地址，替换原数组地址

// 函数f的定义
function void f(output int a[2]);  // 数组类型为 input int
	a[0]=3;
endfunction
1
2
3
4

输出结果是：3 0

1. 函数调用之后，新建一份 a 数组，函数 f 中处理的是 a 这份空间
2. 函数返回之后，会将 r 指向 a 空间，而原来的 r 指向的空间会被释放掉，所以 r 的值都被修改了

函数传入参数类型为 ref

ref采用的是标准的地址传递，只有一份数组，函数内部和调用出都是访问该空间

// 函数f的定义
function void f(ref int a[2]);   // 数组类型为 ref int
	a[0]=3;
endfunction
1
2
3
4

输出结果是： 3 2

1. 函数调用前，内存里只有 r 数组的空间
2. 函数调用之后，会将 a 指向 r 所在的空间，函数里面用的都是这份空间，修改的是这份空间的值，所以 a 和 r 的值都被修改

• input 是将函数外面的值传递到函数里面，调用之后，函数里面的值就被丢弃
• output 是将函数里面的值传递到函数外面来，调用之后，函数外面的值就被丢弃
• ref 是函数内部和外部看到的是同一份值，哪里都会被修改
• 采用 ref 关键字，占用的空间内存是最小的，因为只有一份数组，这样能提高效率

---

SystemVerilog ref的使用:

• ref 只能用于动态方法中；
• ref 引用的参数，此时方法对引用的修改将会同时反应在方法之外；反之，在方法调用期间，方法体外对被引用参数的修改，也会同时反应在方法之内；
• 如果期望方法对于引用只能进行“只读”访问，那么可以在 ref 的基础上增加 const 特性；
• ref 和 input、output、inout 不能连用；
• ref 指定的形参后在方法被引用时，形参类型和实参类型必须完全匹配，即使形参类型和实参类型可以自动转换也不行；

ref 只能用于动态方法中: task automatic , 不加动态关键字 automatic 编译错误

1. task automatic 方法外的 sig 发生变化时，方法内的显示任务也读取到了 sig 的变化
   

2. task automatic 方法内如果对引用的 sig 进行修改，也会引发方法外部 sig 的变化
   

3. 不期望方法对引用的变量进行修改，仅仅只能进行“只读”操作，在方法内修改变量将编译错误
   

ref使用时实参类型和形参类型必须完全匹配，eg：不能方法外是bit，方法内引用是int，编译错误：

---

SV函数传入参数类型为 input / output / ref （类）：

class c;
	int v0;
	int v1;
endclass

function void run();
	c c0;    // 声明变量类型是c类
	c0 = new();   // 实例化
	c0.v0 = 1;
	c0.v1 = 2;
	f(c0);
 	$display(" %0x %0x ", c0.v0 ,c0.v1);
 endfunction
 
 function voidf(input/output/ref c c0);
 	c0.v0 =3;
 endfunction
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果是：
input ： 3 2
output ：报null point 错误
ref： 3 2

class class_A;
    int a;
    function new(int a);
        this.a = a;
    endfunctionfunction void getA_ref(ref int a);
        a = this.a;
    endfunctionfunction void getA_value(int a);
        a = this.a;
    endfunctionfunction void setA(int a);
        this.a = a;
    endfunctionfunctionint getA();
        return a;
    endfunctionfunction void copy(class_A ca);
        this.a = ca.a;
    endfunction
endclassclass class_B;
    class_A ca;
    function new(class_A ca);
        this.ca = ca;
    endfunctionfunctionint setA(int a);
        ca.setA(a);
    endfunction
endclass

program automatic test;
    initialbegin
        class_A ca1;
        class_A ca2;
        class_B cb1;
        int a = 1;
        int b;

        b = a;            // 值拷贝
        b = 2;
        $display(a);    // 因为b是值拷贝，修改b不影响a，所以输出1
        ca1 = new(10);
        ca1.getA_value(a);  // 通过值传递方式获取函数内部值（且没有加output和inout）
        $display(a);            // 输出1，应为函数内部的a是a的一个值拷贝，函数修改不影响函数外的值。
        ca1.getA_ref(a);      // 同ref方式获取返回值。
        $display(a);             // a传递给函数内部的是引用，所以函数内部的修改，等效于修改了函数外的值。所以输出10
        ca2 = ca1;               // ca1为句柄变量，句柄拷贝    
        ca2.setA(20);           // 通过句柄ca2修改内部的域。
        $display(ca1.getA());// 因为ca2是ca1的句柄拷贝，所以ca2修改内部与，相当于修改了ca1的内部域，ca1和ca2指向相同空间。
        cb1 = new(ca1);
        cb1.setA(30);
        $display(ca1.getA());// 输出30，通过非ref的参数传递ca1其实也是传递的是ca1的句柄，所以在函数内修改ca1能够体现到函数外。
        ca2 = new(40);        // 分配一块新的空间，让ca2指向，这个时候ca1和ca2指向了不同的空间。
        $display(ca1.getA())；// 输出30
        $display(ca2.getA());  // 输出40end
endprogram
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

---

变量赋值

systemverilog 中的变量可以分为两种，一种普通变量类型，一种是句柄变量类型

• 内置类型，比如 int，bit，这些类型定义的变量都是普通变量
• 自定义的 class 通过 new 的方式定义的变量都是句柄变量

变量赋值

• 普通变量赋值，直接是拷贝值
• 句柄变量赋值，只是拷贝了句柄，使得两个句柄指向同一个空间
• system verilog 没有拷贝构造函数，所以句柄变量拷贝的时候只是进行了句柄的拷贝，没有进行指向空间的拷贝。为了完成指向空间的拷贝，一般实现的方式是先 new 一块空间，让后调用 copy 函数，copy 函数实现了拷贝构造函数的功能。

class_A ca1 = new(10);
class_A ca2 = new(12);  // ca2要先new好，分配空间。
ca2.copy(ca1);          // ca2拷贝ca1的数据
1
2
3

---