文件：
src/tlm1/uvm_tlm_ifs.svh
类：
uvm_tlm_if_base
这个类没有派生自任何类，在类的中，定义了三类接口：第一类是阻塞性质的普通方法（task），put, get, peek, transport(T1, T2). 第二类是非阻塞性质的普通方法(function)，try_put, try_get, try_peek, nb_transport(T1, T2). 还有can_put, can_get, can_peek. 第三类是用于广播的write, 是属于analysis的，向所有连接的port写。这是一个function. 这三类接口都必须要在派生类中重新定义，直接使用会报错误。
`define UVM_TASK_ERROR "TLM interface task not implemented" `define UVM_FUNCTION_ERROR "TLM interface function not implemented" //----------------------------------------------------------------------------- // // CLASS: uvm_tlm_if_base #(T1,T2) // // This class declares all of the methods of the TLM API. // // Various subsets of these methods are combined to form primitive TLM // interfaces, which are then paired in various ways to form more abstract // "combination" TLM interfaces. Components that require a particular interface // use ports to convey that requirement. Components that provide a particular // interface use exports to convey its availability. // // Communication between components is established by connecting ports to // compatible exports, much like connecting module signal-level output ports to // compatible input ports. The difference is that UVM ports and exports bind // interfaces (groups of methods), not signals and wires. The methods of the // interfaces so bound pass data as whole transactions (e.g. objects). // The set of primitive and combination TLM interfaces afford many choices for // designing components that communicate at the transaction level. // //----------------------------------------------------------------------------- virtual class uvm_tlm_if_base #(type T1=int, type T2=int); // Group: Blocking put // Task: put // // Sends a user-defined transaction of type T. // // Components implementing the put method will block the calling thread if // it cannot immediately accept delivery of the transaction. virtual task put( input T1 t ); uvm_report_error("put", `UVM_TASK_ERROR, UVM_NONE); endtask // Group: Blocking get // Task: get // // Provides a new transaction of type T. // // The calling thread is blocked if the requested transaction cannot be // provided immediately. The new transaction is returned in the provided // output argument. // // The implementation of get must regard the transaction as consumed. // Subsequent calls to get must return a different transaction instance. virtual task get( output T2 t ); uvm_report_error("get", `UVM_TASK_ERROR, UVM_NONE); endtask // Group: Blocking peek // Task: peek // // Obtain a new transaction without consuming it. // // If a transaction is available, then it is written to the provided output // argument. If a transaction is not available, then the calling thread is // blocked until one is available. // // The returned transaction is not consumed. A subsequent peek or get will // return the same transaction. virtual task peek( output T2 t ); uvm_report_error("peek", `UVM_TASK_ERROR, UVM_NONE); endtask // Group: Non-blocking put // Function: try_put // // Sends a transaction of type T, if possible. // // If the component is ready to accept the transaction argument, then it does // so and returns 1, otherwise it returns 0. virtual function bit try_put( input T1 t ); uvm_report_error("try_put", `UVM_FUNCTION_ERROR, UVM_NONE); return 0; endfunction // Function: can_put // // Returns 1 if the component is ready to accept the transaction; 0 otherwise. virtual function bit can_put(); uvm_report_error("can_put", `UVM_FUNCTION_ERROR, UVM_NONE); return 0; endfunction // Group: Non-blocking get // Function: try_get // // Provides a new transaction of type T. // // If a transaction is immediately available, then it is written to the output // argument and 1 is returned. Otherwise, the output argument is not modified // and 0 is returned. virtual function bit try_get( output T2 t ); uvm_report_error("try_get", `UVM_FUNCTION_ERROR, UVM_NONE); return 0; endfunction // Function: can_get // // Returns 1 if a new transaction can be provided immediately upon request, // 0 otherwise. virtual function bit can_get(); uvm_report_error("can_get", `UVM_FUNCTION_ERROR, UVM_NONE); return 0; endfunction // Group: Non-blocking peek // Function: try_peek // // Provides a new transaction without consuming it. // // If available, a transaction is written to the output argument and 1 is // returned. A subsequent peek or get will return the same transaction. If a // transaction is not available, then the argument is unmodified and 0 is // returned. virtual function bit try_peek( output T2 t ); uvm_report_error("try_peek", `UVM_FUNCTION_ERROR, UVM_NONE); return 0; endfunction // Function: can_peek // // Returns 1 if a new transaction is available; 0 otherwise. virtual function bit can_peek(); uvm_report_error("can_ppeek", `UVM_FUNCTION_ERROR, UVM_NONE); return 0; endfunction // Group: Blocking transport // Task: transport // // Executes the given request and returns the response in the given output // argument. The calling thread may block until the operation is complete. virtual task transport( input T1 req , output T2 rsp ); uvm_report_error("transport", `UVM_TASK_ERROR, UVM_NONE); endtask // Group: Non-blocking transport // Task: nb_transport // // Executes the given request and returns the response in the given output // argument. Completion of this operation must occur without blocking. // // If for any reason the operation could not be executed immediately, then // a 0 must be returned; otherwise 1. virtual function bit nb_transport(input T1 req, output T2 rsp); uvm_report_error("nb_transport", `UVM_FUNCTION_ERROR, UVM_NONE); return 0; endfunction // Group: Analysis // Function: write // // Broadcasts a user-defined transaction of type T to any number of listeners. // The operation must complete without blocking. virtual function void write( input T1 t ); uvm_report_error("write", `UVM_FUNCTION_ERROR, UVM_NONE); endfunction endclass