UVM Sequence基础及仲裁机制-uvm_component_param_utils

sequence机制

sequence机制用于产生激励，它是UVM中最重要的机制之一。

在一个规范化的UVM验证平台中，driver只负责驱动transaction，而不负责产生transaction。虽然将激励放在driver的main_phase中也是可行的，但是如果要对激励作修改，则扩展性较差，所以规范化的UVM验证平台中，我们将激励改为放在sequence中去写。

sequence机制有两大组成部分，一是sequence，二是sequencer。driver就负责驱动激励，激励内容由sequence完成。只有在sequencer的帮助下，sequence产生出的transaction才能最终送给driver。

sequence就像是一个弹夹，里面的子弹是transaction，而sequencer是一把

枪。

在不同的测试用例中，将不同的sequence设置成sequencer的main_phase的default_sequence。当sequencer执行到main_phase时，发现有default_sequence，那么它就启动sequence。

Sequence启动

当定义完一个sequence后，可以使用start任务将其启动。

my_sequence my_seq;my_seq = my_sequence::type_id::create(“my_seq”);my_seq.start(sequencer);

除了上述直接启动之外，还可以使用default_sequence启动。

uvm_config_db#(uvm_object_wrapper)::set(this,“env.i_agt.sqr.main_phase“,“default_sequence“,case0_sequence::type_id::get());

还可以先实例化要启动的sequence，之后再通过default_sequence启动：

function void my_case0::build_phase(uvm_phase phase);case0_sequence cseq;super.build_phase(phase);cseq = new(“cseq”);uvm_config_db#(uvm_sequence_base)::set(this,“env.i_agt.sqr.main_phase”,“default_sequence”,cseq);endfunction

当一个sequence启动后会自动执行sequence的body任务。其实，除了body外，还会自动调用sequence的pre_body与post_body：

class case0_sequence extends uvm_sequence #(my_transaction);virtual task pre_body();`uvm_info(“sequence0”, “pre_body is called!!!”, UVM_LOW)endtaskvirtual task post_body();`uvm_info(“sequence0”, “post_body is called!!!”, UVM_LOW)endtaskvirtual task body();#100;`uvm_info(“sequence0”, “body is called!!!”, UVM_LOW)endtask`uvm_object_utils(case0_sequence)endclass

sequence的仲裁机制

UVM支持在同一个sequencer上可以启动多个sequence。

在my_sequencer上同时启动了两个sequence：sequence1和sequence2，代码如下所示：

task my_case0::main_phase(uvm_phase phase); sequence0 seq0; sequence1 seq1; seq0 = new(“seq0”); seq0.starting_phase = phase; seq1 = new(“seq1”); seq1.starting_phase = phase; fork seq0.start(env.i_agt.sqr); seq1.start(env.i_agt.sqr); joinendtask

其中sequence0的定义为：

class sequence0 extends uvm_sequence #(my_transaction);virtual task body();repeat (5) begin`uvm_do(m_trans)`uvm_info(“sequence0”, “send one transaction”, UVM_MEDIUM)end#100;endtask`uvm_object_utils(sequence0)endclass

sequence1的定义为：

class sequence1 extends uvm_sequence #(my_transaction);virtual task body();repeat (5) begin`uvm_do_with(m_trans, {m_trans.pload.size < 500;})`uvm_info(“sequence1”, “send one transaction”, UVM_MEDIUM)end#100;endtask`uvm_object_utils(sequence1)endclass

当使用uvm_do或者uvm_do_with宏时，产生的transaction的优先级是默认的优先级，即-1，这个数值必须是一个大于等于-1的整数。数字越大，优先级越高。

运行如上代码后，会显示两个sequence交替产生transaction：

# UVM_INFO my_case0.sv(15) @ 85900: uvm_test_top.env.i_agt.sqr@@seq0 [sequence0] send one transaction# UVM_INFO my_case0.sv(37) @ 112500: uvm_test_top.env.i_agt.sqr@@seq1 [sequence1] send one transaction# UVM_INFO my_case0.sv(15) @ 149300: uvm_test_top.env.i_agt.sqr@@seq0 [sequence0] send one transaction# UVM_INFO my_case0.sv(37) @ 200500: uvm_test_top.env.i_agt.sqr@@seq1 [sequence1] send one transaction# UVM_INFO my_case0.sv(15) @ 380700: uvm_test_top.env.i_agt.sqr@@seq0 [sequence0] send one transaction# UVM_INFO my_case0.sv(37) @ 436500: uvm_test_top.env.i_agt.sqr@@seq1 [sequence1] send one transaction

Sequence仲裁机制

1、transaction的优先级

可以通过uvm_do_pri及uvm_do_pri_with改变所产生的transaction的优先级：

class sequence0 extends uvm_sequence #(my_transaction);…10 virtual task body();…13 repeat (5) begin14 `uvm_do_pri(m_trans, 100)15 `uvm_info(“sequence0”, “send one transaction”, UVM_MEDIUM)16 end17 #100;…20 endtask…23 endclass2425 class sequence1 extends uvm_sequence #(my_transaction);…32 virtual task body();…35 repeat (5) begin36 `uvm_do_pri_with(m_trans, 200, {m_trans.pload.size < 500;})37 `uvm_info(“sequence1”, “send one transaction”, UVM_MEDIUM)38 end…42 endtask…45 endclass

uvm_do_pri与uvm_do_pri_with的第二个参数是优先级，这个数值必须是一个大于等于-1的整数。数字越大，优先级越高。

但是运行上述代码，发现并没有如预期的那样，而是sequence0与sequence1交替产生transaction。这是因为，在默认情况下sequencer的仲裁算法是SEQ_ARB_FIFO。它会严格遵循先入先出的顺序，而不会考虑优先级。

但这里存在sequencer的仲裁算法：

SEQ_ARB_FIFO,SEQ_ARB_WEIGHTED,SEQ_ARB_RANDOM,SEQ_ARB_STRICT_FIFO,SEQ_ARB_STRICT_RANDOM,SEQ_ARB_USER

在默认情况下sequencer的仲裁算法是SEQ_ARB_FIFO。它会严格遵循先入先出的顺序，而不会考虑优先级。

SEQ_ARB_WEIGHTED是加权的仲裁；

SEQ_ARB_RANDOM是完全随机选择；

SEQ_ARB_STRICT_FIFO是严格按照优先级的，当有多个同一优先级的sequence时，按照先入先出的顺序选择；

SEQ_ARB_STRICT_RANDOM是严格按照优先级的，当有多个同一优先级的sequence时，随机从最高优先级中选择；

SEQ_ARB_USER则是用户可以自定义一种新的仲裁算法。

因此，若想使优先级起作用，应该设置仲裁算法为SEQ_ARB_STRICT_FIFO或者SEQ_ARB_STRICT_RANDOM：

因此，my_case0代码改为如下：

task my_case0::main_phase(uvm_phase phase);… env.i_agt.sqr.set_arbitration(SEQ_ARB_STRICT_FIFO); fork seq0.start(env.i_agt.sqr); seq1.start(env.i_agt.sqr); joinendtask

经过如上的设置后，会发现直到sequence1发送完transaction后，sequence0才开始发送。

Sequence仲裁机制

2、sequence的优先级

除transaction有优先级外，sequence也有优先级的概念。可以在sequence启动时指定其优先级。

start任务的第一个参数是sequencer，第二个参数是parent sequence，可以设置为null，第三个参数是优先级，如果不指定则此值为-1，它同样不能设置为一个小于-1的数字。这个数值必须是一个大于等于-1的整数。数字越大，优先级越高。

task my_case0::main_phase(uvm_phase phase); env.i_agt.sqr.set_arbitration(SEQ_ARB_STRICT_FIFO); fork seq0.start(env.i_agt.sqr, null, 100);    seq1.start(env.i_agt.sqr, null, 200); joinendtask

运行上述代码，会发现sequence1中的transaction完全发送完后才发送sequence0中的transaction。

即不在uvm_do系列宏中指定优先级。运行上述代码，会发现

sequence1中的transaction完全发送完后才发送sequence0中的transaction。所以，对sequence设置优先级的本质即设置其内产生的

transaction的优先级。

Sequencer lock操作

lock操作，就是sequence向sequencer发送一个请求，这个请求与其他sequence发送transaction的请求一同被放入sequencer的仲裁队列中。当其前面的所有请求被处理完毕后，sequencer就开始响应这个lock请求，此后sequencer会一直连续发送此sequence的transaction，直到unlock操作被调用。从效果上看，此sequencer的所有权并没有被所有的sequence共享，而是被申请lock操作的sequence独占了。一个使用lock操作的sequence为：

class sequence1 extends uvm_sequence #(my_transaction); virtual task body(); repeat (3) begin `uvm_do_with(m_trans, {m_trans.pload.size < 500;})      `uvm_info(“sequence1”, “send one transaction”, UVM_MEDIUM) end    lock(); `uvm_info(“sequence1”, “locked the sequencer “, UVM_MEDIUM) repeat (4) begin      `uvm_do_with(m_trans, {m_trans.pload.size < 500;}) `uvm_info(“sequence1”, “send one transaction”, UVM_MEDIUM) end    `uvm_info(“sequence1”, “unlocked the sequencer “, UVM_MEDIUM) unlock(); repeat (3) begin `uvm_do_with(m_trans, {m_trans.pload.size < 500;})      `uvm_info(“sequence1”, “send one transaction”, UVM_MEDIUM) end endtaskendclass

将此sequence1与下面的sequence0在env.i_agt.sqr上启动，

3 class sequence0 extends uvm_sequence #(my_transaction);…10 virtual task body();…13 repeat (5) begin14 `uvm_do(m_trans)15 `uvm_info(“sequence0”, “send one transaction”, UVM_MEDIUM)16 end17 #100;…20 endtask2122 `uvm_object_utils(sequence0)23 endclass

在env.i_agt.sqr上启动，

task my_case0::main_phase(uvm_phase phase);58 sequence0 seq0;59 sequence1 seq1;6061 seq0 = new(“seq0”);62 seq0.starting_phase = phase;63 seq1 = new(“seq1”);64 seq1.starting_phase = phase;65 fork66 seq0.start(env.i_agt.sqr);67 seq1.start(env.i_agt.sqr);68 join69 endtask

会发现在lock语句前，sequence0和seuquence1交替产生transaction；在lock语句后，一直发送sequence1的transaction，直到unlock语句被调用后，sequence0和seuquence1又开始交替产生transaction。

如果两个sequence都试图使用lock任务来获取sequencer的所有权则会如何呢？答案是先获得所有权的sequence在执行完毕后才

会将所有权交还给另外一个sequence。

Sequence grab操作

与lock操作一样，grab操作也用于暂时拥有sequencer的所有权，只是grab操作比lock操作优先级更高。lock请求是被插入sequencer仲裁队列的最后面，等到它时，它前面的仲裁请求都已经结束了。grab请求则被放入sequencer仲裁队列的最前面，它几乎是一发出就拥有了sequencer的所有权。

class sequence1 extends uvm_sequence #(my_transaction); virtual task body(); repeat (3) begin `uvm_do_with(m_trans, {m_trans.pload.size < 500;}) `uvm_info(“sequence1”, “send one transaction”, UVM_MEDIUM) end grab(); `uvm_info(“sequence1”, “grab the sequencer “, UVM_MEDIUM) repeat (4) begin `uvm_do_with(m_trans, {m_trans.pload.size < 500;}) `uvm_info(“sequence1”, “send one transaction”, UVM_MEDIUM) end `uvm_info(“sequence1”, “ungrab the sequencer “, UVM_MEDIUM) ungrab(); repeat (3) begin `uvm_do_with(m_trans, {m_trans.pload.size < 500;}) `uvm_info(“sequence1”, “send one transaction”, UVM_MEDIUM) end endtask `uvm_object_utils(sequence1)endclass

如果两个sequence同时试图使用grab任务获取sequencer的所有权将会如何呢？这种情况与两个sequence同时试图调用lock函数一样，在先获得所有权的sequence执行完毕后才会将所有权交还给另外一个试图所有权的sequence。

如果一个sequence在使用grab任务获取sequencer的所有权前，另外一个sequence已经使用lock任务获得了sequencer的所有权则会如何呢？答案是grab任务会一直等待lock的释放。grab任务还是比较讲文明的，虽然它会插队，但是绝不会打断别人正在进行的事情。

Sequence的有效性

当有多个sequence同时在一个sequencer上启动时，所有的sequence都参与仲裁，根据算法决定哪个sequence发送transaction。仲裁算法是由sequencer决定的，sequence除了可以在优先级上进行设置外，对仲裁的结果无能为力。

通过lock任务和grab任务，sequence可以独占sequencer，强行使sequencer发送自己产生的transaction。同样的，UVM也提供措施使sequence可以在一定时间内不参与仲裁，即令此sequence失效。

sequencer在仲裁时，会查看sequence的is_relevant函数的返回结果。如果为1，说明此sequence有效，否则无效。因此可以通过重载is_relevant函数来使sequence失效：

文章内容参考自：张强《UVM实战》

感谢阅读，别走！点赞、关注、转发后再走吧