SV学习笔记（五）

线程的使用

程序和模块

module（模块）作为SV从verilog继承过来的概念，自然地保持了它的特点，除了作为RTL模型的外壳包装和实现硬件行为，在更高层的集成层面，模块之间也需要通信和同步。
对于硬件的过程块，他们之间的通信可理解为不同逻辑/时序块之间的通信或同步，是通过信号的变化来完成的。
从硬件实现角度来看，Verilog通过Always、initial过程语句块和信号数据连接实现进程间通信。
我们可以将不同的module作为独立的程序块，他们之间的同步通过信号的变化（event触发）、等待特定事件（时钟周期）或时间（固定延时）来完成。
如果按照软件的思维理解硬件仿真，仿真中各个模块首先是独立运行的线程（thread）。
模块（线程）在仿真一开始便并行执行，除了每个线程会依照自身内部产生的事件来触发过程语句块之外，也同时依靠相邻模块间信号变化来完成模块之间的线程同步。

什么是线程

线程即独立运行的程序。
线程需要被触发，可以结束或者不结束。
在module中的initial和always，都可以看做独立的线程，它们会在仿真0时刻开始，而选择结束或者不结束（对initial而言）。
硬件模型中由于都是always语句块，所以可以看成是多个独立运行的线程，而这些线程会一直占用仿真资源，因为它们不会结束。
软件测试平台中的验证环境都需要initial语句块去创建，而在仿真过程中，验证环境中的对象可以创建和销毁，因此软件测试端的资源占用是动态的。
软件环境中的initial块对语句有两种分组方式，使用 begin…end 或 fork…join 。
begin…end 中的语句是顺序执行的，而 fork…join 中的语句是并发执行的。
与 fork…join 类似的并发执行语句还有 fork…join_any 和 fork…join_none。

线程的概念澄清

线程的执行轨迹是呈树状结构的，即任何线程都应该有父线程。
父线程可以开辟若干子线程，父线程可以暂停或终止子线程 。
当子线程终止时，父线程可以继续执行。
当父线程终止时，其开辟的所有子线程都应当会终止。

线程的控制

fork并行线程语句块

linux中的线程也是通过fork来创建的

fork…join

initial begin$display("@%0t: start fork...join example", $time);#10 $display("@%0t: sequential after #10", $time);fork$display("@%0t: parallel start", $time);#50 $display("@%0t: parallel after #50", $time);#10 $display("@%0t: parallel after #10", $time);begin#30 $display("@%0t: sequential after #30", $time);#10 $display("@%0t: sequential after #10", $time);endjoin$display("@%0t: after join", $time);#80 $display("@%0t: finish after 80", $time);
end

@0: start fork...join example
@10: sequential after #10
@10: parallel start
@20: parallel after #10
@40: sequential after #30
@50: sequential after #10
@60: parallel after #50
@60: after join
@140: finish after 80

总结：可见fork…join内是并行执行的，initial块内程序作为父线程，并创建了四个子线程。

$display…
#50 $display…
#10 $display…
begin #30 $display… #10 $display… end

fork…join_any

initial begin$display("@%0t: start fork...join_any example", $time);#10 $display("@%0t: sequential after #10", $time);fork$display("@%0t: parallel start", $time);#50 $display("@%0t: parallel after #50", $time);#10 $display("@%0t: parallel after #10", $time);begin#30 $display("@%0t: sequential after #30", $time);#10 $display("@%0t: sequential after #10", $time);endjoin_any$display("@%0t: after join_any", $time);#80 $display("@%0t: finish after 80", $time);
end

@0: start fork...join_any example
@10: sequential after #10
@10: parallel start
@10: after join_any
@20: parallel after #10
@40: sequential after #30
@50: sequential after #10
@60: parallel after #50
@90: finish after 80

总结：子线程的创建与fork…join是一致的，不同的是，fork…join要等所有子线程执行完毕才会继续执行父线程的程序，而fork…join_any中只要有一个子线程（最短的）执行完毕，父线程的程序就会被执行的。

等待所有衍生线程

在SV中，当程序中的initial块全部执行完毕，仿真器就退出了，也就是如果以上测试代码中没有最后的…finish after…语句，对于join_any和join_none其子线程没有全部执行完毕仿真就结束了。
如果需要等待所有fork块中的子线程全部执行完毕在退出结束initial块，可以使用wait fork语句来等待所有子线程结束。

task run_thread;...forkcheck_trans(tr1); //thread1check_trans(tr2); //thread2check_trans(tr3); //thread3join_none...// 等待所有fork中的线程结束wait fork;
endtask

停止单个线程

在使用了fork…join_any和fork…join_none以后，我们可以使用disable来指定需要停止的线程。

parameter TIME_OUT = 1000;
task check_trans(transaction tr);fork begin// 等待回应或达到某个最大延时fork : timeout_blockbeginwait (bus.cb.addr == tr.addr);$display("@%0t: Addr match %d", $time, tr.addr);end#TIME_OUT $display("@%0t: Error: timeout", $time);join_anydisable timeout_block;endjoin_none
endtask

停止多个线程

disable fork可以停止从当前线程中衍生出来的所有子线程。

initial begincheck_trans(tr0); //线程0//创建一个线程来控制disable fork的作用范围fork //线程1begincheck_trans(tr1); //线程2fork //线程3check_trans(tr2); //线程4join// 停止线程1-4， 单独保留线程0#(TIME_OUT/2) disable fork;endjoin
end

其实最准确的关闭线程的方法是，给定线程的标号，关闭指定的线程。

停止被多次调用的任务

如果给线程指明标号，那么当这个任务或线程被多次调用后，使用disable去终止这个线程时，会将所有的同名线程全部终止。
在创建task时，如果使用disable进程标号，一定要确认该task是否会被多处调用，如果多处调用要避免使用disable进程标号。

线程的通信

写在前面

测试平台中的所有线程都需要同步并交换数据。
一个线程可能需要等待另一个线程。
多个线程可能同时访问同一个资源。
线程之间可能需要交换数据。
所有这些数据交换和同步称之为线程间的通信（IPC，Interprocess Communication）。

event事件

verilog中，一个线程总是要等待一个带@操作符的事件。这个操作符是边沿敏感的，所以它总是阻塞着、等待着事件的变化。
其他线程可以通过->操作符来触发事件，结束对一个线程的阻塞。
这就像在打电话时，一个人等待另一个人的呼叫。
测试代码（注意，event需声明而不需要new）：

event el,	e2;
initial begin$display("@t0t: 1: before trigger", $time);-> el;@e2;$display("@%0t: 1: after trigger", $time);
endinitial begin$display("@t0t: 2: before trigger", $time);-> e2;@e1;$display("@t0t: 2: after trigger", $time);
end

@0: 1: before trigger
@0: 2: before trigger
@0: 1: after trigger

总结：

第一个initial启动，触发e1事件，然后阻塞在e2上。
第二个initial启动，触发e2事件，然后阻塞在e1上。
e1和e2同一时刻被触发，但由于delta cycle的时间差使得两个initial块可能无法等到e1或e2。（根据上面的执行结果，可以分析得出，虽然是同一时刻，initial 1 还是被先执行了，先打印了before，然后拨打了电话（e1），然后等待接电话（e2），此时initial 2被执行，打印了before，拨打电话（e2），此时initial已经等待接听电话，所以initial 1打印了after，也就是接通了电话，而initial 2是接不到电话的，因为在接听之前tinitial 1已经拨出去了，所以没有打印出after）
也就是，等待事件触发要在事件发生之前，否则将错过事件，所以，更安全的方式可以使用event的方法triggered()，相当于为拨打电话提供了留言功能。

进一步：

event el,	e2;
initial begin$display("@t0t: 1: before trigger", $time);-> el;wait (e2.triggered());$display("@%0t: 1: after trigger", $time);
endinitial begin$display("@t0t: 2: before trigger", $time);-> e2;wait (e1.triggered());$display("@t0t: 2: after trigger", $time);
end

@0: 1: before trigger
@0: 2: before trigger
@0: 1: after trigger
@0: 2: after trigger

总结：

对于triggered()而言，如果事件在当前时刻已经被触发，则不会引起阻塞，否则会一直等到事件被触发为止。
这个方法相对@而言，更有能力保证，只要event被触发过，就可以防止引起阻塞。

通知的需求

不同的线程之间，有时会有互相告知的需求。比如，我们要开一辆车，在踩油门要行驶之前，首先得看一下汽车有没有发动，那么这辆车可能是这样设计的：

module road;initial beginautomatic car byd = new();byd.drive();end
endmoduleclass car;bit start=0;task launch();start=1;$display(”car is launched”);endtasktask move();wait(start==1);$display(”car is moving”);endtasktask drive();forkthis.launch();this.move() ;joinendtask
endclass//输出结果：
// car is launched
// car is moving

以上的例子可以看出，两个线程launch和move是通过线程间共享变量car::start和wait语句来实现了线程launch通知线程move的功能。
我们也可以将线程间共享变量car::start改为事件来触发。

class car;event e_start;task launch();-> e_start;$display(”car is launched”);endtasktask move();wait(e_start.triggered());$display(”car is moving”);endtasktask drive();forkthis.launch();this.move() ;joinendtask
endclass

当汽车要加速的时候，添加速度显示功能：

module road;initial beginautomatic car byd = new();byd.drive();byd.speedup();byd.speedup();byd.speedup();end
endmoduleclass car;event e_start;event e_speedup;int speed = 0;......task speedup();#10ns;-> e_speedup;endtasktask display();forever begin@e_speedup;speed++;$display("speed is %0d", speed);endendtasktask launch();start=1;$display(”car is launched”);endtasktask move();wait(start==1);$display(”car is moving”);endtasktask drive();forkthis.launch();this.move() ;this.display() ;join_noneendtask
endclass//输出结果：
// car is launched
// car is moving
// speed is 1
// speed is 2
// speed is 3

这里有两点值得分析：

为什么使用@e_speedup？

因为使用 triggered的话，再第一次触发以后，下次会认为已经触发过而不再继续等待触发，这和设计功能是违背的，这里需要对@和triggerd按功能区分使用（UVM中提供一种event使用方式，当第一次事件触发以后，会清除此次触发，这样就不存在triggerd的问题了）。

为什么改为join_none？

因为父线程中的speedup需要和三个子线程并行执行。

总结：

从这个汽车加速的例子来看，如果你需要一直踩着油门不放的话，这个加速的event必定会被不断触发，而当线程A要给线程B传递超过一次事件时，使用公共变量就不再是一个好的选择了。

通过event的触发，可以多次通知另一个线程，注意此时应该使用@。

semaphore旗语

semaphore可以实现对同一资源的访问控制。
对于初学者而言，无论线程之间在共享什么资源，都应该使用semaphore等资源访问控制的手段，以此避免可能出现的问题。
semaphore有三种基本操作。new() 方法可以创建一个带单个或者多个钥匙的semaphore，使用get() 可以获取一个或者多个钥匙，而put()可以返回一个或者多个钥匙。
如果你试图获取一个semaphore而希望不被阻塞，可以使用try_get() 函数。它返回1表示有足够多的钥匙，而返回0则表示钥匙不够。

program automatic test(bus_ifc.TB bus);semaphore sem; //创建一个semaphoreinitial beginsem=new(1) ; //分配一个钥匙forksequencer() ; //产生两个总线事务线程sequencer() ;joinendtask sequencer;repeat($urandom%10) //随机等待0-9个周期@bus.cb;send Trans() ; //执行总线事务endtasktask sendTrans;sem.get(1) ; //获取总线钥匙@bus.cb; //把信号驱动到总线上bus.cb.addr<=t.addr;......sem.put(1) ; //处理完成时把钥匙返回endtask
endprogram

白话一刻

这段代码是一个简单的自动测试程序，使用了SystemVerilog（SV）语言。它的主要目的是模拟总线上的事务，并确保这些事务是顺序执行的，通过使用信号量（semaphore）来同步这些事务。

以下是对代码各个部分的解释：

程序定义

program automatic test(bus_ifc.TB bus);

这一行定义了一个名为test的自动程序，该程序接受一个类型为bus_ifc.TB的接口参数bus。

信号量定义

semaphore sem;

这定义了一个信号量sem。信号量通常用于同步多个线程或任务，确保它们以正确的顺序执行。

初始化块

initial begin  sem=new(1) ;  fork  sequencer() ;  sequencer() ;  join  
end

在initial块中，首先为信号量sem分配了一个初始值1（这通常表示有一个“钥匙”可用）。然后，使用fork和join结构并行启动了两个sequencer任务。这两个任务将并发执行。

sequencer 任务

task sequencer;  repeat($urandom%10)  @bus.cb;  send Trans() ;  
endtask

sequencer任务首先会随机等待0到9个周期（$urandom%10生成一个0到9的随机数）。然后，它会等待bus.cb上的某个信号（可能是一个时钟信号或其他同步事件）。最后，它调用sendTrans任务来发送一个总线事务。

sendTrans 任务

task sendTrans;  sem.get(1) ;  @bus.cb;  bus.cb.addr<=t.addr;  ......  sem.put(1) ;  
endtask

在sendTrans任务中，首先尝试获取信号量sem的一个“钥匙”（如果sem为0，则任务将等待直到有钥匙可用）。然后，它再次等待bus.cb上的某个信号，并执行一些操作（例如，将地址t.addr写入bus.cb.addr）。在任务完成并处理完总线事务后，它释放（放回）信号量的“钥匙”。

总结

这个程序创建了两个并发的sequencer任务，每个任务在随机延迟后尝试发送一个总线事务。通过使用信号量sem，确保了这两个事务是顺序执行的，即一个事务必须等待另一个事务完成后才能开始。这避免了可能的总线冲突或同步问题。

线程之间除了”发球”和接球”这样的打乒乓以外，还有更深入的友谊，比如共用一些资源。
对于线程间共享资源的使用方式，应该遵循互斥访问(mutex access) 原则。
控制共享资源的原因在于，如果不对其访问做控制，可能会出现多个线程对同一资源的访问，进而导致不可预期的数据损坏和线程的异常，这种现象称之为"线程不安全”。

以这里比亚迪为例：

class car;semaphore key;function new();key=new(1) ;endfunctiontask get_on(string p);$display("%s is waiting for the key", p);key.get();#1ns;$display("%s got on the car", p);endtasktask get_off(string p);$display("%s got off the car", p);key.put();#1ns;$display("%s returned the key", p);endtask
endclassmodule family;car byd=new();string p1="husband";string p2="wife";initial beginforkbegin//丈夫开车byd.get_on(p1);byd.get_off(p1);endbegin//妻子开车byd.get_on(p2);byd.get_off(p2);endjoinend
endmodule//打印结果
// husband is waiting for the key
// wife is waiting for the key
// husband got on the car
// husband got off	the car
// husband returned the key
// wife got on the car
// wife got off the car
// wife returned the key

一开始在拿到这辆车的时候，只有一把钥匙，而丈夫和妻子如果都想开车的话，也得遵循先到先得的原则。所以，当丈夫和妻子同时都想用车的时候，一把钥匙(semaphore key) 只可以交给他们中的一位，另外一位则需要等待，直到那把钥匙归还之后才可以使用。
从上面的输出结果来看，也是能够看出来，虽然丈夫和妻子在同一时间想开这辆车，然而也只能允许一位家庭成员来驾驶。直到丈夫从车上下来，归还了钥匙以后，妻子才可以上车。
我们用这个生动的例子来解释semaphore对于控制访问共享资源的帮助，从上面对于semaphore key的使用来看， key在使用前必须要做初始化，即要告诉用户它原生自带几把钥匙。
从例子来看，它只有1把钥匙，而丈夫和妻子在等待和归还钥匙时，没有在semaphore::get() /put() 函数中传递参数，即默认他们等待和归还的钥匙数量是1。semaphore可以被初始化为多个钥匙，也可以支持每次支取和归还多把钥匙用来控制资源访问。
semaphore存在一些问题，这些问题就需要在coding时格外注意。
- 即使semaphore中没有钥匙，仍然可以执行还钥匙。
- 即使A拿到了钥匙，B没拿到钥匙，B仍然可以还钥匙。

mailbox信箱

线程之间如果传递信息，可以使用mailbox，mailbox和队列queue有相近之处。
mailbox是一种对象，因此也需要使用new()来例化。例化时有一个可选的参数size来限定其存储的最大数量。如果size是0或者没有指定，则信箱是无限大的，可以容纳任意多的条目。
使用put()可以把数据放入mailbox，使用get()可从信箱移除数据。
如果信箱为满，则put()会阻塞；如果信箱为空，则get()会阻塞。
peek()可以获取对信箱里数据的拷贝而不移除它。
线程之间的同步方法需要注意，哪些是阻塞方法，哪些是非阻塞方法，即哪些是立即返回的，而哪些可能需要等待时间的。

program automatic bounded;mailbox mbx;initial beginmbx=new(1); //容量为1fork//Producer线程for(inti=1; i<4; i++) begin$display("Producer: before put(%0d)", i);mbx.put(i);$display("Producer: after put(%0d)", i);end//consumer线程repeat(3) beginint j;#1ns mbx.get(j);$display("Consumer: after get(%0d)", j);endjoinend
endprogram//测试结果
// Producer: before put(1)
// Producer: after put(1)
// Producer: before put(2)
// Consumer: after get(1)
// Producer: after put(2)
// Producer: before put(3)
// Consumer: after get(2)
// Producer: after put(3)
// Consumer: after get(3)

mailbox和queue的区别：
- maibox必须通过new() 例化，而队列只需要声明。
- mailbox可以将不同的数据类型同时存储，不过这么做是不建议的；对于队列来讲，它内部存储的元素类型必须一致。
- maibox的存取方法put() 和get() 是阻塞方法，即使用时方法不一定立即返回；而队列所对应的存取方式，push_back()和pop_front()方法是非阻塞的，会立即返回。注意在用队列时要先判断空满，根据功能需求可以用wait等待，也可以使用if判断；此外调用阻塞方法时，要在task中调用，因为阻塞方法是耗时的，调用非阻塞可以在task也可以在function。
- mailbox只能够用作FIFO，而queue除了按照FIFO使用，还有其它应用的方式例如LIFO(Last In First Out) 。
- 对于mailbox变量的操作，在传递形式参数时，实际传递并拷贝的是mailbox的指针；等同于队列参数声明为ref，也就是指针，区别就是对参数是引用而不是拷贝。
关于mailbox的其它特性：
- mailbox在例化时，通过new(N) 的方式可以使其变为定长(fixed length)容器。这样在负载到长度N以后，无法再对其写入。如果用new() 的方式，则表示信箱容量不限大小。
- 除了put() /get() /peek() 这样的阻塞方法，用户也可以考虑使用try_put() /try_get() /try_peek() 等非阻塞方法。
- 如果要显式地限定mailbox中元素的类型，可以通过mailbox #(type=T)的方式来声明。例如上面的三个mailbox存储的是int，则可以在声明时进一步限定其类型为mailbox #(int) 。