• [UVMC]UVM Connect基础教程

    UVM Connect基础教程

    --- Integrating SystemC into UVM

           前言：尽管 UVM 为构建参考模型提供了高级抽象，但 SystemC 在用于设计和验证的高级模型方面具有传统。 为了允许在 UVM 测试平台中重用使用 SystemC 编写的参考模型，UVMC 在 SystemC 和 SystemVerilog UVM 模型和组件之间提供 TLM1 和 TLM2 连接（参见图 1）。

                   

    Figure 1 - UVMC: SystemC and SystemVerilog sides

           对于 TLM 通信，验证组件必须同意它们正在交换的数据。 使用事务参数化这些组件使它们能够建立 UVMC 连接 [1]。 

    一、一个例子

           为了说明 UVM Connect 的使用，将使用图 2 的测试平台作为示例。 与简单的加法器测试台不同，这个测试台没有监视器，也没有驱动程序，一旦检查的是模块refmod_low（用SystemC编写）的操作，在refmod（用SystemC编写的另一个模块）的操作中。

           两个 refmod 的操作都非常简单：它们只是获取来自 uvm_tlm_analysis_fifo 的 from_refmod 和 from_refmod_low 的事务（带有消息的字符串），并将这些事务分别放入 uvm_tlm_fifo 的 to_refmod 和 to_refmod_low 中。

           序列读取图 3 的树的文件，并且定序器将事务发送到 path_tr，其中使用 analysis_port 将其传输到 uvm_tlm_analysis_fifo 的 from_refmod 和 from_refmod_low。

     Figure 3 - Tree containing transactions for the sequence

           测试平台的代码及其 refmods 可以在下面看到。

    • The class packet_in that defines the input transaction
    1. class packet_in extends uvm_sequence_item;
    2.     string message;
    3.  
    4.     `uvm_object_utils_begin(packet_in)
    5.         `uvm_field_string(message, UVM_DEFAULT|UVM_HEX)
    6.     `uvm_object_utils_end
    8.     function new(string name="packet_in");
    9.         super.new(name);
    10.     endfunction: new
    11. endclass: packet_in
    •  The class packet_out that defines the output transaction
    1. class packet_out extends uvm_sequence_item;
    2.     string message;
    3.  
    4.     `uvm_object_utils_begin(packet_out)
    5.         `uvm_field_string(message, UVM_DEFAULT|UVM_HEX)
    6.     `uvm_object_utils_end
    8.     function new(string name="packet_in");
    9.         super.new(name);
    10.     endfunction: new
    11. endclass: packet_out
    •  The sequence_in that generates the transactions withe the DPI function read_message()
    1. import "DPI-C" context function string read_message(string msg);
    2.  
    3. class sequence_in extends uvm_sequence #(packet_in);
    4.     `uvm_object_utils(sequence_in)
    5.  
    6.     function new(string name="sequence_in");
    7.         super.new(name);
    8.     endfunction: new
    9.     
    10.     int data_file, scan_file;
    11.     string filename;
    12.     
    13.     function void open_file();
    14.       data_file = $fopen("myfile.txt", "r");
    15.       if(data_file == 0)begin
    16.          $display("file could not be open!!!");
    17.       end
    18.      endfunction: open_file
    19.   
    20.     task body();
    21.         packet_in tr;
    22.         open_file();
    23.         while(1)begin
    24.             scan_file = $fscanf(data_file, "%s", filename);
    25.             tr = packet_in::type_id::create("tr");
    26.             start_item(tr);
    27.             tr.message = read_message(filename);
    28.             finish_item(tr);
    29.             if($feof(data_file))
    30.                 break;
    31.         end
    32.         $finish();
    33.     endtask: body
    34. endclass: sequence_in
    •  The DPI function called in the sequence_in
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace std;
    7.  
    8. extern "C" const char* read_message(const char* message){
    9.    string msg;
    10.    ifstream myfile(message);
    11.    if(myfile.is_open()){
    12.       getline(myfile, msg);
    13.       return msg.c_str();
    14.    }
    15.    else
    16.      cout << "unable to open file";
    17. }
    •  The sequencer that sends the transaction to the class path_tr
    1. class sequencer extends uvm_sequencer #(packet_in);
    2.     `uvm_component_utils(sequencer)
    3.  
    4.     function new (string name = "sequencer", uvm_component parent = null);
    5.         super.new(name, parent);
    6.     endfunction
    7. endclass: sequencer
    • The class path_tr that trasmits the transaction to the uvm_tlm_analysis_fifo's from_refmod and from_refmod_low using an analysis_port
    1. class path_tr extends uvm_driver #(packet_in);
    2.     packet_in tr;
    3.    
    4.     `uvm_component_utils(path_tr)
    5.     uvm_analysis_port #(packet_in) item_collected_port;
    6.     
    7.    function new(string name, uvm_component parent);
    8.         super.new(name, parent);
    9.         item_collected_port = new ("item_collected_port", this);
    10.     endfunction
    11.     
    12.     virtual task run_phase(uvm_phase phase);
    13.       forever begin
    14.         seq_item_port.get_next_item(tr);
    15.         begin_tr(tr, "path_tr");
    16.           item_collected_port.write(tr);
    17.         end_tr(tr);
    18.         seq_item_port.item_done();
    19.       end
    20.     endtask
    21. endclass: path_tr
    •  The refmod (written in SystemC)
    1. #include "systemc.h"
    2. #include "tlm.h"
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. using namespace tlm;
    8.  
    9. struct tr {
    10.   string message;
    11. };
    12.  
    13. #include "uvmc.h"
    14. using namespace uvmc;
    15. UVMC_UTILS_1(tr, message)
    16.  
    17.  
    18. SC_MODULE(refmod) {
    19.   sc_port > in;
    20.   sc_port > out;
    21.  
    22.   void p() {
    23.     
    24.     tr tr;
    25.     while(1){
    26.       tr = in->get();
    27.       cout <<"refmod: " <"\n";
    28.       out->put(tr);
    29.     }
    30.   }
    31.   SC_CTOR(refmod): in("in"), out("out") { SC_THREAD(p); }
    32. };
    • The refmod_low (written in SystemC)
    1. SC_MODULE(refmod_low){
    2.   sc_port > in;
    3.   sc_port > out;
    4.  
    5.   void p() {
    6.     
    7.     tr tr;
    8.     while(1){
    9.       tr = in->get();
    10.       cout <<"refmod_low: " <"\n";
    11.       out->put(tr);
    12.     }
    13.   }
    14.   SC_CTOR(refmod_low): in("in"), out("out") { SC_THREAD(p); }
    15. };
    •  The sc_main (file top.cpp) for making connections on the SystemC side
    1. #include "refmod.cpp"
    2. #include "refmod_low.cpp"
    3.  
    4. int sc_main(int argc, char* argv[]) {
    5.  
    6.   refmod  refmod_i("refmod_i");
    7.   refmod_low refmod_low_i("refmod_low_i");
    8.   
    9.   uvmc_connect(refmod_i.in, "refmod_i.in");
    10.   uvmc_connect(refmod_low_i.in, "refmod_low_i.in");
    11.   uvmc_connect(refmod_i.out, "refmod_i.out");
    12.   uvmc_connect(refmod_low_i.out, "refmod_low_i.out");
    13.  
    14.   sc_start();
    15.   return(0);
    16. }
    •  The class comparator that expects transactions from the outputs of the refmod and refmod_low in order to compare them
    1. class comparator #(type T = packet_in) extends uvm_scoreboard;
    2.    typedef comparator #(T) this_type;
    3.    `uvm_component_utils(this_type)
    4.     
    5.     uvm_tlm_fifo #(T) from_refmod;
    6.     uvm_tlm_fifo#(T) from_refmod_low;    
    7.     
    8.      T tr1, tr2;
    9.      int match, mismatch;
    10.  
    11.     function new(string name, uvm_component parent);
    12.       super.new(name, parent);
    13.       from_refmod = new("from_refmod", null, 1); 
    14.       from_refmod_low = new("from_refmod_low", null, 1);
    15.       tr1 = new("tr1");
    16.       tr2 = new("tr2");
    17.     endfunction
    18.  
    19.     function void connect_phase(uvm_phase phase);
    20.         uvmc_tlm1 #(T)::connect(from_refmod.put_export, "refmod_i.out");
    21.         uvmc_tlm1#(T)::connect(from_refmod_low.put_export, "refmod_low_i.out");
    22.     endfunction: connect_phase
    23.    
    24.     task run_phase(uvm_phase phase);
    25.       forever begin
    26.         from_refmod.get(tr1);
    27.         from_refmod_low.get(tr2);
    28.         compare();
    29.       end
    30.     endtask: run_phase
    31.  
    32.     virtual function void compare();
    33.       if(tr1.message == tr2.message) begin
    34.         $display("Comparator MATCH");
    35.         match++;
    36.       end
    37.       else begin
    38.         $display("Comparator MISMATCH");
    39.         mismatch++;
    40.       end
    41.     endfunction: compare
    42.    
    43. endclass: comparator
    •  The environment class
    1. `include "comparator.sv"
    2.  
    3. class env extends uvm_env;
    4.     sequencer sqr;
    5.     path_tr path;
    6.     comparator #(packet_out) comp;
    7.  
    8.     uvm_tlm_analysis_fifo #(packet_in) to_refmod;
    9.     uvm_tlm_analysis_fifo #(packet_in) to_refmod_low;
    10.  
    11.     `uvm_component_utils(env)
    12.  
    13.     function new(string name, uvm_component parent = null);
    14.         super.new(name, parent);       
    15.         to_refmod = new("to_refmod", this);
    16.         to_refmod_low = new("to_refmod_low", this);
    17.     endfunction
    18.  
    19.     virtual function void build_phase(uvm_phase phase);
    20.         super.build_phase(phase);
    21.         sqr = sequencer::type_id::create("sqr", this);
    22.         path = path_tr::type_id::create("path", this);
    23.         comp = comparator #(packet_out)::type_id::create("comp", this);
    24.     endfunction
    25.  
    26.     virtual function void connect_phase(uvm_phase phase);
    27.         path.seq_item_port.connect(sqr.seq_item_export);
    28.         path.item_collected_port.connect(to_refmod.analysis_export);
    29.         uvmc_tlm1 #(packet_in)::connect(to_refmod.get_export, "refmod_i.in");
    30.  
    31.         path.item_collected_port.connect(to_refmod_low.analysis_export);
    32.         uvmc_tlm1 #(packet_in)::connect(to_refmod_low.get_export, "refmod_low_i.in");
    33.     endfunction
    34.  
    35.     virtual function void end_of_elaboration_phase(uvm_phase phase);
    36.         super.end_of_elaboration_phase(phase);
    37.     endfunction
    38.   
    39. endclass
    •  The test class
    1. class test extends uvm_test;
    2.   env env_h;
    3.   sequence_in seq;
    4.  
    5.   `uvm_component_utils(test)
    6.  
    7.   function new(string name, uvm_component parent = null);
    8.     super.new(name, parent);
    9.   endfunction
    10.  
    11.   virtual function void build_phase(uvm_phase phase);
    12.     super.build_phase(phase);
    13.     env_h = env::type_id::create("env_h", this);
    14.     seq = sequence_in::type_id::create("seq", this);
    15.   endfunction
    16.  
    17.   task run_phase(uvm_phase phase);
    18.     seq.start(env_h.sqr);
    19.   endtask: run_phase
    20.  
    21. endclass: test
    •  The top module(top.sv)
    1. import uvm_pkg::*;
    2. import uvmc_pkg::*;
    3.  
    4. `include "uvm_macros.svh"
    5. `include "packet_in.sv"
    6. `include "packet_out.sv"
    7. `include "sequence_in.sv"
    8. `include "sequencer.sv"
    9. `include "path_tr.sv"
    10. `include "env.sv"
    11. `include "test.sv"
    12.  
    13. //Top
    14. module top;
    15.   
    16.   initial begin
    17.     `ifdef INCA
    18.        $recordvars();
    19.     `endif
    20.     `ifdef VCS
    21.        $vcdpluson;
    22.     `endif
    23.     `ifdef QUESTA
    24.        $wlfdumpvars();
    25.        set_config_int("*", "recording_detail", 1);
    26.     `endif
    27.     
    28.     run_test("test");
    29.   end
    30. endmodule
    •  在顶部模块中，应导入 uvm 连接包（import uvmc_pkg::*;）。 图 4 显示了 refmod 和 refmod_low（SystemC 端）与比较器（SystemVerilog 端）之间的连接。

    • SystemC端的连接可以在sc_main的以下几行中看到：
    1. uvmc_connect(refmod_i.out, "refmod_i.out");
    2. uvmc_connect(refmod_low_i.out, "refmod_low_i.out");
    •  SystemVerilog 端的连接可以在比较器的以下行中看到：
    1. function void connect_phase(uvm_phase phase);
    2.         uvmc_tlm1 #(T)::connect(from_refmod.put_export, "refmod_i.out");
    3.         uvmc_tlm1#(T)::connect(from_refmod_low.put_export, "refmod_low_i.out");
    4. endfunction: connect_phase

  • 相关阅读:
    tp6教程
    Linux——手把手教你解决sudo指令无法使用的问题
    【老生谈算法】自动控制中常用的Matlab函数合集——自动控制
    linux中安装jdk
    【C++实现】线程池的设计与实现
    第15章 Linux的Makefile与Cmake编程
    网站上线如何检查?
    Riverlane联手Rigetti：解决超导量子计算机关键纠错步骤
    制作出浪漫玫瑰？SoildWorks：“我可以！”
    利用pytorch自定义CNN网络（四）：损失函数和优化器
  • 原文地址：https://blog.csdn.net/gsjthxy/article/details/126877213