uvm_scoreboard has a write task which will write to the Queue or Associative array.
How will uvm scoreboard know that a packet has arrived ?


In reply to dvuvmsv:

Hi Jeff the scoreboard does not call the write function. This function is provided for another componenet which is calling it. In most cases it is a monotr which is collectiong a transaction from the virtual interface. When the transaction is complete it is published to the analysis port of the monitor by calling the write function. Then each component which is registered with this analysis port get this tranction and the scoreboard can store it.

Thanks chr_sue for your reply.

I saw an example scoreboard class. Here there is a uvm_tlm_analysis_fifo instantiated.
The Monitor call the write function implemented in the scoreboard. ( Here in this example there is no write function shown ). I believe a write task should be implemented
in scoreboard and Scoreboard should call the get(transaction) to pop the transaction
out of the analysis port before comparison.

Could you please give me an example of write function in scoreboard

class simpleadder_scoreboard extends uvm_scoreboard;

 uvm_analysis_export #(simpleadder_transaction) sb_export_before;
 uvm_analysis_export #(simpleadder_transaction) sb_export_after;

 uvm_tlm_analysis_fifo #(simpleadder_transaction) before_fifo;
 uvm_tlm_analysis_fifo #(simpleadder_transaction) after_fifo;

 simpleadder_transaction transaction_before;
 simpleadder_transaction transaction_after;

 function new(string name, uvm_component parent);
      super.new(name, parent);
      transaction_before    = new("transaction_before");
      transaction_after    = new("transaction_after");
 endfunction: new

 function void build_phase(uvm_phase phase);
      sb_export_before    = new("sb_export_before", this);
      sb_export_after        = new("sb_export_after", this);

      before_fifo        = new("before_fifo", this);
      after_fifo        = new("after_fifo", this);
 endfunction: build_phase

 function void connect_phase(uvm_phase phase);
 endfunction: connect_phase

 task run();
      forever begin
 endtask: run

 virtual function void compare();
      if(transaction_before.out == transaction_after.out) begin
           `uvm_info("compare", {"Test: OK!"}, UVM_LOW);
      end else begin
           `uvm_info("compare", {"Test: Fail!"}, UVM_LOW);
 endfunction: compare

endclass: simpleadder_scoreboard


In reply to dvuvmsv:

The base class uvm_scoreboard does not have itself a write function, but the uvm_tlm_analysis_fifo has one. Thus you are writing from the scoreboardto the tlm_fifo. In the scoreboard itself you are performimg calls of (blocking) on each of the tlm_fifos to retrieve the corresponding transactions. write has to have a function. It ios not blocking.

Thank you chr_sue