[CU]factory机制5-factory机制创建实例的原理

 资料来源:

(1)公众号-芯片学堂;

注1:与[CU]factory机制3-factory机制创建实例(create_object/component_by_type/name) - __见贤思齐 - 博客园 (cnblogs.com)内容略有重叠,但侧重点不同;

1.factory机制相关宏

[CU]factory机制2-factory机制之用于类注册的宏(factory机制-注册) - __见贤思齐 - 博客园 (cnblogs.com)

注1:factory所有的操作都是通过`uvm_object_utils或`uvm_component_utils或`uvm_object_param_utils或`uvm_component_param_utils来完成;

2.factory机制的注册(以uvm_object_registry#(T,`"S`")为例,uvm_component_registry#(T,`"S`"类似))

(1) factory机制的注册是在typedef uvm_object_registry#(T,`"S`") type_id中实现的;

注1: typedef语句声明了一个参数化的类,类的名字为uvm_object_registry,参数有两个:一个是输入的类型T,一个是字符串S; 对于参数化的类而言,只有一个参数就是输入类型T;

注2: 输入参数类型T与type-based factory相对应,可以用来实现根据类型创建实例; 输入参数字符串S与string-based factory相对应,可以用来实现根据名字创建实例;

(2) uvm_object_registry#(T,`"S`")类内部有一个私有的静态成员变量me,通过调用get函数,创建一个me的实例,然后通过factory的register函数注册到factory中;

class uvm_object_registry #(type T=uvm_object, string Tname="<unknown>")
                                        extends uvm_object_wrapper;
  typedef uvm_object_registry #(T,Tname) this_type;

  ...
  local static this_type me = get();

  // Function: get
  //
  // Returns the singleton instance of this type. Type-based factory operation
  // depends on there being a single proxy instance for each registered type.

  static function this_type get();
    if (me == null) begin
      uvm_coreservice_t cs = uvm_coreservice_t::get();
      uvm_factory factory=cs.get_factory();
      me = new;
      factory.register(me);
    end
    return me;
  endfunction
  ...
endclass

注1:typedef uvm_object_registry#(T1,"S1") type1和typedef uvm_object_registry#(T2,"S2") type2在编译时,编译器会认为是两个类;

注2:所谓的把一个object或者component注册到factory中,其实注册的不是这个object或者component,而是uvm_object_registry#(T,"S")或uvm_component_registry#(T,"S")的一个实例;

3.单实例类uvm_factory

virtual class uvm_factory;

  // Group: Retrieving the factory    
  static function uvm_factory get();
          uvm_coreservice_t s;
          s = uvm_coreservice_t::get();
          return s.get_factory();
  endfunction    
  ...
endclass

3.1uvm_factory函数简介

(1)uvm_factory中定义了一系列纯虚函数,主要包括以下几种功能:重载,创建,查找,调试等;

(2)uvm_factory的函数根据参数可以分为基于名字(name-based)和基于类型(type-based)两类; 每一种相同的功能都有两种不同的实现方式,一种是基于名字实现,一种是基于类型实现;

virtual class uvm_factory;
     
  static function uvm_factory get();
          uvm_coreservice_t s;
          s = uvm_coreservice_t::get();
          return s.get_factory();
  endfunction    

  pure virtual function void register (uvm_object_wrapper obj);

  pure virtual function
      void set_inst_override_by_type (uvm_object_wrapper original_type,
                                      uvm_object_wrapper override_type,
                                      string full_inst_path);

  pure virtual function
      void set_inst_override_by_name (string original_type_name,
                                      string override_type_name,
                                      string full_inst_path);

  pure virtual function
      void set_type_override_by_type (uvm_object_wrapper original_type,
                                      uvm_object_wrapper override_type,
                                      bit replace=1);

  pure virtual function
      void set_type_override_by_name (string original_type_name,
                                      string override_type_name,
                                      bit replace=1);

  pure virtual function
      uvm_object    create_object_by_type    (uvm_object_wrapper requested_type,  
                                              string parent_inst_path="",
                                              string name=""); 

  pure virtual function
      uvm_component create_component_by_type (uvm_object_wrapper requested_type,  
                                              string parent_inst_path="",
                                              string name, 
                                              uvm_component parent);

  pure virtual function
      uvm_object    create_object_by_name    (string requested_type_name,  
                                              string parent_inst_path="",
                                              string name=""); 

  pure virtual function
      uvm_component create_component_by_name (string requested_type_name,  
                                              string parent_inst_path="",
                                              string name, 
                                              uvm_component parent);

  pure virtual function
      void debug_create_by_type (uvm_object_wrapper requested_type,
                                 string parent_inst_path="",
                                 string name="");

  pure virtual function
      void debug_create_by_name (string requested_type_name,
                                 string parent_inst_path="",
                                 string name="");

  pure virtual function
      uvm_object_wrapper find_override_by_type (uvm_object_wrapper requested_type,
                                                string full_inst_path);

  pure virtual function
      uvm_object_wrapper find_override_by_name (string requested_type_name,
                                                string full_inst_path);

  pure virtual 
    function uvm_object_wrapper find_wrapper_by_name            (string type_name);

  pure  virtual function void print (int all_types=1);
endclass 

4.uvm_default_factory::register();

class uvm_default_factory extends uvm_factory;

  // Group: Registering Types

  // Function: register
  //
  // Registers the given proxy object, ~obj~, with the factory.
   
  extern virtual function void register (uvm_object_wrapper obj);
  ...
endclass

function void uvm_default_factory::register (uvm_object_wrapper obj);

  if (obj == null) begin
    uvm_report_fatal ("NULLWR", "Attempting to register a null object with the factory", UVM_NONE);
  end
  if (obj.get_type_name() != "" && obj.get_type_name() != "<unknown>") begin
    if (m_type_names.exists(obj.get_type_name()))
      uvm_report_warning("TPRGED", {"Type name '",obj.get_type_name(),
        "' already registered with factory. No string-based lookup ",
        "support for multiple types with the same type name."}, UVM_NONE);
    else 
      m_type_names[obj.get_type_name()] = obj;
  end

  if (m_types.exists(obj)) begin
    if (obj.get_type_name() != "" && obj.get_type_name() != "<unknown>")
      uvm_report_warning("TPRGED", {"Object type '",obj.get_type_name(),
                         "' already registered with factory. "}, UVM_NONE);
  end
  else begin
    m_types[obj] = 1;
    // If a named override happens before the type is registered, need to copy
    // the override queue.
    // Note:Registration occurs via static initialization, which occurs ahead of
    // procedural (e.g. initial) blocks. There should not be any preexisting overrides.
    if(m_inst_override_name_queues.exists(obj.get_type_name())) begin
       m_inst_override_queues[obj] = new;
       m_inst_override_queues[obj].queue = m_inst_override_name_queues[obj.get_type_name()].queue;
       m_inst_override_name_queues.delete(obj.get_type_name());
    end
    if(m_wildcard_inst_overrides.size()) begin
       if(! m_inst_override_queues.exists(obj)) 
            m_inst_override_queues[obj] = new;
       foreach (m_wildcard_inst_overrides[i]) begin
         if(uvm_is_match( m_wildcard_inst_overrides[i].orig_type_name, obj.get_type_name()))
            m_inst_override_queues[obj].queue.push_back(m_wildcard_inst_overrides[i]);
       end
    end

  end

endfunction

(1) m_type_names联合数组的索引是string类型,其存储的内容是uvm_object_wrapper类型;

(2) factory.register(me)函数,会将uvm_object_registry#(T1,"S1")的静态成员变量me存储到m_type_names数组中,索引是me.get_type_name()的返回值,即"S1",记录的内容是me所指向的实例;

(3) m_types也是一个联合数组,该联合数组的索引是uvm_object_wrapper,存储的内容是bit类型; 如果m_types中没有找到相关记录,则进入else分支,往m_types中加入一条记录,该条记录的索引是uvm_object_registry#(T1,“S1”)的静态成员变量me所指向的实例;

(4) 总结:注册的实质就是把uvm_object_registry#(T1,”S1”)的实例me放入m_type_names中,并把"S1"作为索引;把me作为m_types的索引,其内容为1;

5.uvm_default_factory::create_object_by_name();

function uvm_object uvm_default_factory::create_object_by_name (string requested_type_name,  
                                                        string parent_inst_path="",  
                                                        string name=""); 

  uvm_object_wrapper wrapper;
  string inst_path;

  if (parent_inst_path == "")
    inst_path = name;
  else if (name != "")
    inst_path = {parent_inst_path,".",name};
  else
    inst_path = parent_inst_path;

  m_override_info.delete();

  wrapper = find_override_by_name(requested_type_name, inst_path);

  // if no override exists, try to use requested_type_name directly
  if (wrapper==null) begin
    if(!m_type_names.exists(requested_type_name)) begin
      uvm_report_warning("BDTYP",{"Cannot create an object of type '",
      requested_type_name,"' because it is not registered with the factory."}, UVM_NONE);
      return null;
    end
    wrapper = m_type_names[requested_type_name];
  end

  return wrapper.create_object(name);

endfunction

(1) 该函数先是根据传入的字符串(待实例化的类名)从关联数组m_type_names中获取相应的wrapper,即uvm_object_registry#(A,”A”)::me;

(2) wrapper.create_object就是uvm_object_registry#(A,”A”)::me.create_object();

6.uvm_object_registry#(T,`"S"`).create_object();

class uvm_object_registry #(type T=uvm_object, string Tname="<unknown>")
                                        extends uvm_object_wrapper;
  ...
  virtual function uvm_object create_object(string name="");
    T obj;
`ifdef UVM_OBJECT_DO_NOT_NEED_CONSTRUCTOR
    obj = new();
    if (name!="")
      obj.set_name(name);
`else
    if (name=="") obj = new();
    else obj = new(name);
`endif
    return obj;
  endfunction
  ...
endclass

(1) 之所以能调用uvm_object_registry.create_object创造类的实例,是因为uvm_object_registry是一个参数化的类,类T是作为一个类型参数传递进来的;

(2) factory机制中根据类名来创建类的实例所用到的技术: 参数化的类和静态变量及静态函数;