UVM : uvm_event, uvm_event_pool

在sv中达成同步的方式有 event, semaphore和mailbox。
而在UVM中event进化成uvm_event，不仅仅拥有达成不同组件进程之间同步的功能，还能像TLM通信一样传递数据，并且作用范围更广（TLM通信只能在uvm_component之间，而uvm_event不限于此）。

常见的uvm_event使用方法

首先从常见的uvm_event达成同步的方式讲起：
example code：

module test
  import uvm_pkg::*;
  
  initial begin
    // get a reference to the global singleton object by 
    // calling a static method
    uvm_event_pool ev_pool = uvm_event_pool::get_global_pool();

    // either create a uvm_event or return a reference to it
    // (which depends on the order of execution of the two
    //  initial blocks - the first call creates the event,
    //  the second and subsequent calls return a reference to
    //  an existing event.)
    uvm_event ev = ev_pool.get("ev");
    
    // wait (an arbitrary) 10 and then trigger the event
    #10 ev.trigger();
    $display("%t: event ev triggered", $time);
  end
  
  initial begin
    // get a reference to the global singleton object by 
    // calling a static method
    uvm_event_pool ev_pool = uvm_event_pool::get_global_pool();

    // either create a uvm_event or return a reference to it
    uvm_event ev = ev_pool.get("ev");
    
    // wait for the trigger
    ev.wait_trigger();
    $display("%t: event ev trigger received", $time);
  end

endmodule

（两个initial 块可以想象成两个不同UVM组件的不同进程）
通过上面的注释已经基本可以理解uvm_event的达成同步的方法，下面看看背后的原理：

1. 得到一个全局的单例的uvm_event_pool类型对象的句柄

 // get a reference to the global singleton object by 
 // calling a static method
    uvm_event_pool ev_pool = uvm_event_pool::get_global_pool();

要知道上面的的语句干了什么是就得知道uvm_event_pool的源代码：
https://verificationacademy.com/verification-methodology-reference/uvm/src/base/uvm_pool.svh

class uvm_object_string_pool #(type T=uvm_object) extends uvm_pool #(string,T);

  typedef uvm_object_string_pool #(T) this_type;
  static protected this_type m_global_pool;

  // Function: new
  //
  // Creates a new pool with the given ~name~.

  function new (string name="");
    super.new(name);
  endfunction

  const static string type_name = {"uvm_obj_str_pool"};

  // Function: get_type_name
  //
  // Returns the type name of this object.

  virtual function string get_type_name();
    return type_name;
  endfunction

  // Function: get_global_pool
  //
  // Returns the singleton global pool for the item type, T. 
  //
  // This allows items to be shared amongst components throughout the
  // verification environment.

  static function this_type get_global_pool ();
    if (m_global_pool==null)
      m_global_pool = new("global_pool");
    return m_global_pool;
  endfunction

  // Function: get_global
  //
  // Returns the specified item instance from the global item pool. 

  static function T get_global (string key);
    this_type gpool;
    gpool = get_global_pool(); 
    return gpool.get(key);
  endfunction

  // Function: get
  //
  // Returns the object item at the given string ~key~.
  //
  // If no item exists by the given ~key~, a new item is created for that key
  // and returned.

  virtual function T get (string key);
    if (!pool.exists(key))
      pool[key] = new (key);
    return pool[key];
  endfunction
  
  // Function: delete
  //
  // Removes the item with the given string ~key~ from the pool.
	...
  // Function- do_print
	...
endclass


typedef class uvm_barrier;
typedef class uvm_event;

typedef uvm_object_string_pool #(uvm_barrier) uvm_barrier_pool;
typedef uvm_object_string_pool #(uvm_event) uvm_event_pool;

uvm_event_pool是一个参数为uvm_event类型的uvm_object_string_pool，而uvm_object_string_pool又是继承于uvm_pool。uvm_event_pool和uvm_pool没有太大差别，也不是很复杂，在这里不是重点。

  typedef uvm_object_string_pool #(T) this_type;
  static protected this_type m_global_pool;
  protected T pool[KEY];  // type KEY = string
.........
  static function this_type get_global_pool ();
    if (m_global_pool==null)
      m_global_pool = new("global_pool");
    return m_global_pool;
  endfunction

get_global_pool()的源代码如上，结合uvm_event_pool的成员pool和m_global_pool——其中pool是从uvm_pool中继承过来的，而KEY和T正是传递的类型参数，string和uvm_event——可以知道， 调用get_global_pool()会返回一个类型为uvm_event_pool的句柄，句柄指向的对象是全局并且单例的。也就是说两个initial块中两次调用get_global_pool都是返回同一个uvm_event_pool类型对象的句柄，只是先调用的那个get_global_pool函数会创建这个对象。

2. 通过这个uvm_event_pool句柄调用get()方法得到一个uvm_event对象的的句柄

    uvm_event ev = ev_pool.get("ev");

get ()函数如下：

virtual function T get (string key);
    if (!pool.exists(key))
      pool[key] = new (key);
    return pool[key];
  endfunction

根据之前的源代码知道，在这里pool是一个关联数组，类型为uvm_event，索引类型为string（这也是为什么get()的参数为字符串）。两个initial块两次调用get()，是为了获得同一个pool[string]对象的句柄，先调用的那个get()会创建这个pool[string]，而后调用的那个只是获得这个pool[string]对象的句柄。这个过程和systemverilog中event的传递是一样的，是在两个进程中完成同步的基础。

3. 通过uvm_event对象的方法trigget () 和wait_trigger ()达成同步

    #10 ev.trigger();

    ev.wait_trigger();

前两部的目的本质上是为了让两个Initial块中两个uvm_event句柄指向同一个对象，这种作法相对于conifg_db或者层次化引用的方式显然方便得多，并且使用get_global()而非get()会更简单。接下来和systemverlog中event达成同步的操作一样了，在一个进程中触发->，另外一个进程中等待触发wait (event.triggered) or @event。
在uvm_event中，触发的方式是uvm_event.trigger ()；而等待出发的方式是wait_ptrigger () （电平触发）or wait_trigger () （上升沿触发） （与event的两种等待方式对应）。

uvm_event 相较于event的功能扩展

uvm_event的源代码如下，去掉了一些不常用的方法，这里只看关键的方法。

class uvm_event extends uvm_object;

  const static string type_name = "uvm_event";

  local event      m_event;
  local int        num_waiters;
  local bit        on;
  local time       trigger_time=0;
  local uvm_object trigger_data;
  local uvm_event_callback  callbacks[$];

  // Function: new
  function new (string name="");
    super.new(name);
  endfunction  


  // Task: wait_on
  virtual task wait_on (bit delta=0);
    if (on) begin
      if (delta)
        #0;
      return;
    end
    num_waiters++;
    @on;
  endtask


  // Task: wait_off
  virtual task wait_off (bit delta=0);
    if (!on) begin
      if (delta)
        #0;
      return;
    end
    num_waiters++;
    @on;
  endtask


  // Task: wait_trigger
  virtual task wait_trigger ();
    num_waiters++;
    @m_event;
  endtask


  // Task: wait_ptrigger

  virtual task wait_ptrigger ();
    if (m_event.triggered)
      return;
    num_waiters++;
    @m_event;
  endtask


  // Task: wait_trigger_data

  virtual task wait_trigger_data (output uvm_object data);
    wait_trigger();
    data = get_trigger_data();
  endtask


  // Task: wait_ptrigger_data

  virtual task wait_ptrigger_data (output uvm_object data);
    wait_ptrigger();
    data = get_trigger_data();
  endtask

  // Function: trigger

  virtual function void trigger (uvm_object data=null);
    int skip;
    skip=0;
    if (callbacks.size()) begin
      for (int i=0;i<callbacks.size();i++) begin
        uvm_event_callback tmp;
        tmp=callbacks[i];
        skip = skip + tmp.pre_trigger(this,data);
      end
    end
    if (skip==0) begin
      ->m_event;
      if (callbacks.size()) begin
        for (int i=0;i<callbacks.size();i++) begin
          uvm_event_callback tmp;
          tmp=callbacks[i];
          tmp.post_trigger(this,data);
        end
      end
      num_waiters = 0;
      on = 1;
      trigger_time = $realtime;
      trigger_data = data;
    end
  endfunction
  
  // Function: get_trigger_data

  virtual function uvm_object get_trigger_data ();
    return trigger_data;
  endfunction

  // Function: get_trigger_time
  virtual function time get_trigger_time ();
    return trigger_time;
  endfunction

  // Function: is_on

  // Function: is_off

  // Function: reset
  virtual function void reset (bit wakeup=0);
    event e;
    if (wakeup)
      ->m_event;
    m_event = e;
    num_waiters = 0;
    on = 0;
    trigger_time = 0;
    trigger_data = null;
  endfunction

  // Function: add_callback

  // Function: delete_callback

  // Function: cancel
  virtual function void cancel ();
    if (num_waiters > 0)
      num_waiters--;
  endfunction

  // Function: get_num_waiters
  virtual function int get_num_waiters ();
    return num_waiters;
  endfunction

  virtual function uvm_object create(string name=""); 
    uvm_event v;
    v=new(name);
    return v;
  endfunction


  virtual function string get_type_name();
    return type_name;
  endfunction


  virtual function void do_print (uvm_printer printer);
  endfunction


  virtual function void do_copy (uvm_object rhs);
  endfunction

endclass : uvm_event

可以发现uvm_event的基础其实还是event，只不过event的触发和等待两个动作进行了很多扩展， 主要区别如下:
http://www.sohu.com/a/140684109_778637

• event被->触发之后，会触发使用@等待该事件的对象；uvm_event通过trigger()来触发，会触发使用wait_trigger()等待的对象。如果要再次等待事件触发，event只需要再次用->来触发，而uvm_event需要先通过reset()方法重置初始状态，再使用trigger()来触发。

• event无法携带更多的信息，而uvm_event可以通过trigger(uvm_event data = null)的可选参数，将所要伴随触发的数据信息都写入到该触发事件中，而等待该事件的对象可以通过方法wait_trigger_data(output uvm_object data)来获取事件触发时写入的数据对象。这实际上是一个句柄的传递，句柄的类型是uvm_object，也就是说传递的对象句柄得是uvm_object类型的。那如何传递非uvm_object类型的对象呢，首先这个对象必须是uvm_object的子类或者子类的子类，然后才能将其句柄作为trigger()方法的参数，然后wait_trigger ()的参数必须是uvm_object类型的，可以用一个uvm_object类型的tmp作为参数传递句柄，然后使用$cast赋值给目标类型句柄。可以参考：http://www.sohu.com/a/140684109_778637

• event触发时无法直接触发回调函数，而uvm_event可以通过add_callback(uvm_event_callback cb, bit append = 1)函数来添加回调函数。

• event无法直接获取等待它的进程数目，而uvm_event不但可以通过get_num_waiters()来获取等待它的进程数目。

uvm_event 能够使用callback机制（这里就不讨论uvm_event_callback了，也不复杂）， uvm_event能够获取目前事件的等待获触发状态。两者最大的区别还是uvm_event能够传递数据，而event不行。

不使用get()而使用get_global()

由于m_global_pool是一个静态全局的单例，没有必要专门创建一个uvm_event_pool的句柄来指向它；

  static function T get_global (string key);
    this_type gpool;
    gpool = get_global_pool(); 
    return gpool.get(key);
  endfunction

get_global (string key)中集合了get_global_pool()和 get()方法，于是下面两部可以合成一句话

    uvm_event_pool ev_pool = uvm_event_pool::get_global_pool();

    // either create a uvm_event or return a reference to it
    uvm_event ev = ev_pool.get("ev");

	uvm_event ev = uvm_event_pool::get_global ("ev");

其实这两种做法的结果都是一样的，都是在uvm_event_pool::m_global_pool这个静态全局单例中的创建了一个uvm_event对象，并存放在关联数组uvm_event_pool::m_global_pool.pool[string]中，索引就是get or get_global ()的参数， 如果这个字符串索引已经存在，那么就返回这个pool[string]句柄。

https://www.chipverify.com/uvm/uvm-pool
https://www.edaplayground.com/x/2Jyj
https://www.cnblogs.com/lybinger/p/8057653.html
https://verificationacademy.com/verification-methodology-reference/uvm/docs_1.1c/html/files/base/uvm_event-svh.html#uvm_event.wait_on