SystemVerilog学习笔记（十）：进程/细粒度进程控制

进程

进程或线程是作为独立实体执行的任何代码片段。fork-join块创建并行运行的不同线程。在下面的图-1中，可以看到进程的类型和进程控制。

序号	进程	描述
1.	fork-join	只有所有子线程执行完毕时，父线程才会执行。
2.	fork-join_any	只有任何一个子线程执行完毕时，父线程才会执行。
3.	fork-join_none	父线程与子线程并行执行。
4.	wait fork	使父线程等待所有子线程执行完毕。
5.	disable fork	当执行disable fork时，会终止所有子线程的执行。
6.	细粒度进程控制	这些用于控制进程，并提供进程/线程的状态。

进程或线程

有3种类型的线程/进程

fork-join
fork-join_any
fork-join_none

fork-join

SystemVerilog通过fork-join结构支持并行线程。在fork-join进程中，只有当所有子线程完成执行时，父线程才会执行。

语法：-

fork  
   线程1  
   线程2  
   线程3
join

代码片段：-

$display("[%0t] Thread_T1: a的值为%0d，b的值为%0d，c的值为%0d，d的值为%0d",$time,a,b,c,d);

fork:FORK_F1  

   begin:BEGIN_B2  
      #1 a <= b;  
      b <= 7;  
      $monitor("[%0t] Thread-T2: a的值为%0d，b的值为%0d，c的值为%0d，d的值为%0d",$time,a,b,c,d);  
      #1 ->e1;  
      c = b;  
   end:BEGIN_B2  

   begin:BEGIN_B3  
      wait(e1.triggered);  
      $display("[%0t] 事件已触发",$time);  

      begin:BEGIN_B4  
        #1 d = c;  
      end:BEGIN_B4  

   end:BEGIN_B3  

join:FORK_F1 

$display("[%0t] Thread_T3: a的值为%0d，b的值为%0d，c的值为%0d，d的值为%0d",$time,a,b,c,d);

输出：
在图-2中，我们可以看到Thread_T1首先在#0模拟时间执行，但是Thread_T3将在所有子线程执行完毕后才执行，子线程将根据时间延迟执行。

fork_join_output

在图-3中，可以清楚地了解关于fork-join代码的整个工作方式，以及与时间表区域相关的调度原理。

变量的取样将在提前的区域中完成。
所有阻塞赋值将在活动区域执行，所有非阻塞赋值将在活动区域中评估。
事件将在活动区域执行。
$display语句将在活动区域执行。
所有#0延迟语句将在非活动区域中执行。
评估的非阻塞赋值将在NBA区域中执行。
$monitor语句将在推迟的区域中执行。

fork_join (1)

fork-join_any

当任何一个子线程完成执行时，父线程将执行。这意味着如果fork-join_any块中有2个或更多线程，并且每个线程需要不同的时间完成。在这种情况下，无论哪个线程先完成，fork-join_any都将退出该块，并开始执行模拟中的下一个父线程/语句。这并不意味着剩余的子线程将被模拟自动丢弃。这些线程将在后台运行。

语法：-

fork  
   Thread 1  
   Thread 2  
   Thread 3  
join_any

代码片段：-

$display("[%0t] Thread_T1: Starting of fork_join_any",$time);

a = "Kapu";
c = "Malpe";

fork:FORK_F1  

   begin:BEGIN_B2  
      #0 $display("[%0t] Thread_T2: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);  

      begin:BEGIN_B3  
         b <= a;  
         #1 $display("[%0t] Thread_T3: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);  
      end:BEGIN_B3  

   end:BEGIN_B2  

   fork:FORK_F2  

      begin:BEGIN_B4  
         #3 -> e1;  
         $display("[%0t] Thread_T4: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);  
      end:BEGIN_B4  

   join:FORK_F2  
      
join_any:FORK_F1

#1 $display("[%0t] Thread_T5: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);
    
begin:BEGIN_B5
   wait(e1.triggered);
   d = "Kodi";
   $monitor("[%0t] Thread_T6: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);
end:BEGIN_B5

输出：-
在下图中，我们可以看到父线程Thread_T1在＃0处执行，子线程Thread_T3在＃1处执行，然后只有父线程Thread_T5将在＃2处执行。

Untitled Diagram drawio (23)

fork join_any

fork-join_none

父线程与子线程并行执行。这意味着在fork-join_none外部的线程不会等待fork-join_none内部的任何线程完成，它们只是并行执行。这并不意味着模拟会自动丢弃其余的子线程。这些线程将在后台运行。

语法：-

fork 
   Thread 1  
   Thread 2  
   Thread 3  
join_none

代码片段：-

$display("[%0t] Thread_T1: Starting of fork_join_none",$time);

a = "Kapu";
c = "Malpe";

fork:FORK_F1  

   begin:BEGIN_B2  
      #1 $display("[%0t] Thread_T2: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);      
      b <= a;  
      #1 $display("[%0t] Thread_T3: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);  
   end:BEGIN_B2  

   fork:FORK_F2  
      #1 -> e1;  
      $display("[%0t] Thread_T4: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);  
   join:FORK_F2  

join_none:FORK_F1

#1 $display("[%0t] Thread_T5: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);

wait(e1.triggered);
d = "Kodi";

$monitor("[%0t] Thread_T6: Values of a =%0s,b =%0s,c =%0s,d =%0s",$time,a,b,c,d);

输出：在下图中，在＃0处执行父线程Thread_T1和子线程Thread_T4，然后在＃1处同时执行父线程Thread_T5和子线程Thread_T2，以此类推。

Untitled Diagram drawio (28)

fork_join_none

进程控制

System Verilog提供了允许一个进程终止或等待其他进程完成的构造。

wait fork
disable fork
细粒度进程控制

wait fork

wait fork语句用于确保所有子进程（由调用进程创建的进程）都已完成执行。它将等待直到所有fork进程完成执行。

代码片段：-

#1 $display("[%0t] Thread_T1: values of a = %0s,b = %0s,c = %0s",$time,a,b,c);

fork:FORK_F1  

   #2 b <= "Delta";  
   #0 $display("[%0t] Thread_T2: values of a = %0s,b = %0s,c = %0s",$time,a,b,c);  

   begin:BEGIN_B2  
      #1 -> e1;  
      c = "Hoode";  
      #1 $display("[%0t] Thread_T3: values of a = %0s,b = %0s,c = %0s",$time,a,b,c);  
   end:BEGIN_B2  

   fork:FORK_F2  
      wait(e1.triggered);  
      #2 $display("[%0t] Thread_T4: values of a = %0s,b = %0s,c = %0s",$time,a,b,c);  
   join:FORK_F2  

   #1 $display("[%0t] Thread_T5: values of a = %0s,b = %0s,c = %0s",$time,a,b,c);  

join_none:FORK_F1  

wait fork;  
#0 $monitor("[%0t] Thread_T6: values of a = %0s,b = %0s,c = %0s",$time,a,b,c);

输出：-

在下图中，我们看到在＃1处，父线程Thread_T1将被执行，并且有一个#0语句将在非活动区域中工作，语句将在相应区域中执行。尽管我们使用了fork-join_none，但$monitor语句将等待所有子线程被执行。

wait_fork

disable fork

执行disable fork时，所有活动的进程都将被终止。

代码片段：-

#0 $display("[%0t] Thread_T1: Values of a = %0s,b = %0s,c = %0s",$time,a,b,c);

fork:FORK_F1  

   #3 b <= "Delta";  

   #4 $display("[%0t] Thread_T2: Values of a = %0s,b = %0s,c = %0s",$time,a,b,c);  
             
   begin:BEGIN_B2  
      #1 -> e1;  
      c = "Hoode";  
      #1 $display("[%0t] Thread_T3: Values of a = %0s,b = %0s,c = %0s",$time,a,b,c);  
   end:BEGIN_B2  
      
   fork:FORK_F2  
      @(e1.triggered);  
      #1 $display("[%0t] Thread_T4: Values of a = %0s,b = %0s,c = %0s",$time,a,b,c);  
   join:FORK_F2  
      
   #1 $display("[%0t] Thread_T5: Values of a = %0s,b = %0s,c = %0s",$time,a,b,c);  

join_any:FORK_F1  

disable fork;  
#1 $display("[%0t] Thread_T6: ending of fork-join",$time);

输出：-

在下图中，在＃0处，我们正在等待事件被触发，＃0语句将在活动区域中执行，因为它是$display语句。在＃1处，它正在触发事件e1，并且一个子线程Thread_T5将被执行，然后由于使用了fork-join_any，它将转到父线程并触发disable fork语句，然后所有剩余的子线程将被终止。

细粒度进程控制

SystemVerilog有一个内置的名为Process的类，允许一个进程（例如，像fork_join）访问和控制进程/线程。当我们分叉出任何线程时，会在那时创建Process类的新对象。该对象包含有关该线程的状态信息。

Untitled Diagram drawio (5)

序号	任务	描述
1.	self()	用于创建进程的ID/对象。
2.	status()	用于返回当前线程的模式。
3.	kill()	用于终止线程。
4.	await()	用于等待当前线程完成其他线程。
5.	suspend()	用于暂停线程一段时间。
6.	resume()	用于从暂停状态恢复线程。

self()

它为Process类创建对象/ID。该对象用于访问Process类的所有预定义方法。对象包含所有线程的状态信息。

语法：-

process p_handle1,p_handle2;  
initial begin 
   p_handle1 = process :: self();  
   p_handle2 = process :: self(); 
end

代码片段：-

fork:FORK_F1  

   $display("[%0t] Entered into fork-join and started first check for the process",$time);  
   #1 ->e1;  

   begin:BEGIN_B2  
      wait(e1.triggered);  
      if(p1 == null)  
         $display("[%0t] Not created",$time);  
      else  
         $display("[%0t] Created",$time);  
      ->e3;  
      #1 ->e2;  
   end:BEGIN_B2  

   #2 p1 = process :: self();  

   begin:BEGIN_B3  
      wait(e2.triggered);
      $display("[%0t] Started second check for the process",$time);  
      if(p1 == null)
         $display("[%0t] Not created",$time);
      else
         $display("[%0t] Created",$time);
      ->e4;
   end:BEGIN_B3
      
   fork:FORK_F2

      begin:BEGIN_B4
         wait(e3.triggered);
         $display("[%0t] first check for the process done",$time);
      end:BEGIN_B4

      begin:BEGIN_B5
         wait(e4.triggered);
         $display("[%0t] Second check for the process done",$time);
      end:BEGIN_B5
      
   join:FORK_F2

join:FORK_F1

在上面的代码片段中，您可以看到在＃0模拟时间时声明了进程类的句柄。在下面的图中，

在＃1模拟时间时，我们正在检查是否创建了对象p1，然后它显示“未创建”。
在＃2模拟时间时，我们为进程p1创建一个对象。
在＃3模拟时间时，我们检查对象p1，显示“已创建”。

fine_self_output

fork join_any _self _kill-Page-2 drawio (3)

Status()

它将显示进程ID的状态/模式。有不同的模式，如已完成（Finished）、运行中（Running）、等待中（Waiting）、已挂起（Suspended）、已终止（Killed）。

语法：-

process p_handle;
initial begin
   begin  
      p_handle = process :: self();  
      $display("status : %s",p_handle.status());  
   end
end

代码片段：-

$display("[%0t] Seeking status:",$time);  

fork:FORK_F1  

   begin:BEGIN_B2  
      p1 = process :: self();  
      #1 $display("[%0t] I am in process p1",$time);  
      $display("[%0t] Initial status of p1: %s",$time,p1.status());  
      #1 $display("[%0t] Still working in p1",$time);  
      ->e1;  
      ->e2;  
   end:BEGIN_B2  
 
   begin:BEGIN_B3  
      p2 = process :: self();  
      wait(e2.triggered);  
      #1 $display("[%0t] I am in process p2",$time);  
      $display("[%0t] Initial status of p2: %s",$time,p2.status());  
      $display("[%0t] Still working in p2",$time);  
      ->e3;  
   end:BEGIN_B3  

   begin:BEGIN_B4  
      wait(e1.triggered);  
      $display("[%0t] Final status of p1: %s",$time,p1.status());  
   end:BEGIN_B4  

   begin:BEGIN_B5  
      wait(e3.triggered);  
      $display("[%0t] Final status of p2: %s",$time,p2.status());  
   end:BEGIN_B5  

   fork:FORK_F2  
      p3 = process :: self();  
      #1 $display("[%0t] I am in process p3",$time);  
      #1 $display("[%0t] status of p3: %s",$time,p3.status());  
      #1 ->e4;  
   join:FORK_F2  

join_any:FORK_F1  

wait(e4.triggered);  
#1 $display("[%0t] Final status of p3: %s",$time,p3.status());

在下图中，

您可以看到一些字符串是大写的，这些是进程p1和p2的状态。
在不同的模拟时间，进程/线程的状态将根据它们的执行而改变。

status drawio (1)

kill()

kill()函数终止进程及其所有子进程。如果进程没有被阻塞（由于等待语句、延迟或等待事件触发），则它将在当前时间戳被终止。

语法：-

Process p_handle1; 
initial begin 
   fork 
      p_handle1 = process :: self();  
      p_handle1.kill(); 
   join_any  
end

代码片段：-

$display("[%0t] Seeking status:",$time);

fork:FORK_F1  

   begin:BEGIN_B2  
      p1 = process :: self();  
      #1 $display("[%0t] I am in process p1",$time);  
      $display("[%0t] Initial status check of p1: %s",$time,p1.status);  
      ->e1;  

      if(p1.status() != process :: FINISHED)  
         p1.kill();  
         $display("hi i am working");  
         $display("what about you?");  
   end:BEGIN_B2  

   begin:BEGIN_B3  
      wait(e1.triggered);  
      #1 $display("[%0t] Status of p1 before killing: %s",$time,p1.status());  
   end:BEGIN_B3  

join:FORK_F1

在上述代码片段中，您可以看到在＃0模拟时间时创建了进程p1的进程类对象。在下图中，

在＃1模拟时间时，进程p1的状态为RUNNING。
在使用kill()方法后的＃2模拟时间时，进程p1的状态为KILLED。

fine_kill_output

fork join_any _self _kill-Page-3 drawio

await()

这种方法用于允许一个进程等待另一个进程/线程完成。

语法：-

Process p_handle1,p_handle2;  
initial begin  
   fork 
      begin
         p_handle1 = process :: self(); 
         p_handle2.await(); 
      end 
      begin 
         p_handle2 = process :: self();
      end
   join 
end

代码片段：-

在上述代码片段中，我们试图使进程p1等待直到进程p2完成。在下面的图8中，您可以看到：

在＃1模拟时间之前使用await()方法之前，p1的状态为RUNNING。
在使用await()方法后的＃2模拟时间时，p1的状态为WAITING。
一旦p2的状态为FINISHED，则p1的状态也为FINISHED。

fine_await_output

await drawio

suspend()

这个方法用于暂停进程/线程的执行。它可以暂停自己或其他进程的执行。执行将暂停，直到遇到resume()方法。如果进程没有被阻塞（由于等待语句、延迟或等待事件触发），则它将在当前时间戳被暂停。

语法：-

Process p_handle1;  
initial begin  
   fork 
      begin
         p_handle1 = process :: self();
         p_handle1.suspend();  
      end
   join_none 
end

代码片段：-

在上述代码片段中，我们试图使进程p1永久暂停。在下面的图10中，您可以看到：

在#1模拟时间之前，暂停p1的状态为RUNNING。
在#3模拟时间之后，暂停p1的状态为SUSPENDED。

fine_suspend_output

Untitled Diagram drawio (5)

resume()

这个方法用于重新启动被暂停的进程。如果暂停的进程在被阻塞时（由于等待语句、延迟或等待事件触发），则恢复该进程将重新初始化到事件表达式或等待条件为真，或等待延迟到期。

语法：-

Process p_handle1,p_handle2;
initial begin 
   fork  
      begin  
         p_handle1 = process :: self();  
         p_handle1.suspend();  
      end  
      begin 
         p_handle2 = process :: self();
         p_handle1.resume();  
      end  
   join_none  
end

代码片段：-

$display("[%0t] Seeking status:",$time);  

   fork:FORK_F1  

      begin:BEGIN_B2  
         p1 = process :: self();  
         #1 $display("[%0t] I am in process p1",$time);  
         $display("[%0t] Initial status of p1: %s",$time,p1.status());  
         ->e1;  

         if(p1.status() != process :: FINISHED)  
        
         begin:BEGIN_B3  
           #1 $display("[%0t] Status of p1 before suspending: %s",$time,p1.status());  
           p1.suspend();  
           $display("[%0t] Status of p2 in p1 block: %s",$time,p2.status());  
         end:BEGIN_B3  

      end:BEGIN_B2  

      begin:BEGIN_B4  
         wait(e2.triggered);  
         $display("[%0t] Status of p1 before resuming: %s",$time,p1.status());  
         p1.resume();  
         #1 $display("[%0t] Status of p1 after resuming: %s",$time,p1.status());  
         ->e3;  
      end:BEGIN_B4  

      begin:BEGIN_B6  
         p2 = process :: self();  
         #1 $display("[%0t] I am in process p2",$time);  
         $display("[%0t] Initial status of p2: %s",$time,p2.status());  

         if(p1.status() == process :: SUSPENDED)  
            #1 ->e2;  
      end:BEGIN_B6  

      begin:BEGIN_B7  
         wait(e3.triggered);  
         #1 $display("[%0t] Final status of p1: %s",$time,p1.status());  
         $display("[%0t] Final status of p2: %s",$time,p2.status());  
      end:BEGIN_B7  

join:FORK_F1

在上述代码片段中，我们试图在进程p2中恢复进程p1。在下面的图12中，您可以看到：

在#1模拟时间时，p1的状态为RUNNING。
在使用resume()方法之前的#2模拟时间时，p1的状态为SUSPENDED。
在使用resume()方法后的#3模拟时间时，p1的状态为FINISHED。

fine_resume_output

resume drawio

进程常见问题

fork_join、fork_join_any 和 fork_join_none 之间的区别

fork_join	fork_join_any	fok_join_none
在 fork_join 中，主（父）线程在 fork_join 中的所有线程（子线程）执行完毕后才会执行	在 fork_join_any 中，如果任何一个子线程执行，则主（父）线程执行	在 fork_join_none 中，子线程和主（父）线程同时执行

我们可以在 fork_join 中使用 wait_fork 吗？

我们知道，在 fork_join 中，仅当 fork_join 中的所有线程执行完毕时，主线程才会执行，因此不需要使用 wait_fork。我们可以在 fork_join_any 或 fork_join_none 语句后使用 wait fork，以等待 fork-join_any 或 fork_join_none 中的所有线程完成。因此，在 fork_join 中不需要 wait_fork。

阻塞和非阻塞赋值的区别

阻塞	非阻塞
在阻塞赋值中，一条语句执行完毕后，下一条语句将执行，即右侧表达式的第一个表达式被评估并立即分配给左侧变量	在非阻塞赋值中，对当前时间单位的所有右侧表达式进行评估，并在时间单位结束时分配给左侧变量
由 " = " 表示	由 " <= " 表示
它按顺序执行	它并行执行
阻塞用于组合逻辑	非阻塞用于时序逻辑

wait event 和 @ event 之间的区别

如果我们在相同的延迟下触发 wait 和 @，那么 wait 语句会被执行，因为 wait 捕获速度比 @ 快。

我们可以使用不同延迟执行 wait 和 @ 吗？

module tb;    
    event e;  
    initial begin  
    #20 ->e;  
   $display($time,"thread1");  
   end  
  initial   
    begin  
     #25 @e;  
     $display($time,"thread2");  
    end  
  initial   
   begin  
   #15 wait(e.triggered);  
   $display($time,"thread3");  
   end 
endmodule

在上面的例子中，我们可以看到事件、wait 和 @ 的延迟是不同的。我们还可以看到这里 @ 的延迟大于事件的延迟，而 wait 的延迟小于事件的延迟，所以这里只有 wait 语句与事件的延迟一起执行。因此，在下面的图中，我们可以看到线程 1 和线程 3 使用相同的延迟（#20）执行。

Untitled Diagram drawio (7)