文章目录
前言
UVM(Universal Verification Methodology),其正式版是在2011年2月由Accellera推出的,得到了Sysnopsys、Mentor和Cadence的支持。UVM几乎完全继承了OVM,同时又采纳了Synopsys在VMM中的寄存器解决方案RAL。同时,UVM还吸收了VMM中的一些优秀的实现方式。可以说,UVM继承了VMM和OVM的优点,克服了各自的缺点,代表了验证方法学的发展方向。
本文以《UVM实战》实战中源代码为例,介绍了UVM验证平台的搭建过程,了解各个组件的构成及UVM整体框架。
1. dut 介绍
DUT的功能为: 通过rxd接收数据,再通过txd发送出去。其中rx_dv是接收的数据有效指示,tx_en是发送的数据有效指示。代码如下:
module dut(clk,rst_n,rxd,rx_dv,txd,tx_en);
input clk;
input rst_n;
input [7:0]rxd;
input rx_dv;
output [7:0]txd;
output tx_en;
reg[7:0] txd;
reg tx_en;
always @(posedge clk) begin
if (!rst_n) begin
txd <= 8'b0;
tx_en <= 1'b0;
end
else begin
txd <= rxd;
tx_en <= rx_dv;
end
end
endmodule
2. driver 介绍
在UVM验证平台中,driver只负责驱动transaction,而不负责产生transaction。激励的产生是通过sequence机制作用。其有两大组成部分,一是sequence,二是sequencer。driver作为uvm_component组件,需要通过UVM的工厂机制在uvm_component_utils(my_driver)中完成注册。
在本例中,通过drive_one_pkt函数将激励驱动到vif.data上,pack_bytes为打包函数,可以将tr中数据打包成byte流
`ifndef MY_DRIVER_SV
`define MY_DRIVER_SV
`include "my_transaction.sv"
class my_driver extends uvm_driver#(my_transaction);
virtual my_if vif;
`uvm_component_utils(my_driver)//factory Registration mechanism
function new(string name = "my_driver", uvm_component parent = null);
super.new(name, parent);
`uvm_info("my_driver", "new is called", UVM_LOW);
endfunction
virtual function void build_phase(uvm_phase phase);
super.build_phase(phase);
`uvm_info("my_driver", "build_phase is called", UVM_LOW);
if(!uvm_config_db#(virtual my_if)::get(this, "", "vif", vif))
`uvm_fatal("my_driver", "virtual interface must be set for vif!!!")
endfunction
extern task main_phase (uvm_phase phase);
extern task drive_one_pkt(my_transaction tr);
endclass
task my_driver::main_phase(uvm_phase phase);
vif.data <= 8'b0;
vif.valid <=1'b0;
while(!vif.rst_n ) begin
@(posedge vif.clk);
end
while(1) begin
seq_item_port.try_next_item(req);
drive_one_pkt(req);
seq_item_port.item_done();//When the driver completes, call item_done to notify sequencer: Handshake mechanism
end
endtask
task my_driver::drive_one_pkt(my_transaction tr);
byte unsigned data_q[];
int data_size;
data_size = tr.pack_bytes(data_q)/8;
`uvm_info("my_driver", "begin to drive one pkt", UVM_LOW);
repeat(3) @(posedge vif.clk);
for(int i = 0; i<data_size; i++) begin
@(posedge vif.clk);
vif.valid <= 1'b1;
data_q = new(data_size);
vif.data <= data_q[i];
end
@(posedge vif.clk);
vif.valid <= 1'b0;
`uvm_info("my_driver", "end drive one pkt", UVM_LOW);
endtask
`endif
3. uvm_sequence与uvm_sequencer
sequence不属于验证平台的任何一部分,但是它与sequencer之间有密切的联系。只有sequencer的帮助下,sequence产生出的transaction才能最终送给driver;同样,sequencer只有在sequence出现的情况下才能体现其价值,如果没有sequence,sequencer就几乎没有任何作用。
每一个sequence都派生自uvm_sequence。每一个sequence都有一个body任务,当一个sequence启动时,会自动执行body中的代码。 `uvm_do宏有如下作用:1)创建my_transaction实例my_trans ,2)将其随机化 ,3)最终将其送个sequencer
`ifndef MY_SEQUENCE__SV
`define MY_SEQUENCE__SV
`include "my_transaction.sv"
class my_sequence extends uvm_sequence #(my_transaction);
my_transaction m_trans;
function new(string name= "my_sequence");
super.new(name);
endfunction
virtual task body();
if(starting_phase != null)
starting_phase.raise_objection(this);
repeat (10) begin
`uvm_do(m_trans)//macro of `uvm_do create a my_transaction instance m_trans;randomize it;Finally give it away sequencer.
end
#1000;
if(starting_phase != null)
starting_phase.drop_objection(this);//相当于$finish
endtask
`uvm_object_utils(my_sequence)
endclass
`endif
`ifndef MY_SEQUENCER_SV
`define MY_SEQUENCER_SV
class my_sequencer extends uvm_sequencer #(my_transaction);
function new (string name,uvm_component parent);
super.new(name,parent);
endfunction
`uvm_component_utils(my_sequencer)
endclass
`endif
4. my_transaction
transaction是一个抽象的概念。一般来说,物理协议中的数据交换都是以帧或者包为单位的,通常在一帧或者一个包中要定义好各项参数,每个包的大小不一样。很少会有协议是以bit或者byte为单位来进行数据交换的。以以太网为例,每个包的大小至少是64byte。这个包中要包括源地址、目的地址、包的类型、整个包的CRC校验数据等。transaction就是用于模拟这种实际情况,一笔transaction就是一个包。在不同的验证平台中,会有不同的transaction。
`ifndef MY_TRANSACTION_SV
`define MY_TRANSACTION_SV
`include "uvm_macros.svh"//a file in the UVM
import uvm_pkg::*;
class my_transaction extends uvm_sequence_item;
rand bit[47:0] dmac;//A 48-bit Ethernet destination address
rand bit[47:0] smac;// a 48-bit Ethernet source address
rand bit[15:0] ether_type;
rand byte pload[];//the size of the data
rand bit[31:0] crc;
constraint pload_cons{pload.size >= 46; pload.size <= 1500;}
function bit [31:0] calc_crc;
return 32'h0;
endfunction
function void post_randomize();
crc = calc_crc;
endfunction
`uvm_object_utils_begin(my_transaction)
`uvm_field_int(dmac, UVM_ALL_ON)
`uvm_field_int(smac, UVM_ALL_ON)
`uvm_field_int(ether_type, UVM_ALL_ON)
`uvm_field_array_int(pload, UVM_ALL_ON)
`uvm_field_int(crc, UVM_ALL_ON)
`uvm_object_utils_end
function new(string name = "my_transaction");
super.new(name);
endfunction
endclass
`endif
注意:
1.transaction的基类是uvm_sequence_item。在UVM中,所有的transaction都要从uvm_sequence_item派生,只有从uvm_sequence_item派生的transaction才可以使用UVM中强大的sequence机制。
2.可以通过域的自动化实现my_transaction的factory注册,从而可以直接调用copy、compare、print等函数,而无需自己定义。
5. 加入monitor
验证平台必须监测DUT的行为,只有知道DUT的输入输出信号变化之后,才能根据这些信号变化来判定DUT的行为是否正确。验证平台中实现监测DUT行为的组件是monitor。driver负责把transaction级别的数据转变成DUT的端口级别,并驱动给DUT,monitor的行为与其相对,用于收集DUT的端口数据,并将其转换成transaction交给后续的组件如reference model、scoreboard等处理。
`ifndef MY_MONITOR__SV
`define MY_MONITOR__SV
`include "my_transaction.sv"
class my_monitor extends uvm_monitor;
virtual my_if vif;
uvm_analysis_port #(my_transaction) ap;//Parameterized class
`uvm_component_utils(my_monitor)
function new(string name = "my_monitor", uvm_component parent = null);
super.new(name, parent);
endfunction
virtual function void build_phase(uvm_phase phase);
super.build_phase(phase);
if(!uvm_config_db#(virtual my_if)::get(this, "", "vif", vif))
`uvm_fatal("my_monitor", "virtual interface must be set for vif!!!")
ap = new("ap", this);
endfunction
extern task main_phase(uvm_phase phase);
extern task collect_one_pkt(my_transaction tr);
endclass
task my_monitor::main_phase(uvm_phase phase);
my_transaction tr;
while(1) begin
tr = new("tr");
collect_one_pkt(tr);
ap.write(tr);
end
endtask
task my_monitor::collect_one_pkt(my_transaction tr);
byte unsigned data_q[$];
byte unsigned data_array[];
logic [7:0] data;
logic valid = 0;
int data_size;
while(1) begin//因为monitor需要时刻收集数据
@(posedge vif.clk);
if(vif.valid) break;
end
`uvm_info("my_monitor", "begin to collect one pkt", UVM_LOW);
while(vif.valid) begin
data_q.push_back(vif.data);
@(posedge vif.clk);
end
data_size = data_q.size();
data_array = new[data_size];//动态数组使用前必须new
for(int i =0; i<data_size; i++) begin
data_array[i] = data_q[i];
end
tr.pload = new[data_size - 18];//pload in tr is a dynamic array, need to call pload in tr,Unpack_bytes specifies the size previously
data_size = tr.unpack_bytes(data_array)/8;
`uvm_info("my_monitor", "end collect one pkt, print it:", UVM_LOW);
endtask
`endif
collect_one_pkt与driver中的driver_one_pkt功能相似,收集被driver驱动到总线上的数据,通过unpack_bytes函数将data_array中的bytes流数据解析成tr数据。
6. 加入agent
driver和monitor处理的是同一种协议,在同样一套既定的规则下做着不同的事情。由于二者的这种相似性,UVM中通常将二者封装在一起,成为一个agent。因此,不同的agent就代表了不同的协议,由于sequencer与driver的关系非常密切,因此要把其加入agent中。
`ifndef MY_AGENT__SV
`define MY_AGENT__SV
`include "my_driver.sv"
`include "my_monitor.sv"
`include "my_sequencer.sv"
class my_agent extends uvm_agent;
my_sequencer sqr;
my_driver drv;
my_monitor mon;
uvm_analysis_port #(my_transaction) ap;
function new(string name, uvm_component parent);
super.new(name, parent);
endfunction
extern virtual function void build_phase(uvm_phase phase);
extern virtual function void connect_phase(uvm_phase phase);
`uvm_component_utils(my_agent)
endclass
function void my_agent::build_phase(uvm_phase phase);
super.build_phase(phase);
if(is_active == UVM_ACTIVE) begin//The default value of is_active is UVM_ACTIVE
sqr = my_sequencer::type_id::create("sqr", this);
drv = my_driver::type_id::create("drv", this);
end
mon = my_monitor::type_id::create("mon", this);
endfunction
function void my_agent::connect_phase(uvm_phase phase);
super.connect_phase(phase);
if (is_active == UVM_ACTIVE) begin
drv.seq_item_port.connect(sqr.seq_item_export);//connect uvm_driver and uvm_sequencer
end
ap = mon.ap;
endfunction
`endif
在connect_phase中,将driver中的seq_item_port和在uvm_sequencer中有成员变量seq_item_export,这两者之间可以建立一个“通道”。含义:driver向sequencer申请数据,然后等待sequence将数据发送给sequencer并将数据给driver,且会复制一份数据,当数据传输完成时,driver会发送seq_item_port.item_done信号给sequencer,未没有收到此信号之前,会一直保留数据。
7. 加入reference model
reference model用于完成和DUT相同的功能。reference model的输出被scoreboard接收,用于和DUT的输出相比较。此处DUT很简单,对应的reference model并不复杂。
reference model 需要从i_agent接收my_transaction,同时将输出结果以my_transaction形式传递给my_scoreboard。在UVM中通常使用TLM实现uvm component之间transaction级别的通信。
数据的接收:uvm_blocking_get_port,参数化的类,声明完后再build_phase中进行实例化,通过get任务接受传过来的transaction;
数据的发送:uvm_analysis_port,也是一个参数化的类,声明完后再build_phase中进行实例化,通过其内建函数write()将数据写入到my_transaction的实例中。
`ifndef MY_MODEL__SV
`define MY_MODEL__SV
`include "my_transaction.sv"
class my_model extends uvm_component;
uvm_blocking_get_port #(my_transaction) port;
uvm_analysis_port #(my_transaction) ap;//send to scoreboard
extern function new(string name, uvm_component parent);
extern function void build_phase(uvm_phase phase);
extern virtual task main_phase(uvm_phase phase);
`uvm_component_utils(my_model)
endclass
function my_model::new(string name, uvm_component parent);
super.new(name, parent);
endfunction
function void my_model::build_phase(uvm_phase phase);
super.build_phase(phase);
port = new("port", this);
ap = new("ap", this);
endfunction
task my_model::main_phase(uvm_phase phase);
my_transaction tr;
my_transaction new_tr;
super.main_phase(phase);
while(1) begin
port.get(tr);
new_tr = new("new_tr");
new_tr.copy(tr);
`uvm_info("my_model", "get one transaction, copy and print it:", UVM_LOW)
new_tr.print();
ap.write(new_tr);//write function of uvm_analysis_port
end
endtask
`endif
8. 加入scoreboard
my_scoreboard要比较的数据一是来源于reference model,二是来源于o_agt的monitor。前者通过exp_port获取,而后者通过act_port获取。在main_phase中通过fork建立起了两个进程,一个进程处理exp_port的数据,当收到数据后,把数据放入expect_queue中;另外一个进程处理act_port的数据,这是DUT的输出数据,当收集到这些数据后,从expect_queue中弹出之前从exp_port收到的数据,并调用my_transaction的my_compare函数。采用这种比较处理方式的前提是exp_port要比act_port先收到数据。由于DUT处理数据需要延时,而reference model是基于高级语言的处理,一般不需要延时,因此可以保证exp_port的数据在act_port的数据之前到来。
`ifndef MY_SCOREBOARD__SV
`define MY_SCOREBOARD__SV
`include "my_transaction.sv"
class my_scoreboard extends uvm_scoreboard;
my_transaction expect_queue[$];
uvm_blocking_get_port #(my_transaction) exp_port;//from my_model
uvm_blocking_get_port #(my_transaction) act_port;//from o_agent
`uvm_component_utils(my_scoreboard)
extern function new(string name, uvm_component parent = null);
extern virtual function void build_phase(uvm_phase phase);
extern virtual task main_phase(uvm_phase phase);
endclass
function my_scoreboard::new(string name, uvm_component parent = null);
super.new(name, parent);
endfunction
function void my_scoreboard::build_phase(uvm_phase phase);
super.build_phase(phase);
exp_port = new("exp_port", this);
act_port = new("act_port", this);
endfunction
task my_scoreboard::main_phase(uvm_phase phase);
my_transaction get_expect, get_actual, tmp_tran;
bit result;
super.main_phase(phase);
fork
while (1) begin
exp_port.get(get_expect);
expect_queue.push_back(get_expect);
end
while (1) begin
act_port.get(get_actual);
if(expect_queue.size() > 0) begin
tmp_tran = expect_queue.pop_front();
result = get_actual.compare(tmp_tran);
if(result) begin
`uvm_info("my_scoreboard", "Compare SUCCESSFULLY", UVM_LOW);
end
else begin
`uvm_error("my_scoreboard", "Compare FAILED");
$display("the expect pkt is");
tmp_tran.print();
$display("the actual pkt is");
get_actual.print();
end
end
else begin
`uvm_error("my_scoreboard", "Received from DUT, while Expect Queue is empty");
$display("the unexpected pkt is");
get_actual.print();
end
end
join
endtask
`endif
9. 加入env
`ifndef MY_ENV_SV
`define MY_ENV_SV
`include "my_agent.sv"
`include "my_model.sv"
`include "my_scoreboard.sv"
class my_env extends uvm_env;
my_agent i_agt;
my_agent o_agt;
my_model mdl;
my_scoreboard scd;
uvm_tlm_analysis_fifo #(my_transaction) agt_mdl_fifo;
uvm_tlm_analysis_fifo #(my_transaction) agt_scb_fifo;
uvm_tlm_analysis_fifo #(my_transaction) mdl_scb_fifo;
function new(string name = "my_env", uvm_component parent);
super.new(name, parent);
endfunction
virtual function void build_phase(uvm_phase phase);
super.build_phase(phase);
i_agt = my_agent::type_id::create("i_agt", this);
o_agt = my_agent::type_id::create("o_agt", this);
i_agt.is_active = UVM_ACTIVE;
o_agt.is_active = UVM_PASSIVE;//No driver is required on the output port, just need to monitor the signal
mdl = my_model::type_id::create("mdl", this);
scd = my_scoreboard::type_id::create("scd", this);
agt_mdl_fifo = new("agt_mdl_fifo", this);
agt_scb_fifo = new("agt_scb_fifo", this);
mdl_scb_fifo = new("mdl_scb_fifo", this);
endfunction
extern virtual function void connect_phase(uvm_phase phase);
`uvm_component_utils(my_env)
endclass
function void my_env::connect_phase(uvm_phase phase);
super.connect_phase(phase);
i_agt.ap.connect(agt_mdl_fifo.analysis_export);//the connect_phase of my_agent performed before the my_env
mdl.port.connect(agt_mdl_fifo.blocking_get_export);
mdl.ap.connect(mdl_scb_fifo.analysis_export);
scd.exp_port.connect(mdl_scb_fifo.blocking_get_export);
o_agt.ap.connect(agt_scb_fifo.analysis_export);
scd.act_port.connect(agt_scb_fifo.blocking_get_export);
endfunction
`endif
这个容器类env中实例化了driver、monitor、reference model和scoreboard等。在调用run_test时,传递的参数不再是my_driver,而是这个容器类,即让UVM自动创建这个容器类的实例。在UVM中,这个容器类称为uvm_env
10.验证平台顶层top_tb
首先uvm_macros.svh文件包含进来,该文件包含了许多uvm框架所使用到的宏;其次通过import将uvm_pkg导入到整个验证平台。
`timescale 1ns/1ps
`include "uvm_macros.svh"//a file in the UVM
import uvm_pkg::*;//uvm library
`include "my_transaction.sv"
`include "my_sequencer.sv"
`include "my_driver.sv"
`include "my_monitor.sv"
`include "my_agent.sv"
`include "my_model.sv"
`include "my_scoreboard.sv"
`include "my_env.sv"
`include "base_test.sv"
`include "my_case0.sv"
interface my_if(input clk, input rst_n);
logic [7:0] data;
logic valid;
endinterface
module top_tb;
reg clk;
reg rst_n;
reg [7:0]rxd;
reg rx_dv;
wire [7:0]txd;
wire tx_en;
my_if input_if(clk, rst_n);
my_if output_if(clk, rst_n);
dut my_dut(.clk(clk),
.rst_n(rst_n),
.rxd(input_if.data),
.rx_dv(input_if.valid),
.txd(output_if.data),
.tx_en(output_if.valid));
initial begin//clock generation
clk = 0;
forever begin
#100 clk <= ~clk;
end
end
initial begin
rst_n = 1'b0;
#2 $display ("rst_n is %0b", rst_n);
#1000;
rst_n = 1'b1;
end
//Passed to my_drive through config_db
initial begin
run_test("my_case0");//Automatic instance creation by +UVM_TEST_NAME
end
initial begin
uvm_config_db#(virtual my_if)::set(null, "uvm_test_top.env.i_agt.drv", "vif", input_if);//The fourth parameter indicates which interface to add
uvm_config_db#(virtual my_if)::set(null, "uvm_test_top.env.i_agt.mon", "vif", input_if);
uvm_config_db#(virtual my_if)::set(null, "uvm_test_top.env.o_agt.mon", "vif", output_if);
end
endmodule
在top_tb中通过set设置virtual interface,而在driver或者monitor中通过get函数得到virtual interface。 在run_test中可以启动测试用例,可以通过 +UVM_TEST_NAME命令指定case启动。
11.创建base_test
base_test派生自uvm_test,使用uvm_component_utils宏来注册到factory中。在build_phase中实例化my_env,并设置sequencer的default_sequence来启动sequencer。除了实例化env外,base_test中做的事情在不同的公司各不相同。上面的代码中出现了report_phase,在report_phase中根据UVM_ERROR的数量来打印不同的信息。一些日志分析工具可以根据打印的信息来判断DUT是否通过了某个测试用例的检查。
`ifndef BASE_TEST__SV
`define BASE_TEST__SV
`include "my_sequence.sv"
`include "my_env.sv"
`include "my_sequencer.sv"
class base_test extends uvm_test;
my_env env;//all case need to instantiated env
function new(string name = "base_test", uvm_component parent = null);
super.new(name,parent);
endfunction
extern virtual function void build_phase(uvm_phase phase);
extern virtual function void report_phase(uvm_phase phase);
`uvm_component_utils(base_test)
endclass
function void base_test::build_phase(uvm_phase phase);
super.build_phase(phase);
env = my_env::type_id::create("env", this);
uvm_config_db#(uvm_object_wrapper)::set(this,
"env.i_agt.sqr.main_phase",
"default_sequence",
my_sequence::type_id::get());start the sequence by default_sequence
endfunction
function void base_test::report_phase(uvm_phase phase);
uvm_report_server server;
int err_num;
super.report_phase(phase);
server = get_report_server();
err_num = server.get_severity_count(UVM_ERROR);
if (err_num != 0) begin
$display("TEST CASE FAILED");
end
else begin
$display("TEST CASE PASSED");
end
endfunction
`endif
12.添加测试用例:my_case0
测试用例都是基于base_test派生的一个类
`ifndef MY_CASE0__SV
`define MY_CASE0__SV
`include "base_test.sv"
class case0_sequence extends uvm_sequence #(my_transaction);
my_transaction m_trans;
function new(string name= "case0_sequence");
super.new(name);
endfunction
virtual task body();
if(starting_phase != null)
starting_phase.raise_objection(this);
repeat (10) begin
`uvm_do(m_trans)
end
#100;
if(starting_phase != null)
starting_phase.drop_objection(this);
endtask
`uvm_object_utils(case0_sequence)
endclass
class my_case0 extends base_test;
function new(string name = "my_case0", uvm_component parent = null);
super.new(name,parent);
endfunction
extern virtual function void build_phase(uvm_phase phase);
`uvm_component_utils(my_case0)
endclass
function void my_case0::build_phase(uvm_phase phase);
super.build_phase(phase);
uvm_config_db#(uvm_object_wrapper)::set(this,
"env.i_agt.sqr.main_phase",
"default_sequence",
case0_sequence::type_id::get());//start directly by case0_sequence.start
endfunction
`endif
13. 添加测试用例:my_case1
`ifndef MY_CASE1__SV
`define MY_CASE1__SV
class case1_sequence extends uvm_sequence #(my_transaction);
my_transaction m_trans;
function new(string name= "case1_sequence");
super.new(name);
endfunction
virtual task body();
if(starting_phase != null)
starting_phase.raise_objection(this);
repeat (10) begin
`uvm_do_with(m_trans, { m_trans.pload.size() == 60;})
end
#100;
if(starting_phase != null)
starting_phase.drop_objection(this);
endtask
`uvm_object_utils(case1_sequence)
endclass
class my_case1 extends base_test;
function new(string name = "my_case1", uvm_component parent = null);
super.new(name,parent);
endfunction
extern virtual function void build_phase(uvm_phase phase);
`uvm_component_utils(my_case1)
endclass
function void my_case1::build_phase(uvm_phase phase);
super.build_phase(phase);
uvm_config_db#(uvm_object_wrapper)::set(this,
"env.i_agt.sqr.main_phase",
"default_sequence",
case1_sequence::type_id::get());
endfunction
`endif