uvm_sqr_ifs——TLM1事务级建模方法（四）

　　与uvm_tlm_if_base 一样，这个类也没有派生自任何类，定义了如下几个接口：get_next_item, try_next_item, item_done, get, peek, put, put_response.

`define UVM_SEQ_ITEM_TASK_ERROR "Sequencer interface task not implemented"
`define UVM_SEQ_ITEM_FUNCTION_ERROR "Sequencer interface function not implemented"

//------------------------------------------------------------------------------
//
// CLASS: uvm_sqr_if_base #(REQ,RSP)
//
// This class defines an interface for sequence drivers to communicate with
// sequencers. The driver requires the interface via a port, and the sequencer
// implements it and provides it via an export.
//
//------------------------------------------------------------------------------

virtual class uvm_sqr_if_base #(type T1=uvm_object, T2=T1);

// Task: get_next_item
//
// Retrieves the next available item from a sequence.  The call will block
// until an item is available.  The following steps occur on this call:
//
// 1 - Arbitrate among requesting, unlocked, relevant sequences - choose the
//     highest priority sequence based on the current sequencer arbitration
//     mode. If no sequence is available, wait for a requesting unlocked
//     relevant sequence,  then re-arbitrate.
// 2 - The chosen sequence will return from wait_for_grant
// 3 - The chosen sequence <uvm_sequence_base::pre_do> is called
// 4 - The chosen sequence item is randomized
// 5 - The chosen sequence <uvm_sequence_base::post_do> is called
// 6 - Return with a reference to the item
//
// Once <get_next_item> is called, <item_done> must be called to indicate the
// completion of the request to the sequencer.  This will remove the request
// item from the sequencer FIFO.

virtual task get_next_item(output T1 t);
uvm_report_error("get_next_item", `UVM_SEQ_ITEM_TASK_ERROR, UVM_NONE);
endtask

// Task: try_next_item
//
// Retrieves the next available item from a sequence if one is available.
// Otherwise, the function returns immediately with request set to ~null~.
// The following steps occur on this call:
//
// 1 - Arbitrate among requesting, unlocked, relevant sequences - choose the
//     highest priority sequence based on the current sequencer arbitration
//     mode. If no sequence is available, return ~null~.
// 2 - The chosen sequence will return from wait_for_grant
// 3 - The chosen sequence <uvm_sequence_base::pre_do> is called
// 4 - The chosen sequence item is randomized
// 5 - The chosen sequence <uvm_sequence_base::post_do> is called
// 6 - Return with a reference to the item
//
// Once <try_next_item> is called, <item_done> must be called to indicate the
// completion of the request to the sequencer.  This will remove the request
// item from the sequencer FIFO.

virtual task try_next_item(output T1 t);
uvm_report_error("try_next_item", `UVM_SEQ_ITEM_TASK_ERROR, UVM_NONE);
endtask

// Function: item_done
//
// Indicates that the request is completed to the sequencer.  Any
// <uvm_sequence_base::wait_for_item_done>
// calls made by a sequence for this item will return.
//
// The current item is removed from the sequencer FIFO.
//
// If a response item is provided, then it will be sent back to the requesting
// sequence. The response item must have its sequence ID and transaction ID
// set correctly, using the <uvm_sequence_item::set_id_info> method:
//
//|  rsp.set_id_info(req);
//
// Before <item_done> is called, any calls to peek will retrieve the current
// item that was obtained by <get_next_item>.  After <item_done> is called, peek
// will cause the sequencer to arbitrate for a new item.

virtual function void item_done(input T2 t = null);
uvm_report_error("item_done", `UVM_SEQ_ITEM_FUNCTION_ERROR, UVM_NONE);
endfunction

// Task: wait_for_sequences
//
// Waits for a sequence to have a new item available. The default
// implementation in the sequencer calls
//  <uvm_wait_for_nba_region>.
// User-derived sequencers
// may override its <wait_for_sequences> implementation to perform some other
// application-specific implementation.

virtual task wait_for_sequences();
uvm_report_error("wait_for_sequences", `UVM_SEQ_ITEM_TASK_ERROR, UVM_NONE);
endtask

// Function: has_do_available
//
// Indicates whether a sequence item is available for immediate processing.
// Implementations should return 1 if an item is available, 0 otherwise.

virtual function bit has_do_available();
uvm_report_error("has_do_available", `UVM_SEQ_ITEM_FUNCTION_ERROR, UVM_NONE);
return 0;
endfunction

//-----------------------
// uvm_tlm_blocking_slave_if
//-----------------------

// Task: get
//
// Retrieves the next available item from a sequence.  The call blocks until
// an item is available. The following steps occur on this call:
//
// 1 - Arbitrate among requesting, unlocked, relevant sequences - choose the
//     highest priority sequence based on the current sequencer arbitration
//     mode. If no sequence is available, wait for a requesting unlocked
//     relevant sequence, then re-arbitrate.
// 2 - The chosen sequence will return from <uvm_sequence_base::wait_for_grant>
// 3 - The chosen sequence <uvm_sequence_base::pre_do> is called
// 4 - The chosen sequence item is randomized
// 5 - The chosen sequence <uvm_sequence_base::post_do> is called
// 6 - Indicate <item_done> to the sequencer
// 7 - Return with a reference to the item
//
// When get is called, <item_done> may not be called.  A new item can be
// obtained by calling get again, or a response may be sent using either
// <put>, or uvm_driver::rsp_port.write().

virtual task get(output T1 t);
uvm_report_error("get", `UVM_SEQ_ITEM_TASK_ERROR, UVM_NONE);
endtask

// Task: peek
//
// Returns the current request item if one is in the sequencer FIFO.  If no
// item is in the FIFO, then the call will block until the sequencer has a new
// request. The following steps will occur if the sequencer FIFO is empty:
//
// 1 - Arbitrate among requesting, unlocked, relevant sequences - choose the
// highest priority sequence based on the current sequencer arbitration mode.
// If no sequence is available, wait for a requesting unlocked relevant
// sequence, then re-arbitrate.
//
// 2 - The chosen sequence will return from <uvm_sequence_base::wait_for_grant>
// 3 - The chosen sequence <uvm_sequence_base::pre_do> is called
// 4 - The chosen sequence item is randomized
// 5 - The chosen sequence <uvm_sequence_base::post_do> is called
//
// Once a request item has been retrieved and is in the sequencer FIFO,
// subsequent calls to peek will return the same item.  The item will stay in
// the FIFO until either get or <item_done> is called.

virtual task peek(output T1 t);
uvm_report_error("peek", `UVM_SEQ_ITEM_TASK_ERROR, UVM_NONE);
endtask

// Task: put
//
// Sends a response back to the sequence that issued the request. Before the
// response is put, it must have its sequence ID and transaction ID set to
// match the request.  This can be done using the
// <uvm_sequence_item::set_id_info> call:
//
//   rsp.set_id_info(req);
//
// While this is a task, it will not consume time (including delta cycles).
// The response will be put into the
// sequence response queue or it will be sent to the
// sequence response handler.
//

virtual task put(input T2 t);
uvm_report_error("put", `UVM_SEQ_ITEM_TASK_ERROR, UVM_NONE);
endtask

// Function: put_response
//
// Sends a response back to the sequence that issued the request. Before the
// response is put, it must have its sequence ID and transaction ID set to
// match the request.  This can be done using the
// <uvm_sequence_item::set_id_info> call:
//
//   rsp.set_id_info(req);
//

virtual function void put_response(input T2 t);
uvm_report_error("put_response", `UVM_SEQ_ITEM_FUNCTION_ERROR, UVM_NONE);
endfunction

// Function: disable_auto_item_recording
//
// By default, item recording is performed automatically when
// get_next_item() and item_done() are called.
// However, this works only for simple, in-order, blocking transaction
// execution. For pipelined and out-of-order transaction execution, the
// driver must turn off this automatic recording and call
// <uvm_transaction::accept_tr>, <uvm_transaction::begin_tr>
// and <uvm_transaction::end_tr> explicitly at appropriate points in time.
//
// This methods be called at the beginning of the driver's ~run_phase()~ method.
// Once disabled, automatic recording cannot be re-enabled.
//
// For backward-compatibility, automatic item recording can be globally
// turned off at compile time by defining UVM_DISABLE_AUTO_ITEM_RECORDING

virtual function void disable_auto_item_recording();
uvm_report_error("disable_auto_item_recording", `UVM_SEQ_ITEM_FUNCTION_ERROR, UVM_NONE);
endfunction

// Function: is_auto_item_recording_enabled
//
// Return TRUE if automatic item recording is enabled for this port instance.

virtual function bit is_auto_item_recording_enabled();
uvm_report_error("is_auto_item_recording_enabled", `UVM_SEQ_ITEM_FUNCTION_ERROR, UVM_NONE);
return 0;
endfunction
endclass