SV学习笔记(五)

本文

芯片验证系列文章主要分为三部分:验证工程师与芯片验证、SV学习笔记、UVM学习笔记。此为 SV学习笔记 部分第五篇,主要介绍线程的使用、线程的控制和线程的通信。

版本 说明
0.1 初版发布

参考

名称 作者 来源
《芯片验证漫游指南》 刘斌 书籍
《SystemVerilog验证》 克里斯.斯皮尔 书籍

专业术语与缩略语

缩写 全称 说明

线程的使用

程序和模块

  • 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并行线程语句块

fork…join

  • 测试代码
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
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);
        end
    join
    $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块内程序作为父线程,并创建了四个子线程。
    1. $display…
    2. #50 $display…
    3. #10 $display…
    4. begin #30 $display… #10 $display… end

fork…join_any

  • 测试代码
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
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);
        end
    join_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中只要有一个子线程(最短的)执行完毕,父线程的程序就会被执行的。

fork..,join_none

  • 测试代码
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
initial begin
    $display("@%0t: start fork...join_none 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);
        end
    join_none
    $display("@%0t: after join_none", $time);
    #80 $display("@%0t: finish after 80", $time);
end
  • 测试结果
@0: start fork...join_none example
@10: sequential after #10
@10: after join_none
@10: parallel start
@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_none中父线程与子线程是并行执行的。

等待所有衍生线程

  • 在SV中,当程序中的initial块全部执行完毕,仿真器就退出了,也就是如果以上测试代码中没有最后的…finish after…语句,对于join_any和join_none其子线程没有全部执行完毕仿真就结束了。
  • 如果需要等待所有fork块中的子线程全部执行完毕在退出结束initial块,可以使用wait fork语句来等待所有子线程结束。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
task run_thread;
    ...
    fork
        check_trans(tr1); //thread1
        check_trans(tr2); //thread2
        check_trans(tr3); //thread3
    join_none
    ...

    // 等待所有fork中的线程结束
    wait fork;
endtask

停止单个线程

  • 在使用了fork…join_any和fork…join_none以后,我们可以使用disable来指定需要停止的线程。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
parameter TIME_OUT = 1000;
task check_trans(transaction tr);
    fork begin
        // 等待回应或达到某个最大延时
        fork : timeout_block
            begin
                wait (bus.cb.addr == tr.addr);
                $display("@%0t: Addr match %d", $time, tr.addr);
            end
            #TIME_OUT $display("@%0t: Error: timeout", $time);
        join_any
        disable timeout_block;
    end
    join_none
endtask

停止多个线程

  • disable fork可以停止从当前线程中衍生出来的所有子线程。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
initial begin
    check_trans(tr0); //线程0
    //创建一个线程来控制disable fork的作用范围
    fork //线程1
        begin
            check_trans(tr1); //线程2
            fork //线程3
                check_trans(tr2); //线程4
            join
            // 停止线程1-4, 单独保留线程0
            #(TIME_OUT/2) disable fork;
        end
    join
end
  • 其实最准确的关闭线程的方法是,给定线程的标号,关闭指定的线程。

停止被多次调用的任务

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

线程的通信

写在前面

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

event事件

  • verilog中,一个线程总是要等待一个带@操作符的事件。这个操作符是边沿敏感的,所以它总是阻塞着、等待着事件的变化。
  • 其他线程可以通过->操作符来触发事件,结束对一个线程的阻塞。
  • 这就像在打电话时,一个人等待另一个人的呼叫。
  • 测试代码(注意,event需声明而不需要new):
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
event el,	e2;
initial begin
    $display("@t0t: 1: before trigger", $time);
    -> el;
    @e2;
    $display("@%0t: 1: after trigger", $time);
end

initial 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(),相当于为拨打电话提供了留言功能。
  • 测试代码:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
event el,	e2;
initial begin
    $display("@t0t: 1: before trigger", $time);
    -> el;
    wait (e2.triggered());
    $display("@%0t: 1: after trigger", $time);
end

initial 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被触发过,就可以防止引起阻塞。

通知的需求

  • 不同的线程之间,有时会有互相告知的需求。比如,我们要开一辆车,在踩油门要行驶之前,首先得看一下汽车有没有发动,那么这辆车可能是这样设计的:
 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
module road;
    initial begin
        automatic car byd = new();
        byd.drive();
    end
endmodule

class car;
    bit start=0;
    task launch();
        start=1;
        $display(car is launched);
    endtask

    task move();
        wait(start==1);
        $display(car is moving);
    endtask

    task drive();
        fork
            this.launch();
            this.move() ;
        join
     endtask
endclass

//输出结果:
// car is launched
// car is moving
  • 以上的例子可以看出,两个线程launch和move是通过线程间共享变量car::start和wait语句来实现了线程launch通知线程move的功能。
  • 我们也可以将线程间共享变量car::start改为事件来触发。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
class car;
    event e_start;
    task launch();
        -> e_start;
        $display(car is launched);
    endtask

    task move();
        wait(e_start.triggered());
        $display(car is moving);
    endtask

    task drive();
        fork
            this.launch();
            this.move() ;
        join
     endtask
endclass
  • 当汽车要加速的时候,添加速度显示功能:
 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
51
52
53
module road;
    initial begin
        automatic car byd = new();
        byd.drive();
        byd.speedup();
        byd.speedup();
        byd.speedup();
    end
endmodule

class car;
    event e_start;
    event e_speedup;
    int speed = 0;
    ......
    task speedup();
        #10ns;
        -> e_speedup;
    endtask

    task display();
        forever begin
            @e_speedup;
            speed++;
            $display("speed is %0d", speed);
        end
    endtask

    task launch();
        start=1;
        $display(car is launched);
    endtask

    task move();
        wait(start==1);
        $display(car is moving);
    endtask

    task drive();
        fork
            this.launch();
            this.move() ;
            this.display() ;
        join_none
     endtask
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则表示钥匙不够。
 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
program automatic test(bus_ifc.TB bus);
    semaphore sem; //创建一个semaphore
    initial begin
        sem=new(1) ; //分配一个钥匙
        fork
            sequencer() ; //产生两个总线事务线程
            sequencer() ;
        join
    end

    task sequencer;
        repeat($urandom%10) //随机等待0-9个周期
        @bus.cb;

        send Trans() ; //执行总线事务
    endtask

    task sendTrans;
        sem.get(1) ; //获取总线钥匙
        @bus.cb; //把信号驱动到总线上
        bus.cb.addr<=t.addr;
        ......
        sem.put(1) ; //处理完成时把钥匙返回
    endtask
endprogram
  • 线程之间除了”发球”和接球”这样的打乒乓以外,还有更深入的友谊,比如共用一些资源。

  • 对于线程间共享资源的使用方式, 应该遵循互斥访问(mutex access) 原则。

  • 控制共享资源的原因在于,如果不对其访问做控制,可能会出现多个线程对同一资源的访问,进而导致不可预期的数据损坏和线程的异常,这种现象称之为"线程不安全”。

  • 以这里比亚迪为例:

 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
class car;
    semaphore key;
    function new();
        key=new(1) ;
    endfunction

    task get_on(string p);
        $display("%s is waiting for the key", p);
        key.get();
        #1ns;
        $display("%s got on the car", p);
    endtask

    task get_off(string p);
        $display("%s got off the car", p);
        key.put();
        #1ns;
        $display("%s returned the key", p);
    endtask
endclass

module family;
    car byd=new();
    string p1="husband";
    string p2="wife";

    initial begin
        fork
            begin//丈夫开车
                byd.get_on(p1);
                byd.get_off(p1);
            end

            begin//妻子开车
                byd.get_on(p2);
                byd.get_off(p2);
            end
        join
    end
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()可以获取对信箱里数据的拷贝而不移除它。
  • 线程之间的同步方法需要注意,哪些是阻塞方法,哪些是非阻塞方法,即哪些是立即返回的,而哪些可能需要等待时间的。
 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
program automatic bounded;
    mailbox mbx;
    initial begin
        mbx=new(1); //容量为1
        fork
            //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) begin
                int j;
                #1ns mbx.get(j);
                $display("Consumer: after get(%0d)", j);
            end
        join
    end
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) 。

三种通信的比较和应用

  • event: 最小信息量的触发,即单一的通知功能。可以用来做事件的触发, 也可以多个event组合起来用来做线程之间的同步。
  • semaphore: 共享资源的安全卫士。如果多线程间要对某一公共资源做访问,即可以使用此方式。
  • mailbox: 精小的SV原生FIFO。在线程之间做数据通信或者内部数据缓存时可以考虑使用此方式。

文章原创,可能存在部分错误,欢迎指正,联系邮箱 cao_arvin@163.com。