uvm_agent+configuration object+configuration database(uvm验证平台)

资料来源

(1) 《The UVM Primer》第22章

1.top.sv

module top;
   import uvm_pkg::*;
   import   tinyalu_pkg::*;
`include "tinyalu_macros.svh"
`include "uvm_macros.svh"
   
 tinyalu_bfm       class_bfm();
   
 tinyalu class_dut (.A(class_bfm.A), .B(class_bfm.B), .op(class_bfm.op), 
                    .clk(class_bfm.clk), .reset_n(class_bfm.reset_n), 
                    .start(class_bfm.start), .done(class_bfm.done), 
                    .result(class_bfm.result));

 tinyalu_bfm       module_bfm();

 tinyalu module_dut (.A(module_bfm.A), .B(module_bfm.B), .op(module_bfm.op), 
                     .clk(module_bfm.clk), .reset_n(module_bfm.reset_n), 
                     .start(module_bfm.start), .done(module_bfm.done), 
                     .result(module_bfm.result));

 tinyalu_tester_module stim_module(module_bfm);

 initial begin
  uvm_config_db #(virtual tinyalu_bfm)::set(null, "*", "class_bfm", class_bfm);
  uvm_config_db #(virtual tinyalu_bfm)::set(null, "*", "module_bfm", module_bfm);
  run_test("dual_test");
 end
   
endmodule : top

2.tinyalu_tester_module.sv

module tinyalu_tester_module(tinyalu_bfm bfm);
   import tinyalu_pkg::*;

   function operation_t get_op();
      bit [2:0] op_choice;
      op_choice = $random;
      case (op_choice)
        3'b000 : return no_op;
        3'b001 : return add_op;
        3'b010 : return and_op;
        3'b011 : return xor_op;
        3'b100 : return mul_op;
        3'b101 : return no_op;
        3'b110 : return rst_op;
        3'b111 : return rst_op;
      endcase // case (op_choice)
   endfunction : get_op

   function byte get_data();
      bit [1:0] zero_ones;
      zero_ones = $random;
      if (zero_ones == 2'b00)
        return 8'h00;
      else if (zero_ones == 2'b11)
        return 8'hFF;
      else
        return $random;
   endfunction : get_data
   
   initial begin
      byte         unsigned        iA;
      byte         unsigned        iB;
      operation_t                  op_set;
      shortint     result;
      
      bfm.reset_alu();
      repeat (5) begin : random_loop
         op_set = get_op();
         iA = get_data();
         iB = get_data();
         bfm.send_op(iA, iB, op_set,result);
      end : random_loop
   end // initial begin
endmodule : tinyalu_tester_module

3.tinyalu_bfm.sv

interface tinyalu_bfm;
   import uvm_pkg::*;
   `include "uvm_macros.svh"
   import tinyalu_pkg::*;

   byte         unsigned        A;
   byte         unsigned        B;
   bit          clk;
   bit          reset_n;
   wire [2:0]   op;
   bit          start;
   wire         done;
   wire [15:0]  result;
   operation_t  op_set;


   assign op = op_set;

   task reset_alu();
      reset_n = 1'b0;
      @(negedge clk);
      @(negedge clk);
      reset_n = 1'b1;
      start = 1'b0;
   endtask : reset_alu
   


   task send_op(input byte iA, input byte iB, input operation_t iop, output shortint alu_result);
      if (iop == rst_op) begin
         @(posedge clk);
         reset_n = 1'b0;
         start = 1'b0;
         @(posedge clk);
         #1;
         reset_n = 1'b1;
      end else begin
         @(negedge clk);
         op_set = iop;
         A = iA;
         B = iB;
         start = 1'b1;
         if (iop == no_op) begin
            @(posedge clk);
            #1;
            start = 1'b0;           
         end else begin
            do
              @(negedge clk);
            while (done == 0);
            alu_result = result;
            start = 1'b0;
         end
      end // else: !if(iop == rst_op)
      
   endtask : send_op
   
   command_monitor command_monitor_h;

   function operation_t op2enum();
      case(op)
        3'b000 : return no_op;
        3'b001 : return add_op;
        3'b010 : return and_op;
        3'b011 : return xor_op;
        3'b100 : return mul_op;
    3'b111 : return rst_op;
        default : `uvm_fatal("TINYALU BFM",$sformatf("Illegal operation:  %d", int'(op)))
      endcase // case (op)
   endfunction : op2enum


   always @(posedge clk) begin : op_monitor
      static bit in_command = 0;
      command_transaction command;
      if (start) begin : start_high
        if (!in_command) begin : new_command
           command_monitor_h.write_to_monitor(A, B, op2enum());
           in_command = (op2enum() != no_op);
        end : new_command
      end : start_high
      else // start low
        in_command = 0;
   end : op_monitor

   always @(negedge reset_n) begin : rst_monitor
      command_transaction command;
      if (command_monitor_h != null) //guard against VCS time 0 negedge
        command_monitor_h.write_to_monitor($random,0,rst_op);
   end : rst_monitor
   
   result_monitor  result_monitor_h;

   initial begin : result_monitor_thread
      forever begin : result_monitor
         @(posedge clk) ;
         if (done) 
           result_monitor_h.write_to_monitor(result);
      end : result_monitor
   end : result_monitor_thread
   

   initial begin
      clk = 0;
      forever begin
         #10;
         clk = ~clk;
      end
   end


endinterface : tinyalu_bfm

4.tinyalu_pkg.sv

package tinyalu_pkg;
   import uvm_pkg::*;
`include "uvm_macros.svh"
         
      typedef enum bit[2:0] {
                             no_op  = 3'b000,
                             add_op = 3'b001, 
                             and_op = 3'b010,
                             xor_op = 3'b011,
                             mul_op = 3'b100,
                             rst_op = 3'b111} operation_t;



`include "env_config.svh"
`include "tinyalu_agent_config.svh"   
`include "command_transaction.svh"   
`include "add_transaction.svh"
`include "result_transaction.svh"
`include "coverage.svh"
`include "tester.svh"
`include "scoreboard.svh"
`include "driver.svh"
`include "command_monitor.svh"
`include "result_monitor.svh"
`include "tinyalu_agent.svh"
`include "env.svh"

`include "dual_test.svh"

   
endpackage : tinyalu_pkg

5.dual_test.svh

class dual_test extends uvm_test;
   `uvm_component_utils(dual_test);

   env       env_h;
   
   function new (string name, uvm_component parent);
      super.new(name,parent);
   endfunction : new


   function void build_phase(uvm_phase phase);
      
      virtual tinyalu_bfm class_bfm, module_bfm;
      env_config env_config_h;

      if(!uvm_config_db #(virtual tinyalu_bfm)::get(this, "","class_bfm", class_bfm))
        `uvm_fatal("DUAL TEST", "Failed to get CLASS BFM");
      if(!uvm_config_db #(virtual tinyalu_bfm)::get(this, "","module_bfm", module_bfm))
        `uvm_fatal("DUAL TEST", "Failed to get MODULE BFM");

      env_config_h = new(.class_bfm(class_bfm), .module_bfm(module_bfm));
      
      uvm_config_db #(env_config)::set(this, "env_h*", "config", env_config_h);

      env_h = env::type_id::create("env_h",this);
   endfunction : build_phase


endclass

6.env.svh

class env extends uvm_env;
   `uvm_component_utils(env);

   tinyalu_agent        class_tinyalu_agent_h,  module_tinyalu_agent_h;
   tinyalu_agent_config class_config_h, module_config_h;
   
   function new (string name, uvm_component parent);
      super.new(name,parent);
   endfunction : new

   function void build_phase(uvm_phase phase);
      virtual tinyalu_bfm class_bfm;
      virtual tinyalu_bfm module_bfm;
      env_config env_config_h;


      
      if(!uvm_config_db #(env_config)::get(this, "","config", env_config_h))
        `uvm_fatal("RANDOM TEST", "Failed to get CLASS BFM");
      
      class_config_h  = new(.bfm(env_config_h.class_bfm),  .is_active(UVM_ACTIVE));
      module_config_h = new(.bfm(env_config_h.module_bfm), .is_active(UVM_PASSIVE));
      
      uvm_config_db #(tinyalu_agent_config)::set(this, "class_tinyalu_agent_h*",  
                                                 "config", class_config_h);
      
      uvm_config_db #(tinyalu_agent_config)::set(this, "module_tinyalu_agent_h*", 
                                                 "config", module_config_h);



      class_tinyalu_agent_h  = new("class_tinyalu_agent_h",this);
      module_tinyalu_agent_h = new("module_tinyalu_agent_h",this);
      
   endfunction : build_phase
   
endclass

7.env_config.svh

class env_config;
 virtual tinyalu_bfm class_bfm;
 virtual tinyalu_bfm module_bfm;

 function new(virtual tinyalu_bfm class_bfm, virtual tinyalu_bfm module_bfm);
    this.class_bfm = class_bfm;
    this.module_bfm = module_bfm;
 endfunction : new
endclass : env_config

8.tinyalu_agent.svh

class tinyalu_agent extends uvm_agent;
   `uvm_component_utils(tinyalu_agent)

   tinyalu_agent_config tinyalu_agent_config_h;

   tester          tester_h;
   driver          driver_h;
   scoreboard      scoreboard_h;
   coverage        coverage_h;
   command_monitor command_monitor_h;
   result_monitor  result_monitor_h;

   uvm_tlm_fifo      #(command_transaction) command_f;
   uvm_analysis_port #(command_transaction) cmd_mon_ap;
   uvm_analysis_port #(result_transaction) result_ap;


function new (string name, uvm_component parent);
   super.new(name,parent);
endfunction : new  


function void build_phase(uvm_phase phase);

   if(!uvm_config_db #(tinyalu_agent_config)::get(this, "","config", 
                                                   tinyalu_agent_config_h))
    `uvm_fatal("AGENT", "Failed to get config object");    
   is_active = tinyalu_agent_config_h.get_is_active();

   if (get_is_active() == UVM_ACTIVE) begin : make_stimulus
      command_f = new("command_f", this);
      tester_h    = tester::type_id::create( "tester_h",this);
      driver_h    = driver::type_id::create("driver_h",this);
   end

   command_monitor_h = command_monitor::type_id::create("command_monitor_h",this);
   result_monitor_h  = result_monitor::type_id::create("result_monitor_h",this);
   
   coverage_h = coverage::type_id::create("coverage_h",this);
   scoreboard_h = scoreboard::type_id::create("scoreboard_h",this);

   cmd_mon_ap = new("cmd_mon_ap",this);
   result_ap  = new("result_ap", this);

endfunction : build_phase

function void connect_phase(uvm_phase phase);
   if (get_is_active() == UVM_ACTIVE) begin : make_stimulus
      driver_h.command_port.connect(command_f.get_export);
      tester_h.command_port.connect(command_f.put_export);
   end
      
   command_monitor_h.ap.connect(cmd_mon_ap);
   result_monitor_h.ap.connect(result_ap);

   command_monitor_h.ap.connect(scoreboard_h.cmd_f.analysis_export);
   command_monitor_h.ap.connect(coverage_h.analysis_export);
   result_monitor_h.ap.connect(scoreboard_h.analysis_export);

endfunction : connect_phase

endclass : tinyalu_agent

9.tinyalu_agent_config.svh

class tinyalu_agent_config;

   virtual tinyalu_bfm bfm;
   protected  uvm_active_passive_enum     is_active;

   function new (virtual tinyalu_bfm bfm, uvm_active_passive_enum
         is_active);
      this.bfm = bfm;
      this.is_active = is_active;
   endfunction : new

   function uvm_active_passive_enum get_is_active();
      return is_active;
   endfunction : get_is_active
   
endclass : tinyalu_agent_config