:::danger 【总结】
这一部分中我们将对以下两部分的内容进行分析：

  1. 结合AHB协议理解addr是否能按照不对齐进行测试；
  2. 理解Design给出的数据，在无效位给出的并不是0，而是x；

基于以上两点，monitor在总线上采集数据是无所谓的，master来选择数据的有效位然后进行比较即可，所以这部分选择有效位的逻辑我们放到了scoreboard中进行实现。
memory中采集有效数据的时候需要注意数据的mem的地址一定要正确，否则数据会采集不到。
通过addr，data和bsize来寻找真正的有效位的data，最后采集到有效的数据以后才能进行比较。 :::

7.1 scoreboard分析读数据操作

之前我们进行了diff_hsize的测试，分别在seq和scoreboard中进行了比较，分析scoreboard的逻辑发现我们并不需要在读操作的时候对数据进行一个按位与的运算
假设：这一部分应道由Design来完成，也就是说Design它已经默认判断了一个数据的有效位和无效位，我们将按位与运算去掉以后进行仿真调试：

  1. `ifndef AHB_RAM_SCOREBOARD_SV
  2. `define AHB_RAM_SCOREBOARD_SV
  4. class ahb_ram_scoreboard extends ahb_ram_subscriber;
  6.   bit [31:0] mem [int unsigned];
  8.   // Events of scoreboard
  10.   `uvm_component_utils(ahb_ram_scoreboard)
  12.   function new (string name = "ahb_ram_scoreboard", uvm_component parent);
  13.     super.new(name, parent);
  14.   endfunction
  16.   function void build_phase(uvm_phase phase);
  17.     super.build_phase(phase);
  18.   endfunction
  20.   task run_phase(uvm_phase phase);
  21.     super.run_phase(phase);
  22.   endtask
  24.   virtual function void write(ahb_transaction tr);
  25.     if(is_trans_valid(tr.addr)) begin
  26.       case(tr.xact_type)
  27.         WRITE : store_data_with_burst(tr);
  28.         READ  : check_data_with_burst(tr);
  29.       endcase
  30.     end
  31.   endfunction
  33.   function is_trans_valid(bit [31:0] addr);
  34.     if(addr >= cfg.addr_start && addr <= cfg.addr_end);
  35.     return 1;
  36.   endfunction
  38.   function void store_data_with_burst(ahb_transaction tr);
  39.     case(tr.burst_type)
  40.       SINGLE : begin 
  41.                 store_data_with_hsize(tr, 0);
  42.                end
  43.       INCR   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  44.       WRAP4   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  45.       WRAP8   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  46.       WRAP16   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  47.       INCR4   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  48.       INCR8   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  49.       INCR16   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  50.       default : begin `uvm_error("TYPEERR", "burst type not defined") end
  51.     endcase
  52.   endfunction
  54.   function void store_data_with_hsize(ahb_transaction tr, int beat);
  55.     case(tr.burst_size)
  56.       BURST_SIZE_8BIT    : mem[tr.addr] = tr.data[beat] & 32'h0000_00FF;
  57.       BURST_SIZE_16BIT   : mem[tr.addr] = tr.data[beat] & 32'h0000_FFFF;
  58.       BURST_SIZE_32BIT   : mem[tr.addr] = tr.data[beat] & 32'hFFFF_FFFF;
  59.       BURST_SIZE_64BIT   : begin `uvm_error("TYPEERR", "burst_size is not supported yet") end
  60.       default : begin `uvm_error("TYPEERR", "burst_size is not supported yet") end
  61.     endcase
  62.   endfunction
  64.   function bit check_data_with_burst(ahb_transaction tr);
  65.     case(tr.burst_type)
  66.       SINGLE : begin 
  67.                 check_data_with_burst = check_data_with_hsize(tr, 0);
  68.                end
  69.       INCR   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  70.       WRAP4   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  71.       WRAP8   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  72.       WRAP16   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  73.       INCR4   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  74.       INCR8   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  75.       INCR16   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  76.       default : begin `uvm_error("TYPEERR", "burst type not defined") end
  77.     endcase
  78.     if(check_data_with_burst) begin
  79.       `uvm_info("DATACHK", $sformatf("ahbram[0%x] hburst[%s] is as expected", tr.addr, tr.burst_type), UVM_HIGH)
  80.     end
  81.     else begin
  82.       `uvm_error("DATACHK", $sformatf("ahbram[0%x] hburst[%s] is not as expected", tr.addr, tr.burst_type))
  83.     end
  84.   endfunction
  86.   function bit check_data_with_hsize(ahb_transaction tr, int beat);
  87.     bit [63:0] data;
  88.     case(tr.burst_size)
  89.       BURST_SIZE_8BIT    : begin data = tr.data[beat]; if(mem[tr.addr] == data) check_data_with_hsize = 1; end
  90.       BURST_SIZE_16BIT   : begin data = tr.data[beat]; if(mem[tr.addr] == data) check_data_with_hsize = 1; end
  91.       BURST_SIZE_32BIT   : begin data = tr.data[beat]; if(mem[tr.addr] == data) check_data_with_hsize = 1; end
  92.       BURST_SIZE_64BIT   : begin `uvm_error("TYPEERR", "burst_size is not supported yet") end
  93.       default : begin `uvm_error("TYPEERR", "burst_size is not supported yet") end
  94.     endcase
  95.     cfg.scb_check_count++;
  96.     if(check_data_with_hsize) begin
  97.       `uvm_info("DATACHK", $sformatf("ahb_ram[%0x] data expected 'h%0x = actual 'h%0x", tr.addr, mem[tr.addr], data), UVM_HIGH)
  98.     end
  99.     else begin
  100.       cfg.scb_check_error++;
  101.       `uvm_error("DATACHK", $sformatf("ahb_ram[%0x] data expected 'h%0x != actual 'h%0x", tr.addr, mem[tr.addr], data))
  102.     end
  103.   endfunction
  105.   task do_listen_events();
  106.   endtask
  108.   virtual task do_data_check();
  109.   endtask
  113. endclass
  115. `endif // AHB_RAM_SCOREBOARD_SV

【调试及结果】

image.png

结果可以发现按照hsize不同读出来的数据rdata在高位都是不定态的，这样的结果放在scoreboard中是难以比较的，通常来说，我们都会希望在高位被读出来的数据会被处理成0，所以在scoreboard中我们使用的是双等号。

也就是说在DUT中，被reset以后读出来的值是x状态的。但是monitor中采集到的数据是bit的，然后将这个数据交给了scoreboard，如果我们继续使用==进行比较的话，结果就会变得不可靠。

:::info 重新查阅手册：
rdata总线是由slave端来进行驱动的，总线上的数据长度我们规定的是32bit，如果给定的激励是低于32bit的，那么slave端是需要在有效bit位上提供数据的（通常都是将整个数据块传输过来，所以会包含高位的不定态），因此只能由master端来选择有效的数据最后进行比较。 ::: image.png
image.png

对于有效bit位的数据而言我们会读取，其他位置就会当做x进行处理。

:::info 经过上述分析以后我们知道在scoboard中使用双等号来比较这样的一个rd_data是存在危险的，如果读出来的数据高位有其他的数据，那么此时比较的结果就并非我们所想看到的，所以我们对hsize中读出来的数据还是要进行按位与来防止错误出现。 :::

如果我们的地址不一定是word对齐的，我们就需要根据地址来进行sel，所以要更新scoreboard来对case进行比较，进一步查看addr和hsize之间的combine和random问题。

【思考2】 既然我们讨论了从mem一侧读取的数据复位值是x，那么为什么scoreboard中一定要有转换成0，再使用==进行比较呢？ 原因就是我们的transaction中的data和addr都是bit类型的，所以scoreboard在比较数据的时候也应当是bit类型的，这样就可以使用==进行比较。

7.2 地址不对齐数据测试

接下来我们进行地址不对齐的数据测试ahb_ram_word_unaligned_test，这个测试中我们不再在seq中比较数据，将比较的任务全部交给scoreboard。

  1. `ifndef AHB_RAM_HADDR_WORD_UNALIGNED_VIRT_SEQ_SV
  2. `define AHB_RAM_HADDR_WORD_UNALIGNED_VIRT_SEQ_SV
  4.   class ahb_ram_haddr_word_unaligned_virt_seq extends ahb_ram_base_virt_seq;
  6.     `uvm_object_utils(ahb_ram_haddr_word_unaligned_virt_seq)
  8.     function new(string name = "ahb_ram_haddr_word_unaligned_virt_seq");
  9.       super.new(name);
  10.     endfunction
  12.     virtual task body();
  13.       bit [31:0] addr, data;
  14.       burst_size_enum bsize;
  15.       super.body();
  16.       `uvm_info("body","Entered...",UVM_LOW)
  17.       for(int i=0; i<100; i++) begin
  18.         std::randomize(bsize) with {bsize inside {BURST_SIZE_8BIT, BURST_SIZE_16BIT, BURST_SIZE_32BIT};};
  19.         std::randomize(addr) with {addr inside {['h1000:'h1FFF]};
  20.                                                 bsize == BURST_SIZE_16BIT -> addr[0] == 0;
  21.                                                 bsize == BURST_SIZE_32BIT -> addr[1:0] == 0;
  22.                                                 };
  23.         std::randomize(wr_val) with {wr_val == ((i << 24) + (i << 16) + (i << 8) + i);};
  24.         data = wr_val;
  25.         `uvm_do_with(single_write, {addr == local::addr; data == local::data; bsize == local::bsize;})
  26.         `uvm_do_with(single_read, {addr == local::addr; bsize == local::bsize;})
  27.       end
  28.       `uvm_info("body","EXited...", UVM_LOW)
  29.     endtask
  31.   endclass
  33. `endif //AHB_RAM_HADDR_WORD_UNALIGNED_VIRT_SEQ_SV

如何确定约束条件及随机化的顺序呢？

  1. 既然是不按照地址对齐的数据进行随机化的操作，那么我们首先是要给定激励的位宽；
  2. 原有的addr[1:0]也不再需要为0，我们需要根据不同的位宽大小来确定索引地址的信息：
    1. 对于一个32位的数据而言，按照1byte进行索引，实际寻址的步长就是4个byte，也就是对编号为4的倍数进行寻址；
    2. 对于一个16位的数据而言，按照1byte进行索引，实际索引的步长就是2个byte，也就是对编号为2的倍数进行寻址，分别是0,2,4,8。那么就要求最低位为0；
    3. 对于一个8位的数据而言，按照1byte进行索引，实际索引的补偿就是1个byte，也就是对1的倍数进行寻址，那么就是它本身。

另外，对于32bit的数据而言，为了保证其每一位都有数据，我们将给到的激励也进行改变。

【调试及结果】

image.png

根据结果可以发现，在地址不对齐以后进行测试，scoreboard一共比较了100次，其中54次是错误的。

  • 我们找到命令栏中的第一个error的地方单击它，在波形上可以看到：在126000时刻，scoreboard报错；
  • 在它的前两拍的时候进行了写数据，地址是0202_0202，写入的数据和地址是对其的，写地址是195d，四字节对其，c是对第一个byte进行操作，所以d是对第二个byte进行写操作，也就是说写data数据的有效位是data[16:8]，反映到读出来的数据就是0_0000_xxxx_02xx，这样就会导致monitor在采样的时候产生错误，使得scoreboard比较错误。image.png

    7.3 monintor & scoreboard逻辑更正

    7.3.1 monitor逻辑更正

    之前也已经提到过了，monitor从vif上拿到数据然后通过判断以后直接存放到transaction中，这种过程是错误的，因为没有经过有效位的检查。
    因此我们声明一个xact_get_valid_data函数，根据burst的大小分别对数据进行移位，最后只检查最低位的数据即可。 ``systemverilogifndef AHB_MONITOR_SV `define AHB_MONITOR_SV

class ahb_monitor extends uvm_monitor;

ahb_agent_configuration cfg; virtual ahb_if vif;

uvm_analysis_port #(ahb_transaction) item_observed_port;

`uvm_component_utils(ahb_monitor)

function new (string name = “ahb_monitor”, uvm_component parent = null); super.new(name,parent); item_observed_port = new(“item_observed_port”, this); endfunction

function void build_phase(uvm_phase phase); super.build_phase(phase); endfunction

function void connect_phase(uvm_phase phase); super.connect_phase(phase); endfunction

task run_phase(uvm_phase phase); super.run_phase(phase); fork monitor_transaction(); join_none endtask

task monitor_transaction(); ahb_transaction t; forever begin collect_transaction(t); item_observed_port.write(t); end endtask

task collect_transaction(output ahb_transaction t); // collect transaction from interfacena t = ahb_transaction::type_id::create(“ahb_transaction”); @(vif.cb_mon iff vif.cb_mon.htrans == NSEQ); t.xact_type = xact_type_enum’(vif.cb_mon.hwrite); t.trans_type = trans_type_enum’(vif.cb_mon.htrans); t.burst_size = burst_size_enum’(vif.cb_mon.hsize); t.burst_type = burst_type_enum’(vif.cb_mon.hburst); t.addr = vif.cb_mon.haddr; forever begin monitor_valid_data(t); if(vif.cb_mon.htrans == IDLE) begin break; end end t.response_type = t.all_beat_response[t.current_data_beat_num]; endtask

task monitor_valid_data(ahb_transaction t); @(vif.cb_mon iff vif.cb_mon.hready); t.increase_data(); t.current_data_beat_num = t.data.size() - 1; // Get draft data from bus t.data[t.current_data_beat_num] = t.xact_type == WRITE ? vif.cb_mon.hwdata : vif.cb_mon.hrdata; // NOTE:: aligned not to extract the valid data after shifted // Exact valid data from current beat // xact_get_valid_data(t); t.all_beat_response[t.current_data_beat_num] = response_type_enum’(vif.cb_mon.hresp); t.trans_type = trans_type_enum’(vif.cb_mon.htrans); endtask

function void xact_get_valid_data(ahb_transaction t); case(t.burst_size) BURST_SIZE_8BIT : t.data[t.current_data_beat_num] = t.data[t.current_data_beat_num] >> (8 t.addr[1:0]); BURST_SIZE_16BIT : t.data[t.current_data_beat_num] = t.data[t.current_data_beat_num] >> (16 t.addr[1]); BURST_SIZE_32BIT : t.data[t.current_data_beat_num] = t.data[t.current_data_beat_num]; endcase endfunction

task monitor_transaction_proc(ahb_transaction t); endtask

endclass

`endif // AHB_MONITOR_SV

  1. <a name="BdRMy"></a>
  2. ## 7.3.2 scoreboard逻辑更正
  3. 根据我们对ahb协议的理解：
  5. - 如果我们的memory设定合理的话，mem中的地址也应当是按照字对齐来进行索引才算合理，因为这样才能最后将mem中的有效数据和monitor中采集到的数据进行比较。因此我们在存放data到mem的时候，每一次存放数据都应当让mem中的地址是对齐，因此必须对地址进行一个拼写，同时，也必须保证我们往mem中存放的数据就必须是一组数据的有效位；
  6. - 也就是说我们的地址应当按照字索引的方式，如果没有按照这种方式，例如在100的时候作为一个index，101的时候作为一个index，这种搭建的模型对于地址的索引是错误的。
  7. > 如何将地址按照字对齐的方式进行排列？
  9. > 我们直接将最低两位的地址令为0，这样它就是默认按照0,4,8,c的方式进行排列的，内存就是对齐的。
  12. ---
  14. <a name="n9WzC"></a>
  15. ### （1）实现scoreboard中有效数据向mem中的传输
  16. 针对第一点中的两个问题，我们对scoreboard进行以下修改：
  18. - 声明一个新的函数xact_current_beat_mdata来将transaction中的有效数据存放到mem中。
  20. 完成了对mem数据存放问题的修改以后，接下来只需要进行数据的check即可，对数据进行相应的位移再进行比对是没有问题的。
  21. ```systemverilog
  22. `ifndef AHB_RAM_SCOREBOARD_SV
  23. `define AHB_RAM_SCOREBOARD_SV
  25. class ahb_ram_scoreboard extends ahb_ram_subscriber;
  27.   ...
  29.   function void store_data_with_hsize(ahb_transaction tr, int beat);
  30.     case(tr.burst_size)
  31.       BURST_SIZE_8BIT    : mem[{tr.addr[31:3],2'b00}] = xact_current_beat_mdata(tr, beat);
  32.       BURST_SIZE_16BIT   : mem[{tr.addr[31:3],2'b00}] = xact_current_beat_mdata(tr, beat);
  33.       BURST_SIZE_32BIT   : mem[{tr.addr[31:3],2'b00}] = xact_current_beat_mdata(tr, beat);
  34.       BURST_SIZE_64BIT   : begin `uvm_error("TYPEERR", "burst_size is not supported yet") end
  35.       default : begin `uvm_error("TYPEERR", "burst_size is not supported yet") end
  36.     endcase
  37.   endfunction
  39.   function bit check_data_with_burst(ahb_transaction tr);
  40.     case(tr.burst_type)
  41.       SINGLE : begin 
  42.                 check_data_with_burst = check_data_with_hsize(tr, 0);
  43.                end
  44.       INCR   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  45.       WRAP4   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  46.       WRAP8   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  47.       WRAP16   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  48.       INCR4   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  49.       INCR8   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  50.       INCR16   : begin `uvm_error("TYPEERR", "burst type not supported yet") end
  51.       default : begin `uvm_error("TYPEERR", "burst type not defined") end
  52.     endcase
  53.     if(check_data_with_burst) begin
  54.       `uvm_info("DATACHK", $sformatf("ahbram[0%x] hburst[%s] is as expected", tr.addr, tr.burst_type), UVM_HIGH)
  55.     end
  56.     else begin
  57.       `uvm_error("DATACHK", $sformatf("ahbram[0%x] hburst[%s] is not as expected", tr.addr, tr.burst_type))
  58.     end
  59.   endfunction
  61.   ...
  63.   function bit [31:0] xact_current_beat_mdata(ahb_transaction t, int beat);
  64.     bit [31:0] mdata = mem[{tr.addr[31:2],2'b00}];
  65.     bit [31:0] tdata = t.data[beat];
  66.     case(t.burst_size)
  67.       BURST_SIZE_8BIT   : mdata[tr.addr[1:0]*8+7 : -8] = tdata >> (8 * t.addr[1:0]);
  68.       BURST_SIZE_16BIT  : mdata[tr.addr[1]*16+15 : -16] = tdata >> (16 * t.addr[1]);
  69.       BURST_SIZE_32BIT  : mdata = tdata;
  70.     endcase
  71.     return mdata;
  72.   endfunction
  74.   task do_listen_events();
  75.   endtask
  77.   virtual task do_data_check();
  78.   endtask
  82. endclass
  84. `endif // AHB_RAM_SCOREBOARD_SV

我们在scoreboard的mem中的地址也应当按照字节索引的方式来进行操作： addr为0的话，就是对mem[7:0]位的数据进行操作； addr为1的话，就是对mem[15:8]位的数据进行操作；这样就使得mem中的每一个地址也是对应了8个bit位的数据，最后对数据进行了拼接。

（2）有效数据的移动及monitor & scoreboard逻辑简化

既然scoreboard在获取有效数据到mem的过程中需要移位，monitor在采样到数据以后也需要移位来获取有效值。我们可以将这一部分的函数集成到一个公共可被调用的文件中。

  1. `ifndef AHB_DEFINES_SVH
  2. `define AHB_DEFINES_SVH
  4. `define AHB_MAX_DATA_WIDTH 64
  5. `define AHB_MAX_ADDR_WIDTH 32
  7. typedef enum burst_size_enum;
  9. function bit [31:0] extract_valid_data([`AHB_MAX_DATA_WIDTH - 1:0] data,
  10.                                        [`AHB_MAX_ADDR_WIDTH - 1:0] addr,
  11.                                        burst_size_enum bsize 
  12.                                       );
  13.   case(bsize)
  14.     BURST_SIZE_8BIT   : return data >> (8 * addr[1:0]) & 8'hFF
  15.     BURST_SIZE_16BIT  : return data >> (16 * addr[1]) & 16'hFFFF
  16.     BURST_SIZE_32BIT  : return data & 32"hFFFF_FFFF;
  17.     BURST_SIZE_64BIT   : begin `uvm_error("TYPEERR", "burst_size is not supported yet") end
  18.     default : begin `uvm_error("TYPEERR", "burst_size is not supported yet") end
  20.   endcase
  21. endfunction
  23. `endif

我们在上面的这个defines文件中集成了extract_valid_data函数，之后就可以方便monitor和scoreboard随时进行调用； 这一部分一定要按位与，原因是data可能是64位的，我们对高位的数据必须用按位与的方式来使得x值可以变成0从而进行进一步的比较。

:::info 将获取数据的有效值并移动以后的逻辑独立出来以后，我们就可以在monitor中对它进一步进行调用： :::

  1. `ifndef AHB_MONITOR_SV
  2. `define AHB_MONITOR_SV
  4. class ahb_monitor extends uvm_monitor;
  6.   ahb_agent_configuration cfg;
  7.   virtual ahb_if vif;
  9.   uvm_analysis_port #(ahb_transaction) item_observed_port;
  11.   `uvm_component_utils(ahb_monitor)
  13.   function new (string name = "ahb_monitor", uvm_component parent = null);
  14.     super.new(name,parent);
  15.     item_observed_port = new("item_observed_port", this);
  16.   endfunction
  18.   function void build_phase(uvm_phase phase);
  19.     super.build_phase(phase);
  20.   endfunction
  22.   function void connect_phase(uvm_phase phase);
  23.     super.connect_phase(phase);
  24.   endfunction
  26.   task run_phase(uvm_phase phase);
  27.     super.run_phase(phase);
  28.     fork
  29.       monitor_transaction();
  30.     join_none
  31.   endtask
  33.   task monitor_transaction();
  34.     ahb_transaction t;
  35.     forever begin
  36.       collect_transaction(t);
  37.       item_observed_port.write(t);
  38.     end
  39.   endtask
  41.   task collect_transaction(output ahb_transaction t);
  42.     // collect transaction from interfacena
  43.     t = ahb_transaction::type_id::create("ahb_transaction");
  44.     @(vif.cb_mon iff vif.cb_mon.htrans == NSEQ);
  45.     t.xact_type = xact_type_enum'(vif.cb_mon.hwrite);
  46.     t.trans_type = trans_type_enum'(vif.cb_mon.htrans);
  47.     t.burst_size = burst_size_enum'(vif.cb_mon.hsize);
  48.     t.burst_type = burst_type_enum'(vif.cb_mon.hburst);
  49.     t.addr = vif.cb_mon.haddr;
  50.     forever begin
  51.       monitor_valid_data(t);
  52.       if(vif.cb_mon.htrans == IDLE) begin
  53.         break;
  54.       end
  55.     end
  56.     t.response_type = t.all_beat_response[t.current_data_beat_num];
  57.   endtask
  59.   task monitor_valid_data(ahb_transaction t);
  60.     @(vif.cb_mon iff vif.cb_mon.hready);
  61.     t.increase_data();
  62.     t.current_data_beat_num = t.data.size() - 1;
  63.     // Get draft data from bus
  64.     t.data[t.current_data_beat_num] = t.xact_type == WRITE ? vif.cb_mon.hwdata : vif.cb_mon.hrdata;
  65.     // NOTE:: aligned not to extract the valid data after shifted
  66.     // Exact valid data from current beat
  67.     // extract_valid_data(t.data[t.current_data_beat_num], t.addr, t.burst_size);
  68.     t.all_beat_response[t.current_data_beat_num] = response_type_enum'(vif.cb_mon.hresp);
  69.     t.trans_type = trans_type_enum'(vif.cb_mon.htrans);
  70.   endtask
  72.   task monitor_transaction_proc(ahb_transaction t);
  73.   endtask
  75. endclass
  77. `endif // AHB_MONITOR_SV

:::info 同样的，我们也可以在scoreboard中在做数据比对的时候，将monitor一侧拿来的数据，使用该函数来对有效数据进行移动 :::

【调试及结果】

对scoreboard和monitor的逻辑重新进行整理以后，我们再次进行编译仿真，首先从简单的测试开始，由于haddr默认了hsize 32bit
image.png
scoreboard的比较中只有一个通过。检查发现我们mem中的值都是0，说明在mem中给定有效值的函数有问题。
image.png
设置断点以后发癫mdata的值有问题，一直保持为0，说明scoreboard没有将有效的数值输入到mem中。
经过一系列追溯发现问题出在了存储data数据的时候，mem的地址拼接错误了，使得在mem[2]位置的data始终为0。

更改以后运行地址非对齐的测试，结果正常通过。
image.png
image.png
datacheck比较了200次均是成功的。