第四段：seq_item_port的分析（二次更新）

初版内容

    1）基础用法：首先它是一个port，那么它肯定有对应export，我们在agent中链接driver和squencer，我们在sequence调用send，接着在driver中调用 get_next_item获取相应的发送的激励值。

    2）项目升级用法：使用方法一致。

    3）底层原理分析：

    我们平常可以不用定义，直接使用seq_item_port，那么在源码中肯定定义了该参数，在driver源码中，定义了uvm_seq_item_pull_port#(req,rsp)  seq_item_port，它是uvm_port_base的一个子类。

    Port和imp的初始化，然后在agent中连接，当在sequence中调用send函数，数据就会放入imp_list[]中，我们通过调用get_next_item不断获取数据，当imp_list[]中存在数据时，获取数据成功，m_if.get_next_item和m_imp.get_next_item，最后通过item_done结束本次激励的传递。

        最后总结一下：我们在driver里面通过一个看起来属于driver的seq_item_port的类来调用取sequencer构建的FIFO中的数据放到driver自己声明的transaction里面。这一个操作实际上是借用seq_item_port这个壳来调用了sequencer的函数来实现与FIFO的通信。

二次更新内容：

    之前写的太简单了，这次补充下：

    在run_phase里不用声明就直接调用了seq_item_port这个东西，那么它肯定是在driver类中系统已经定义好了的东西，我们打开uvm_driver看一看，uvm_driver的代码特别简单。

typedef class uvm_sequence_item;

//------------------------------------------------------------------------------
//
// CLASS: uvm_driver #(REQ,RSP)
//
// The base class for drivers that initiate requests for new transactions via
// a uvm_seq_item_pull_port. The ports are typically connected to the exports of
// an appropriate sequencer component.
//
// This driver operates in pull mode. Its ports are typically connected to the
// corresponding exports in a pull sequencer as follows:
//
//| driver.seq_item_port.connect(sequencer.seq_item_export);
//| driver.rsp_port.connect(sequencer.rsp_export);
//
// The ~rsp_port~ needs connecting only if the driver will use it to write
// responses to the analysis export in the sequencer.
//
//------------------------------------------------------------------------------

class uvm_driver #(type REQ=uvm_sequence_item,
type RSP=REQ) extends uvm_component;


// Port: seq_item_port
//
// Derived driver classes should use this port to request items from the
// sequencer. They may also use it to send responses back.

uvm_seq_item_pull_port #(REQ, RSP) seq_item_port;

uvm_seq_item_pull_port #(REQ, RSP) seq_item_prod_if; // alias

// Port: rsp_port
//
// This port provides an alternate way of sending responses back to the
// originating sequencer. Which port to use depends on which export the
// sequencer provides for connection.

uvm_analysis_port #(RSP) rsp_port;

REQ req;
RSP rsp;

// Function: new
//
// Creates and initializes an instance of this class using the normal
// constructor arguments for <uvm_component>: ~name~ is the name of the
// instance, and ~parent~ is the handle to the hierarchical parent, if any.

function new (string name, uvm_component parent);
super.new(name, parent);
seq_item_port = new("seq_item_port", this);
rsp_port = new("rsp_port", this);
seq_item_prod_if = seq_item_port;
endfunction // new

const static string type_name = "uvm_driver #(REQ,RSP)";

virtual function string get_type_name ();
return type_name;
endfunction

endclass

    可以看到，uvm_driver里面声明了三个port：seq_item_port/rsp_port/uvm_analysis_port，seq_item_port是一个uvm_seq_item_pull_port #(REQ, RSP)的类，这属于uvm_port_base下面的一个子类。

    它的代码部分特别简单，展示如下。(属于uvm_seq_item_pull_port )

class uvm_seq_item_pull_port #( type REQ = jelly_bean_transaction,
type RSP = REQ )
extends uvm_port_base #( uvm_sqr_if_base #(REQ, RSP) );

// `UVM_SEQ_PORT( `UVM_SEQ_ITEM_PULL_MASK, "uvm_seq_item_pull_port" )
// | |
// | V
// | ( `UVM_SEQ_ITEM_GET_NEXT_ITEM_MASK |
// | `UVM_SEQ_ITEM_TRY_NEXT_ITEM_MASK |
// | `UVM_SEQ_ITEM_ITEM_DONE_MASK |
// | `UVM_SEQ_ITEM_HAS_DO_AVAILABLE_MASK |
// | `UVM_SEQ_ITEM_WAIT_FOR_SEQUENCES_MASK |
// | `UVM_SEQ_ITEM_PUT_RESPONSE_MASK |
// | `UVM_SEQ_ITEM_PUT_MASK |
// | `UVM_SEQ_ITEM_GET_MASK |
// | `UVM_SEQ_ITEM_PEEK_MASK ) = 9'h1FF
// V

function new( string name,
uvm_component parent,
int min_size = 0,
int max_size = 1 );
super.new( name, parent, UVM_PORT, min_size, max_size );
m_if_mask = 9'h1FF;
endfunction // new

// |
// +--> `UVM_TLM_GET_TYPE_NAME( "uvm_seq_item_pull_port" )

virtual function string get_type_name();
return "uvm_seq_item_pull_port";
endfunction // get_type_name

// `UVM_SEQ_ITEM_PULL_IMP( this.m_if,
// | jelly_bean_transaction,
// | jelly_bean_transaction, t, t )
// V

task get_next_item( output jelly_bean_transaction t );
this.m_if.get_next_item( t );
endtask // get_next_item

task try_next_item( output jelly_bean_transaction t );
this.m_if.try_next_item( t );
endtask // try_next_item

function void item_done( input jelly_bean_transaction t = null );
this.m_if.item_done( t );
endfunction // item_done

task wait_for_sequences();
this.m_if.wait_for_sequences();
endtask // wait_for_sequences

function bit has_do_available();
return this.m_if.has_do_available();
endfunction // has_do_available

function void put_response( input jelly_bean_transaction t );
this.m_if.put_response( t );
endfunction // put_response

task get( output jelly_bean_transaction t );
this.m_if.get( t );
endtask // get

task peek( output jelly_bean_transaction t );
this.m_if.peek( t );
endtask // peek

task put( input jelly_bean_transaction t );
this.m_if.put( t );
endtask // put

// end of macro expansion

bit print_enabled;endclass // uvm_seq_item_pull_port

    从上面可以看到，seq_item_pull_port的get_next_item实际上是调用了m_if的get_next_item函数，那么什么是m_if呢。这个m_if是通过了别的两个函数执行之后，变成了sequencer。所以我们最终调用的是sequencer里面的get_next_item。

    现在可以总结一下了，我们在driver里面通过一个看起来属于driver的seq_item_port的类来调用取sequencer构建的FIFO中的数据(第二篇读UVM源代码的内容)放到driver自己声明的transaction里面。这一个操作实际上是借用seq_item_port这个壳来调用了sequencer的函数来实现与FIFO的通信。