UVM_Sequence

已于 2022-09-10 23:43:27 修改
阅读量464 收藏 4
点赞数
分类专栏： Digital IC Verify 文章标签： fpga开发
于 2022-08-03 23:35:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gjbt123/article/details/126149973
版权
  • 13.3.2 事务传输实例
    一、sequence body()的四步骤：
    1、create_item() //创建request对象
    2、start_item() //准备发送item
    3、req.randomize with //发送前的随机化处理
    4、finish_item() //完成item的发送
    二、driver run_phase()的几个步骤
    1、seq_item_port.get_next_item(tmp) //从sequencer中获取到有效的item\sequence
    2、$ cast(req,tmp) //进行动态句柄转换
    3、void’($cast(rep,req.clone())) //若有需要进行clone一份给rsp
    4、seq_item_port.item_done(rsp) //最后通过此形式将rsp反馈给sequence
class bus_trans extends uvm_sequence_item;
	rand int data;
	`uvm_object_utils_begin(bus_trans)
		`uvm_field_int(data,UVM_ALL_ON)
	`uvm_object_utils_end
	//...
endclass

class flas_seq extends uvm_sequence;
	`uvm_object_utils(flat_seq)
	//...
	task body();
		uvm_sequence_item tmp;
		bud_trans req,rdp;
		tmp = creat_item(bus_trans::get_type().m_sequencer,"req");
		void'($cast(req,tmp));
		start_item(req);
		req.randomize with (data == 10);
		`uvm_info("SEQ",$sformatf("sent a item \n%s",req.sprint()),UVM_LOW)
		finish_item(req);
		get_response(tmp);
		vod'($cast(rsp,tmp));
		`uvm_info("RSP",$sformatf("recived a item \n %s"),rsp.sprint(),UVM_LOW)
	endtask
endclass

class sequencer extends uvm_sequencer;
	`uvm_component_utils(sequencer);
	//...
endclass

class driver extends uvm_driver;
	`uvm_component_utils(driver)
	//...
	task run_phase(uvm_phase phase);
		REQ tmp;
		bus_trans req,rsp;
		seq_item_port.get_next_item(tmp);
		void'($cast(req,tmp));
		`uvm_info("DRV",$sformatf("got an item \n %s"),req.sprint(),UVM_LOW)
		
		void'($cast(rsp,req.clone()));
		rsp.set_sequence_id(req.get_sequence_id());
		rsp.data += 100;
		seq_item_port.item_done(rsp);
		`uvm_info("DRV",$sformatf("sent an item \n %s"),rsp.sprintf(),UVM_LOW)
	endtask
endclass

class env extends uvm_env;
	sequencer sqr;
	driver drv;
	`uvm_component_utils(env)
	//...
	function void build_phase (uvm_phase phase);
		sqr = sequencer::type_id::create("sqr",this);
		drv = driver::type_id::create("drv",this);
	endfunction
	function void connect_phase (uvm_phase phase)
		drv.seq_item_port.connect(sqr.seq_item_export);
	endfunction
endclass

class test1 extends uvm_test;
	env e;
	`uvm_component_utils(test1)
	//...
	function void build_phase (uvm_phase phase);
		e = env::type_id::create("e",this);
	endfunction
	task run_phase (uvm_phase phase);
		flat_seq seq;
		phase.raise_objection(phase);
		seq = new();
		seq.start(e.sqr);   //实现了将sequence挂载到sequencer上
		phase.drop_objection(phase);
	endtask
endclass

在这里插入图片描述

  • sequence中发送item跟sequence的区别
    1、sequence挂载到sequencer上：HANDLE.start(m_sequencer,this) //若是没有更上层的sequence嵌套时可以省略this，例如在test层调top_seq的时候：HANLE.start(e.start‘“路径”)
    2、将item挂载到sequencer上：
    create_item(bus_trans::get_type(), m_sequencer, “req”)
    finish_item(req)
class top_seq extends uvm_sequence;
    `uvm_object_utils(top_seq)
    function new(string name = "top_seq");
      super.new(name);
    endfunction
    task body();
      uvm_sequence_item tmp;
      child_seq cseq;
      bus_trans req;
      // create child sequence and items
      cseq = child_seq::type_id::create("cseq");
      tmp = create_item(bus_trans::get_type(), m_sequencer, "req");
      // send child sequence via start()
      cseq.start(m_sequencer, this);
      // send sequence item 
      void'($cast(req, tmp));
      start_item(req);
      req.randomize with {data == 20;};
      finish_item(req);
    endtask
  endclass

在这里插入图片描述
在这里插入图片描述

  • sequencer仲裁模式；
    在这里插入图片描述
    在这里插入图片描述
child_seq seq1,seq2,seq3;
m_sequencer.set_arbitration(UVM_SEQ_ARB_STRICT_FIFO);
fork
	`uvm_do_pri_with(seq1, 500, {base == 10;})
	`uvm_do_pri_with(seq1, 500, {base == 10;})
	`uvm_do_pri_with(seq1, 300, {base == 10;})
						 //优先级
join
  • layer sequence

在这里插入图片描述

module layer_seq;
  import uvm_pkg::*;
  `include "uvm_macros.svh"

  typedef class phy_master_sequencer;
  typedef enum {CLKON, CLKOFF, RESET, WRREG, RDREG} phy_cmd_t;
  typedef enum {FREQ_LOW_TRANS, FREQ_MED_TRANS, FREQ_HIGH_TRANS} layer_cmd_t;

  class bus_trans extends uvm_sequence_item;
    rand phy_cmd_t cmd;
    rand int addr;
    rand int data;
    constraint cstr{
      soft addr == 'h0;
      soft data == 'h0;
    }
    `uvm_object_utils_begin(bus_trans)
      `uvm_field_enum(phy_cmd_t, cmd, UVM_ALL_ON)
      `uvm_field_int(addr, UVM_ALL_ON)
      `uvm_field_int(data, UVM_ALL_ON)
    `uvm_object_utils_end
    function new(string name = "bus_trans");
      super.new(name);
    endfunction
  endclass

  class packet_seq extends uvm_sequence;
    rand int len;
    rand int addr;
    rand int data[];
    rand phy_cmd_t cmd;
    constraint cstr{
      soft len inside {[30:50]};
      soft addr[31:16] == 'hFF00;
      data.size() == len;
    }
    `uvm_object_utils(packet_seq)
    function new(string name = "reg_test_seq");
      super.new(name);
    endfunction
    task body();
      bus_trans req;
      foreach(data[i])
        `uvm_do_with(req, {cmd == local::cmd; 
                           addr == local::addr;
                           data == local::data[i];})
    endtask
  endclass

  class layer_trans extends uvm_sequence_item;
    rand layer_cmd_t layer_cmd;
    rand int pkt_len;
    rand int pkt_idle;
    constraint cstr {
      soft pkt_len inside {[10: 20]};
      layer_cmd == FREQ_LOW_TRANS -> pkt_idle inside {[300:400]};
      layer_cmd == FREQ_MED_TRANS -> pkt_idle inside {[100:200]};
      layer_cmd == FREQ_HIGH_TRANS -> pkt_idle inside {[20:40]};
    }
    `uvm_object_utils(layer_trans)
    function new(string name = "layer_trans");
      super.new(name);
    endfunction
  endclass

  class adapter_seq extends uvm_sequence;
    `uvm_object_utils(adapter_seq)
    `uvm_declare_p_sequencer(phy_master_sequencer)
    function new(string name = "adapter_seq");
      super.new(name);
    endfunction
    task body();
      layer_trans trans;
      packet_seq pkt;
      forever begin
        p_sequencer.up_sqr.get_next_item(req);
        void'($cast(trans, req));
        repeat(trans.pkt_len) begin
          `uvm_do(pkt)
          delay(trans.pkt_idle);
        end
        p_sequencer.up_sqr.item_done();
      end
    endtask
    virtual task delay(int delay);
    endtask
  endclass

  class top_seq extends uvm_sequence;
    `uvm_object_utils(top_seq)
    function new(string name = "top_seq");
      super.new(name);
    endfunction
    task body();
      layer_trans trans;
      `uvm_do_with(trans, {layer_cmd == FREQ_LOW_TRANS;})
      `uvm_do_with(trans, {layer_cmd == FREQ_HIGH_TRANS;})
    endtask
  endclass

  class layering_sequencer extends uvm_sequencer;
    `uvm_component_utils(layering_sequencer)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
  endclass

  class phy_master_sequencer extends uvm_sequencer;
    layering_sequencer up_sqr;
    `uvm_component_utils(phy_master_sequencer)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
  endclass

  class phy_master_driver extends uvm_driver;
    `uvm_component_utils(phy_master_driver)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
    task run_phase(uvm_phase phase);
      REQ tmp;
      bus_trans req;
      forever begin
        seq_item_port.get_next_item(tmp);
        void'($cast(req, tmp));
        `uvm_info("DRV", $sformatf("got a item \n %s", req.sprint()), UVM_LOW)
        seq_item_port.item_done();
      end
    endtask
  endclass

  class phy_master_agent extends uvm_agent;
    phy_master_sequencer sqr;
    phy_master_driver drv;
    `uvm_component_utils(phy_master_agent)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
    function void build_phase(uvm_phase phase);
      sqr = phy_master_sequencer::type_id::create("sqr", this);
      drv = phy_master_driver::type_id::create("drv", this);
    endfunction
    function void connect_phase(uvm_phase phase);
      drv.seq_item_port.connect(sqr.seq_item_export);
    endfunction
  endclass

  class test1 extends uvm_test;
    layering_sequencer layer_sqr;
    phy_master_agent phy_agt;
    `uvm_component_utils(test1)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
    function void build_phase(uvm_phase phase);
      layer_sqr = layering_sequencer::type_id::create("layer_sqr", this);
      phy_agt = phy_master_agent::type_id::create("phy_agt", this);
    endfunction
    function void connect_phase(uvm_phase phase);
      phy_agt.sqr.up_sqr = layer_sqr;
    endfunction
    task run_phase(uvm_phase phase);
      top_seq seq;
      adapter_seq adapter;
      phase.raise_objection(phase);
      seq = new();
      adapter = new();
      fork
        adapter.start(phy_agt.sqr);
      join_none
      seq.start(layer_sqr);
      phase.drop_objection(phase);
    endtask
  endclass

  initial begin
    run_test("test1");
  end
endmodule

在这里插入图片描述

  • virtual sequence
    uvm_do_on宏用于显式地指定使用哪个sequencer发送此transaction，其参数形式为`uvm_do_on(SEQ_OR_ITEM,SEQR)，第一个参数是transaction的指针，第二个是sequencer的指针。当使用uvm_do时，它实际等价于将uvm_do_on的第二个参数设置为了默认的sequencer，即此sequence启动时为其指定的sequencer。

'uvm_do_on(data_seq, p_sequencer.chnl_sqr0)在这里插入图片描述

module virtual_seq;
  import uvm_pkg::*;
  `include "uvm_macros.svh"

  typedef class mcdf_virtual_sequencer;

  class clk_rst_seq extends uvm_sequence;
    `uvm_object_utils(clk_rst_seq)
    function new(string name = "clk_rst_seq");
      super.new(name);
    endfunction
  endclass

  class reg_cfg_seq extends uvm_sequence;
    `uvm_object_utils(reg_cfg_seq)
    function new(string name = "reg_cfg_seq");
      super.new(name);
    endfunction
  endclass

  class data_trans_seq extends uvm_sequence;
    `uvm_object_utils(data_trans_seq)
    function new(string name = "data_trans_seq");
      super.new(name);
    endfunction
  endclass

  class fmt_slv_cfg_seq extends uvm_sequence;
    `uvm_object_utils(fmt_slv_cfg_seq)
    function new(string name = "fmt_slv_cfg_seq");
      super.new(name);
    endfunction
  endclass

  // element sequences definitions above
  // which belong to different sequencers/agents
  // clk_rst_seq
  // reg_cfg_seq
  // data_trans_seq
  // fmt_slv_cfg_seq

  class mcdf_normal_seq extends uvm_sequence;
    `uvm_object_utils(mcdf_normal_seq)
    `uvm_declare_p_sequencer(mcdf_virtual_sequencer)
    function new(string name = "mcdf_normal_seq");
      super.new(name);
    endfunction
    task body();
      clk_rst_seq clk_seq;
      reg_cfg_seq cfg_seq;
      data_trans_seq data_seq;
      fmt_slv_cfg_seq fmt_seq;

      // virtual sequence is to be attached the
      // virtual sequencer, and further attache
      // its child sequences via p_sequencer.OBJ_SQR_HANDLE

      // configure formatter slave agent 
      `uvm_do_on(fmt_seq, p_sequencer.fmt_sqr)
      // turn on clock and assert reset
      `uvm_do_on(clk_seq, p_sequencer.cr_sqr)
      // configure mcdf registers
      `uvm_do_on(cfg_seq, p_sequencer.reg_sqr)
      // transfer data packets
      fork
        `uvm_do_on(data_seq, p_sequencer.chnl_sqr0)
        `uvm_do_on(data_seq, p_sequencer.chnl_sqr1)
        `uvm_do_on(data_seq, p_sequencer.chnl_sqr2)
      join
    endtask
  endclass

  class cr_master_sequencer extends uvm_sequencer;
    `uvm_component_utils(cr_master_sequencer)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
  endclass

  class reg_master_sequencer extends uvm_sequencer;
    `uvm_component_utils(reg_master_sequencer)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
  endclass

  class chnl_master_sequencer extends uvm_sequencer;
    `uvm_component_utils(chnl_master_sequencer)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
  endclass

  class fmt_slave_sequencer extends uvm_sequencer;
    `uvm_component_utils(fmt_slave_sequencer)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
  endclass

  
  class reg_master_agent extends uvm_agent;
    reg_master_sequencer sqr;
    // other agents definition/build/connect ignored
    `uvm_component_utils(reg_master_agent)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
    function void build_phase(uvm_phase phase);
      sqr = reg_master_sequencer::type_id::create("sqr", this);
    endfunction
  endclass

  class cr_master_agent extends uvm_agent;
    cr_master_sequencer sqr;
    // other agents definition/build/connect ignored
    `uvm_component_utils(cr_master_agent)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
    function void build_phase(uvm_phase phase);
      sqr = cr_master_sequencer::type_id::create("sqr", this);
    endfunction
  endclass

  class chnl_master_agent extends uvm_agent;
    chnl_master_sequencer sqr;
    // other agents definition/build/connect ignored
    `uvm_component_utils(chnl_master_agent)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
    function void build_phase(uvm_phase phase);
      sqr = chnl_master_sequencer::type_id::create("sqr", this);
    endfunction
  endclass

  class fmt_slave_agent extends uvm_agent;
    fmt_slave_sequencer sqr;
    // other agents definition/build/connect ignored
    `uvm_component_utils(fmt_slave_agent)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
    function void build_phase(uvm_phase phase);
      sqr = fmt_slave_sequencer::type_id::create("sqr", this);
    endfunction
  endclass

  // element sequencers and agents definition above
  // cr_master_sequencer | cr_master_agent
  // reg_master_sequencer | reg_master_agent
  // chnl_master_sequencer | chnl_master_agent
  // fmt_slave_sequencer | fmt_slave_agent
  class mcdf_virtual_sequencer extends uvm_sequencer;
    cr_master_sequencer cr_sqr;
    reg_master_sequencer reg_sqr;
    chnl_master_sequencer chnl_sqr0;
    chnl_master_sequencer chnl_sqr1;
    chnl_master_sequencer chnl_sqr2;
    fmt_slave_sequencer fmt_sqr;
    `uvm_component_utils(mcdf_virtual_sequencer)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
  endclass

  class mcdf_env extends uvm_env;
    cr_master_agent cr_agt;
    reg_master_agent reg_agt;
    chnl_master_agent chnl_agt0;
    chnl_master_agent chnl_agt1;
    chnl_master_agent chnl_agt2;
    fmt_slave_agent fmt_agt;
    mcdf_virtual_sequencer virt_sqr;
    `uvm_component_utils(mcdf_env)
    function new(string name, uvm_component parent);
      super.new(name, parent);
    endfunction
    function void build_phase(uvm_phase phase);
      cr_agt = cr_master_agent::type_id::create("cr_agt", this);
      reg_agt = reg_master_agent::type_id::create("reg_agt", this);
      chnl_agt0 = chnl_master_agent::type_id::create("chnl_agt", this);
      chnl_agt1 = chnl_master_agent::type_id::create("chnl_agt", this);
      chnl_agt2 = chnl_master_agent::type_id::create("chnl_agt", this);
      fmt_agt = fmt_slave_agent::type_id::create("fmt_agt", this);
      virt_sqr = mcdf_virtual_sequencer::type_id::create("virt_sqr", this);
    endfunction
    function void connect_phase(uvm_phase phase);
      // virtual sequencer connection
      // but no any TLM connection with sequencers
      virt_sqr.cr_sqr = cr_agt.sqr;
      virt_sqr.reg_sqr = reg_agt.sqr;
      virt_sqr.chnl_sqr0 = chnl_agt0.sqr;
      virt_sqr.chnl_sqr1 = chnl_agt1.sqr;
      virt_sqr.chnl_sqr2 = chnl_agt2.sqr;
      virt_sqr.fmt_sqr = fmt_agt.sqr;
    endfunction
  endclass

在这里插入图片描述

gjbt123
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
uvm学习总结_2021.1.11
01-11
关于UVM几个机制的解释。 sequence机制 简单说明：sequence机制是为了独立出“生成transaction”的这部分操作而建立的机制。 特点：  支持多种uvm_do宏命令  有优先级仲裁机制，可以控制先后发送的顺序。  virtual sequence调度sequence发送的顺序。  寄存器模型内建检查读写功能的sequence。
uvm_do系列宏介绍
m0_61703043的博客
02-23 7898
uvm_do系列宏介绍
关于UVM中的sequence(五)
weixin_45857247的博客
12-25 758
8、sequence的进阶应用 嵌套的sequence 假设一个产生CRC错误包的sequence如下： 另外一个产生长包的sequence如下： 现在要写一个新的sequence，它可以交替产生上面的两种包。那么在新的sequence里面可以这样写： 似乎这样写起来显得特别麻烦。产生的两种不同的包中，第一个约束条件有两个，第二个约束条件有三个。但是假如约束条 件有十个呢？如果整个验证平台中有30个测试用例都用到这样的两种包，那就要在这30个测试用例的sequence中加入这些代码，这
UVM学习记录
waddle_pig的博客
05-12 1713
1、Soc/ASIC/FPGA验证有什么区别 2、验证策略：白盒验证、灰盒验证、黑盒验证 3、factory机制：在不改变代码的情况下实现不同对象的替换。注册表中记录了所有注册的类；替换表中记录了哪些类替换了哪些类。 4、sequence机制：sequence、sequencer和driver是如何协作的？ ①sequence产生的事务发送给相应的sequencer，然后等待driver返回完成标志才开始下一个事务的产生 ②sequencer将收到的事务存在fifo中，当收到driver发来的事务
UVM中的sequence
Suchane的博客
03-18 257
UVM序列
UVM_Class_Reference_Manual_1.2.pdf
09-12
这些组件可以通过UVM的连接机制相互交互，如通过UVM channels（如uvm_analysis_port和uvm_sequence_port）进行数据传输。 手册中的“1.2 Class Reference”部分详细列出了每个UVM类的功能、属性和方法，这对于理解...
UVM1.1_labs_lossqet_UVM1.1_uvm验证book_UVM_uvm代码_
10-04
1. **UVM组件模型**：理解如何使用UVM预定义的组件（如sequence、sequencer、agent、monitor和driver）以及它们之间的关系是基础。 2. **配置管理**：UVM的配置机制允许动态地定制和连接组件，这是实现复用性和灵活...
UVM_adder程序.zip
12-04
在"bench"文件夹中，可能有一个自定义的序列类，该类继承自UVM基类`uvm_sequence`，并实现加法器的操作序列，如不同数值的加法操作。 4. **驱动（Driver）**：驱动是连接验证环境和被验证DUT（Design Under Test）...
uvm-1.1.zip_IC验证_IC验证资料_UVM_uvm 1.1d_uvm平台
07-14
例如，uvm_sequence_base类是所有序列的基类，它定义了基本的序列操作；uvm_agent类则包含了driver（驱动）和monitor（监视器），它们分别负责DUT的输入和输出数据的处理。通过分析这些示例代码，我们可以掌握如何...
uvm-1.2_hidden871_universal_源码_uvm1.2_UVM_
10-03
在源码中，我们可以看到如`uvm_component`、`uvm_sequence`、`uvm_agent`、`uvm_report_server`等关键类，它们构成了UVM的基础框架。 `uvm_component`是所有UVM组件的基类，它包含了生命周期管理、配置、连接和报告...
UVM学习整理——UVM通信（sequence）
lizhao_yang_的博客
11-28 4184
五、sequence UVM的sequence机制最大的作用就是将test case和testbench分离开来。 对一个项目而言，testbench是相对稳定的框架，而针对各个module要有不同的测试内容，所以具体的test case 的差异非常大。在UVM中， test和sequence类总是成对出现，实现了testbench和具体的test case的结合。test类中可以针对具体的测试内容对testbench做一些差异化配置，在sequence类中则是实现test case的具体...
[uvm]create_item ???
oldmoney
08-04 439
create_item
`uvm_do_with中约束无法生效解决方案
u012723003的博客
09-07 1675
在项目中遇到过明明在uvm_do_with中对transaction的域段做了约束，但在driver获取到seq时却无法生效约束的问题。最后排查发现是变量名的问题，如下约束值的名称var和req的var字段一致时，因为在`uvm_do_with()中，指定的作用域首先找到的是req，如果变量名一致，则会被当成是req的字段，会导致无法识别这个var是外部传入的变量，出现约束失效的情况。
【UVM源码】sequence机制使用方法和源代码解析
飓风_数字IC验证的博客
02-04 5094
UVM机制sequence的使用方法介绍，UVM机制sequence机制相关的源代码解析。
`uvm_do_with中constraint不生效的原因及解决方案
元直的博客
07-09 6194
`uvm_do_with中constraint不生效的原因及解决方案 前言：我们通常在上层的top_vseq中启动下层sub_seq或seq_item，出于灵活性或者可重用性的考虑，可能会使用`uvm_do_with对下层的random变量进行约束。为了coding方便以及增强代码可读性的考虑，上层和下层seq变量的名字可能是一样的。但是这样就会造成一个问题：我们会发现如果使用`uvm_do_with(sub_seq, {var_a == var_a});这个约束是无法生...
《UVM实战》学习笔记——第六章 sequence机制
qq_42135020的博客
12-04 5762
virtual sequence，仲裁机制，m_sequencer
uvm_sequence中的body任务能否自动执行
最新发布
weixin_49816194的博客
01-10 522
在上面的例子中，用到了宏： uvm_do。这个宏是UVM中最常用的宏之一，它用于：①创建一个my_transaction的实例m_trans；③最终将其送给 sequencer。如果不使用uvm_do宏，也可以直接使用start_item与finish_item的方式产生transaction。答：sequence启动时，自动执行body。
ic验证笔记-20天挑战day17
weixin_42954734的博客
05-15 314
1.sequence和item,sequencer和driver之间的关系 transaction在sequence中传输，到达driver
UVM 的sequence 在继承时执行body任务和pre_body任务会影响么？
weixin_40570952的博客
03-19 3381
systemverilog sequence 执行body task
uvm_sequence_library
03-16
uvm_sequence_library是UVM中的一个库，它包含了各种不同类型的sequence，这些sequence可以被用来生成测试序列。这个库中的sequence可以被继承和定制，以满足特定的测试需求。在UVM中，sequence是用来描述测试序列的一种机制，它可以被用来生成各种不同类型的测试序列，包括顺序序列、并发序列、随机序列等等。通过使用uvm_sequence_library，测试工程师可以更加方便地创建测试序列，提高测试效率和测试覆盖率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值