| // |
| //------------------------------------------------------------------------------ |
| // Copyright 2007-2011 Mentor Graphics Corporation |
| // Copyright 2007-2011 Cadence Design Systems, Inc. |
| // Copyright 2010-2011 Synopsys, Inc. |
| // Copyright 2013 NVIDIA Corporation |
| // Copyright 2013 Verilab, Inc. |
| // All Rights Reserved Worldwide |
| // |
| // Licensed under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in |
| // compliance with the License. You may obtain a copy of |
| // the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in |
| // writing, software distributed under the License is |
| // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR |
| // CONDITIONS OF ANY KIND, either express or implied. See |
| // the License for the specific language governing |
| // permissions and limitations under the License. |
| //------------------------------------------------------------------------------ |
| |
| |
| typedef class uvm_object; |
| typedef class uvm_component; |
| typedef class uvm_object_wrapper; |
| typedef class uvm_factory_override; |
| |
| //Instance overrides by requested type lookup |
| class uvm_factory_queue_class; |
| uvm_factory_override queue[$]; |
| endclass |
| |
| //------------------------------------------------------------------------------ |
| // Title: UVM Factory |
| // |
| // This page covers the classes that define the UVM factory facility. |
| //------------------------------------------------------------------------------ |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_factory |
| // |
| //------------------------------------------------------------------------------ |
| // |
| // As the name implies, uvm_factory is used to manufacture (create) UVM objects |
| // and components. Object and component types are registered |
| // with the factory using lightweight proxies to the actual objects and |
| // components being created. The <uvm_object_registry #(T,Tname)> and |
| // <uvm_component_registry #(T,Tname)> class are used to proxy <uvm_objects> |
| // and <uvm_components>. |
| // |
| // The factory provides both name-based and type-based interfaces. |
| // |
| // type-based - The type-based interface is far less prone to errors in usage. |
| // When errors do occur, they are caught at compile-time. |
| // |
| // name-based - The name-based interface is dominated |
| // by string arguments that can be misspelled and provided in the wrong order. |
| // Errors in name-based requests might only be caught at the time of the call, |
| // if at all. Further, the name-based interface is not portable across |
| // simulators when used with parameterized classes. |
| // |
| // |
| // The ~uvm_factory~ is an abstract class which declares many of its methods |
| // as ~pure virtual~. The UVM uses the <uvm_default_factory> class |
| // as its default factory implementation. |
| // |
| // See <uvm_default_factory::Usage> section for details on configuring and using the factory. |
| // |
| |
| virtual class uvm_factory; |
| |
| // Group: Retrieving the factory |
| |
| |
| // Function: get |
| // Static accessor for <uvm_factory> |
| // |
| // The static accessor is provided as a convenience wrapper |
| // around retrieving the factory via the <uvm_coreservice_t::get_factory> |
| // method. |
| // |
| // | // Using the uvm_coreservice_t: |
| // | uvm_coreservice_t cs; |
| // | uvm_factory f; |
| // | cs = uvm_coreservice_t::get(); |
| // | f = cs.get_factory(); |
| // |
| // | // Not using the uvm_coreservice_t: |
| // | uvm_factory f; |
| // | f = uvm_factory::get(); |
| // |
| static function uvm_factory get(); |
| uvm_coreservice_t s; |
| s = uvm_coreservice_t::get(); |
| return s.get_factory(); |
| endfunction |
| |
| // Group: Registering Types |
| |
| // Function: register |
| // |
| // Registers the given proxy object, ~obj~, with the factory. The proxy object |
| // is a lightweight substitute for the component or object it represents. When |
| // the factory needs to create an object of a given type, it calls the proxy's |
| // create_object or create_component method to do so. |
| // |
| // When doing name-based operations, the factory calls the proxy's |
| // ~get_type_name~ method to match against the ~requested_type_name~ argument in |
| // subsequent calls to <create_component_by_name> and <create_object_by_name>. |
| // If the proxy object's ~get_type_name~ method returns the empty string, |
| // name-based lookup is effectively disabled. |
| |
| pure virtual function void register (uvm_object_wrapper obj); |
| |
| |
| // Group: Type & Instance Overrides |
| |
| // Function: set_inst_override_by_type |
| |
| pure virtual function |
| void set_inst_override_by_type (uvm_object_wrapper original_type, |
| uvm_object_wrapper override_type, |
| string full_inst_path); |
| |
| // Function: set_inst_override_by_name |
| // |
| // Configures the factory to create an object of the override's type whenever |
| // a request is made to create an object of the original type using a context |
| // that matches ~full_inst_path~. The original type is typically a super class |
| // of the override type. |
| // |
| // When overriding by type, the ~original_type~ and ~override_type~ are |
| // handles to the types' proxy objects. Preregistration is not required. |
| // |
| // When overriding by name, the ~original_type_name~ typically refers to a |
| // preregistered type in the factory. It may, however, be any arbitrary |
| // string. Future calls to any of the ~create_*~ methods with the same string |
| // and matching instance path will produce the type represented by |
| // ~override_type_name~, which must be preregistered with the factory. |
| // |
| // The ~full_inst_path~ is matched against the concatenation of |
| // {~parent_inst_path~, ".", ~name~} provided in future create requests. The |
| // ~full_inst_path~ may include wildcards (* and ?) such that a single |
| // instance override can be applied in multiple contexts. A ~full_inst_path~ |
| // of "*" is effectively a type override, as it will match all contexts. |
| // |
| // When the factory processes instance overrides, the instance queue is |
| // processed in order of override registrations, and the first override |
| // match prevails. Thus, more specific overrides should be registered |
| // first, followed by more general overrides. |
| |
| pure virtual function |
| void set_inst_override_by_name (string original_type_name, |
| string override_type_name, |
| string full_inst_path); |
| |
| |
| // Function: set_type_override_by_type |
| |
| pure virtual function |
| void set_type_override_by_type (uvm_object_wrapper original_type, |
| uvm_object_wrapper override_type, |
| bit replace=1); |
| |
| // Function: set_type_override_by_name |
| // |
| // Configures the factory to create an object of the override's type whenever |
| // a request is made to create an object of the original type, provided no |
| // instance override applies. The original type is typically a super class of |
| // the override type. |
| // |
| // When overriding by type, the ~original_type~ and ~override_type~ are |
| // handles to the types' proxy objects. Preregistration is not required. |
| // |
| // When overriding by name, the ~original_type_name~ typically refers to a |
| // preregistered type in the factory. It may, however, be any arbitrary |
| // string. Future calls to any of the ~create_*~ methods with the same string |
| // and matching instance path will produce the type represented by |
| // ~override_type_name~, which must be preregistered with the factory. |
| // |
| // When ~replace~ is 1, a previous override on ~original_type_name~ is |
| // replaced, otherwise a previous override, if any, remains intact. |
| |
| pure virtual function |
| void set_type_override_by_name (string original_type_name, |
| string override_type_name, |
| bit replace=1); |
| |
| |
| // Group: Creation |
| |
| // Function: create_object_by_type |
| |
| pure virtual function |
| uvm_object create_object_by_type (uvm_object_wrapper requested_type, |
| string parent_inst_path="", |
| string name=""); |
| |
| // Function: create_component_by_type |
| |
| pure virtual function |
| uvm_component create_component_by_type (uvm_object_wrapper requested_type, |
| string parent_inst_path="", |
| string name, |
| uvm_component parent); |
| |
| // Function: create_object_by_name |
| |
| pure virtual function |
| uvm_object create_object_by_name (string requested_type_name, |
| string parent_inst_path="", |
| string name=""); |
| |
| // Function: create_component_by_name |
| // |
| // Creates and returns a component or object of the requested type, which may |
| // be specified by type or by name. A requested component must be derived |
| // from the <uvm_component> base class, and a requested object must be derived |
| // from the <uvm_object> base class. |
| // |
| // When requesting by type, the ~requested_type~ is a handle to the type's |
| // proxy object. Preregistration is not required. |
| // |
| // When requesting by name, the ~request_type_name~ is a string representing |
| // the requested type, which must have been registered with the factory with |
| // that name prior to the request. If the factory does not recognize the |
| // ~requested_type_name~, an error is produced and a ~null~ handle returned. |
| // |
| // If the optional ~parent_inst_path~ is provided, then the concatenation, |
| // {~parent_inst_path~, ".",~name~}, forms an instance path (context) that |
| // is used to search for an instance override. The ~parent_inst_path~ is |
| // typically obtained by calling the <uvm_component::get_full_name> on the |
| // parent. |
| // |
| // If no instance override is found, the factory then searches for a type |
| // override. |
| // |
| // Once the final override is found, an instance of that component or object |
| // is returned in place of the requested type. New components will have the |
| // given ~name~ and ~parent~. New objects will have the given ~name~, if |
| // provided. |
| // |
| // Override searches are recursively applied, with instance overrides taking |
| // precedence over type overrides. If ~foo~ overrides ~bar~, and ~xyz~ |
| // overrides ~foo~, then a request for ~bar~ will produce ~xyz~. Recursive |
| // loops will result in an error, in which case the type returned will be |
| // that which formed the loop. Using the previous example, if ~bar~ |
| // overrides ~xyz~, then ~bar~ is returned after the error is issued. |
| |
| pure virtual function |
| uvm_component create_component_by_name (string requested_type_name, |
| string parent_inst_path="", |
| string name, |
| uvm_component parent); |
| |
| // Group: Debug |
| |
| // Function: debug_create_by_type |
| |
| pure virtual function |
| void debug_create_by_type (uvm_object_wrapper requested_type, |
| string parent_inst_path="", |
| string name=""); |
| |
| // Function: debug_create_by_name |
| // |
| // These methods perform the same search algorithm as the ~create_*~ methods, |
| // but they do not create new objects. Instead, they provide detailed |
| // information about what type of object it would return, listing each |
| // override that was applied to arrive at the result. Interpretation of the |
| // arguments are exactly as with the ~create_*~ methods. |
| |
| pure virtual function |
| void debug_create_by_name (string requested_type_name, |
| string parent_inst_path="", |
| string name=""); |
| |
| |
| // Function: find_override_by_type |
| |
| pure virtual function |
| uvm_object_wrapper find_override_by_type (uvm_object_wrapper requested_type, |
| string full_inst_path); |
| |
| // Function: find_override_by_name |
| // |
| // These methods return the proxy to the object that would be created given |
| // the arguments. The ~full_inst_path~ is typically derived from the parent's |
| // instance path and the leaf name of the object to be created, i.e. |
| // { parent.get_full_name(), ".", name }. |
| |
| pure virtual function |
| uvm_object_wrapper find_override_by_name (string requested_type_name, |
| string full_inst_path); |
| |
| // Function: find_wrapper_by_name |
| // |
| // This method returns the <uvm_object_wrapper> associated with a given |
| // ~type_name~. |
| pure virtual |
| function uvm_object_wrapper find_wrapper_by_name (string type_name); |
| |
| // Function: print |
| // |
| // Prints the state of the uvm_factory, including registered types, instance |
| // overrides, and type overrides. |
| // |
| // When ~all_types~ is 0, only type and instance overrides are displayed. When |
| // ~all_types~ is 1 (default), all registered user-defined types are printed as |
| // well, provided they have names associated with them. When ~all_types~ is 2, |
| // the UVM types (prefixed with uvm_) are included in the list of registered |
| // types. |
| |
| pure virtual function void print (int all_types=1); |
| endclass |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_default_factory |
| // |
| //------------------------------------------------------------------------------ |
| // |
| // Default implementation of the UVM factory. |
| |
| 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); |
| |
| |
| // Group: Type & Instance Overrides |
| |
| // Function: set_inst_override_by_type |
| |
| extern virtual function |
| void set_inst_override_by_type (uvm_object_wrapper original_type, |
| uvm_object_wrapper override_type, |
| string full_inst_path); |
| |
| // Function: set_inst_override_by_name |
| // |
| // Configures the factory to create an object of the override's type whenever |
| // a request is made to create an object of the original type using a context |
| // that matches ~full_inst_path~. |
| extern virtual function |
| void set_inst_override_by_name (string original_type_name, |
| string override_type_name, |
| string full_inst_path); |
| |
| |
| // Function: set_type_override_by_type |
| |
| extern virtual function |
| void set_type_override_by_type (uvm_object_wrapper original_type, |
| uvm_object_wrapper override_type, |
| bit replace=1); |
| |
| // Function: set_type_override_by_name |
| // |
| // Configures the factory to create an object of the override's type whenever |
| // a request is made to create an object of the original type, provided no |
| // instance override applies. |
| |
| extern virtual function |
| void set_type_override_by_name (string original_type_name, |
| string override_type_name, |
| bit replace=1); |
| |
| |
| // Group: Creation |
| |
| // Function: create_object_by_type |
| |
| extern virtual function |
| uvm_object create_object_by_type (uvm_object_wrapper requested_type, |
| string parent_inst_path="", |
| string name=""); |
| |
| // Function: create_component_by_type |
| |
| extern virtual function |
| uvm_component create_component_by_type (uvm_object_wrapper requested_type, |
| string parent_inst_path="", |
| string name, |
| uvm_component parent); |
| |
| // Function: create_object_by_name |
| |
| extern virtual function |
| uvm_object create_object_by_name (string requested_type_name, |
| string parent_inst_path="", |
| string name=""); |
| |
| // Function: create_component_by_name |
| // |
| // Creates and returns a component or object of the requested type, which may |
| // be specified by type or by name. |
| |
| extern virtual function |
| uvm_component create_component_by_name (string requested_type_name, |
| string parent_inst_path="", |
| string name, |
| uvm_component parent); |
| |
| // Group: Debug |
| |
| // Function: debug_create_by_type |
| |
| extern virtual function |
| void debug_create_by_type (uvm_object_wrapper requested_type, |
| string parent_inst_path="", |
| string name=""); |
| |
| // Function: debug_create_by_name |
| // |
| // These methods perform the same search algorithm as the ~create_*~ methods, |
| // but they do not create new objects. |
| extern virtual function |
| void debug_create_by_name (string requested_type_name, |
| string parent_inst_path="", |
| string name=""); |
| |
| |
| // Function: find_override_by_type |
| |
| extern virtual function |
| uvm_object_wrapper find_override_by_type (uvm_object_wrapper requested_type, |
| string full_inst_path); |
| |
| // Function: find_override_by_name |
| // |
| // These methods return the proxy to the object that would be created given |
| // the arguments. |
| |
| extern virtual function |
| uvm_object_wrapper find_override_by_name (string requested_type_name, |
| string full_inst_path); |
| |
| extern virtual |
| function uvm_object_wrapper find_wrapper_by_name (string type_name); |
| |
| // Function: print |
| // |
| // Prints the state of the uvm_factory, including registered types, instance |
| // overrides, and type overrides. |
| // |
| extern virtual function void print (int all_types=1); |
| |
| |
| //---------------------------------------------------------------------------- |
| // PRIVATE MEMBERS |
| |
| extern protected |
| function void m_debug_create (string requested_type_name, |
| uvm_object_wrapper requested_type, |
| string parent_inst_path, |
| string name); |
| |
| extern protected |
| function void m_debug_display(string requested_type_name, |
| uvm_object_wrapper result, |
| string full_inst_path); |
| |
| protected bit m_types[uvm_object_wrapper]; |
| protected bit m_lookup_strs[string]; |
| protected uvm_object_wrapper m_type_names[string]; |
| |
| protected uvm_factory_override m_type_overrides[$]; |
| |
| protected uvm_factory_queue_class m_inst_override_queues[uvm_object_wrapper]; |
| protected uvm_factory_queue_class m_inst_override_name_queues[string]; |
| protected uvm_factory_override m_wildcard_inst_overrides[$]; |
| |
| local uvm_factory_override m_override_info[$]; |
| local static bit m_debug_pass; |
| |
| extern function bit m_has_wildcard(string nm); |
| |
| extern function bit check_inst_override_exists |
| (uvm_object_wrapper original_type, |
| uvm_object_wrapper override_type, |
| string full_inst_path); |
| |
| endclass |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Group: Usage |
| // |
| // Using the factory involves three basic operations |
| // |
| // 1 - Registering objects and components types with the factory |
| // 2 - Designing components to use the factory to create objects or components |
| // 3 - Configuring the factory with type and instance overrides, both within and |
| // outside components |
| // |
| // We'll briefly cover each of these steps here. More reference information can |
| // be found at <Utility Macros>, <uvm_component_registry #(T,Tname)>, |
| // <uvm_object_registry #(T,Tname)>, <uvm_component>. |
| // |
| // 1 -- Registering objects and component types with the factory: |
| // |
| // When defining <uvm_object> and <uvm_component>-based classes, simply invoke |
| // the appropriate macro. Use of macros are required to ensure portability |
| // across different vendors' simulators. |
| // |
| // Objects that are not parameterized are declared as |
| // |
| //| class packet extends uvm_object; |
| //| `uvm_object_utils(packet) |
| //| endclass |
| //| |
| //| class packetD extends packet; |
| //| `uvm_object_utils(packetD) |
| //| endclass |
| // |
| // Objects that are parameterized are declared as |
| // |
| //| class packet #(type T=int, int WIDTH=32) extends uvm_object; |
| //| `uvm_object_param_utils(packet #(T,WIDTH)) |
| //| endclass |
| // |
| // Components that are not parameterized are declared as |
| // |
| //| class comp extends uvm_component; |
| //| `uvm_component_utils(comp) |
| //| endclass |
| // |
| // Components that are parameterized are declared as |
| // |
| //| class comp #(type T=int, int WIDTH=32) extends uvm_component; |
| //| `uvm_component_param_utils(comp #(T,WIDTH)) |
| //| endclass |
| // |
| // The `uvm_*_utils macros for simple, non-parameterized classes will register |
| // the type with the factory and define the get_type, get_type_name, and create |
| // virtual methods inherited from <uvm_object>. It will also define a static |
| // type_name variable in the class, which will allow you to determine the type |
| // without having to allocate an instance. |
| // |
| // The `uvm_*_param_utils macros for parameterized classes differ from |
| // `uvm_*_utils classes in the following ways: |
| // |
| // - The ~get_type_name~ method and static type_name variable are not defined. You |
| // will need to implement these manually. |
| // |
| // - A type name is not associated with the type when registering with the |
| // factory, so the factory's *_by_name operations will not work with |
| // parameterized classes. |
| // |
| // - The factory's <print>, <debug_create_by_type>, and <debug_create_by_name> |
| // methods, which depend on type names to convey information, will list |
| // parameterized types as '<unknown>'. |
| // |
| // It is worth noting that environments that exclusively use the type-based |
| // factory methods (*_by_type) do not require type registration. The factory's |
| // type-based methods will register the types involved "on the fly," when first |
| // used. However, registering with the `uvm_*_utils macros enables name-based |
| // factory usage and implements some useful utility functions. |
| // |
| // |
| // 2 -- Designing components that defer creation to the factory: |
| // |
| // Having registered your objects and components with the factory, you can now |
| // make requests for new objects and components via the factory. Using the factory |
| // instead of allocating them directly (via new) allows different objects to be |
| // substituted for the original without modifying the requesting class. The |
| // following code defines a driver class that is parameterized. |
| // |
| //| class driverB #(type T=uvm_object) extends uvm_driver; |
| //| |
| //| // parameterized classes must use the _param_utils version |
| //| `uvm_component_param_utils(driverB #(T)) |
| //| |
| //| // our packet type; this can be overridden via the factory |
| //| T pkt; |
| //| |
| //| // standard component constructor |
| //| function new(string name, uvm_component parent=null); |
| //| super.new(name,parent); |
| //| endfunction |
| //| |
| //| // get_type_name not implemented by macro for parameterized classes |
| //| const static string type_name = {"driverB #(",T::type_name,")"}; |
| //| virtual function string get_type_name(); |
| //| return type_name; |
| //| endfunction |
| //| |
| //| // using the factory allows pkt overrides from outside the class |
| //| virtual function void build_phase(uvm_phase phase); |
| //| pkt = packet::type_id::create("pkt",this); |
| //| endfunction |
| //| |
| //| // print the packet so we can confirm its type when printing |
| //| virtual function void do_print(uvm_printer printer); |
| //| printer.print_object("pkt",pkt); |
| //| endfunction |
| //| |
| //| endclass |
| // |
| // For purposes of illustrating type and instance overrides, we define two |
| // subtypes of the ~driverB~ class. The subtypes are also parameterized, so |
| // we must again provide an implementation for <uvm_object::get_type_name>, |
| // which we recommend writing in terms of a static string constant. |
| // |
| //| class driverD1 #(type T=uvm_object) extends driverB #(T); |
| //| |
| //| `uvm_component_param_utils(driverD1 #(T)) |
| //| |
| //| function new(string name, uvm_component parent=null); |
| //| super.new(name,parent); |
| //| endfunction |
| //| |
| //| const static string type_name = {"driverD1 #(",T::type_name,")"}; |
| //| virtual function string get_type_name(); |
| //| ...return type_name; |
| //| endfunction |
| //| |
| //| endclass |
| //| |
| //| class driverD2 #(type T=uvm_object) extends driverB #(T); |
| //| |
| //| `uvm_component_param_utils(driverD2 #(T)) |
| //| |
| //| function new(string name, uvm_component parent=null); |
| //| super.new(name,parent); |
| //| endfunction |
| //| |
| //| const static string type_name = {"driverD2 #(",T::type_name,")"}; |
| //| virtual function string get_type_name(); |
| //| return type_name; |
| //| endfunction |
| //| |
| //| endclass |
| //| |
| //| // typedef some specializations for convenience |
| //| typedef driverB #(packet) B_driver; // the base driver |
| //| typedef driverD1 #(packet) D1_driver; // a derived driver |
| //| typedef driverD2 #(packet) D2_driver; // another derived driver |
| // |
| // Next, we'll define a agent component, which requires a utils macro for |
| // non-parameterized types. Before creating the drivers using the factory, we |
| // override ~driver0~'s packet type to be ~packetD~. |
| // |
| //| class agent extends uvm_agent; |
| //| |
| //| `uvm_component_utils(agent) |
| //| ... |
| //| B_driver driver0; |
| //| B_driver driver1; |
| //| |
| //| function new(string name, uvm_component parent=null); |
| //| super.new(name,parent); |
| //| endfunction |
| //| |
| //| virtual function void build_phase(uvm_phase phase); |
| //| |
| //| // override the packet type for driver0 and below |
| //| packet::type_id::set_inst_override(packetD::get_type(),"driver0.*"); |
| //| |
| //| // create using the factory; actual driver types may be different |
| //| driver0 = B_driver::type_id::create("driver0",this); |
| //| driver1 = B_driver::type_id::create("driver1",this); |
| //| |
| //| endfunction |
| //| |
| //| endclass |
| // |
| // Finally we define an environment class, also not parameterized. Its ~build_phase~ |
| // method shows three methods for setting an instance override on a grandchild |
| // component with relative path name, ~agent1.driver1~, all equivalent. |
| // |
| //| class env extends uvm_env; |
| //| |
| //| `uvm_component_utils(env) |
| //| |
| //| agent agent0; |
| //| agent agent1; |
| //| |
| //| function new(string name, uvm_component parent=null); |
| //| super.new(name,parent); |
| //| endfunction |
| //| |
| //| virtual function void build_phase(uvm_phase phase); |
| //| |
| //| // three methods to set an instance override for agent1.driver1 |
| //| // - via component convenience method... |
| //| set_inst_override_by_type("agent1.driver1", |
| //| B_driver::get_type(), |
| //| D2_driver::get_type()); |
| //| |
| //| // - via the component's proxy (same approach as create)... |
| //| B_driver::type_id::set_inst_override(D2_driver::get_type(), |
| //| "agent1.driver1",this); |
| //| |
| //| // - via a direct call to a factory method... |
| //| factory.set_inst_override_by_type(B_driver::get_type(), |
| //| D2_driver::get_type(), |
| //| {get_full_name(),".agent1.driver1"}); |
| //| |
| //| // create agents using the factory; actual agent types may be different |
| //| agent0 = agent::type_id::create("agent0",this); |
| //| agent1 = agent::type_id::create("agent1",this); |
| //| |
| //| endfunction |
| //| |
| //| // at end_of_elaboration, print topology and factory state to verify |
| //| virtual function void end_of_elaboration_phase(uvm_phase phase); |
| //| uvm_top.print_topology(); |
| //| endfunction |
| //| |
| //| virtual task run_phase(uvm_phase phase); |
| //| #100 global_stop_request(); |
| //| endfunction |
| //| |
| //| endclass |
| // |
| // |
| // 3 -- Configuring the factory with type and instance overrides: |
| // |
| // In the previous step, we demonstrated setting instance overrides and creating |
| // components using the factory within component classes. Here, we will |
| // demonstrate setting overrides from outside components, as when initializing |
| // the environment prior to running the test. |
| // |
| //| module top; |
| //| |
| //| env env0; |
| //| |
| //| initial begin |
| //| |
| //| // Being registered first, the following overrides take precedence |
| //| // over any overrides made within env0's construction & build. |
| //| |
| //| // Replace all base drivers with derived drivers... |
| //| B_driver::type_id::set_type_override(D_driver::get_type()); |
| //| |
| //| // ...except for agent0.driver0, whose type remains a base driver. |
| //| // (Both methods below have the equivalent result.) |
| //| |
| //| // - via the component's proxy (preferred) |
| //| B_driver::type_id::set_inst_override(B_driver::get_type(), |
| //| "env0.agent0.driver0"); |
| //| |
| //| // - via a direct call to a factory method |
| //| factory.set_inst_override_by_type(B_driver::get_type(), |
| //| B_driver::get_type(), |
| //| {get_full_name(),"env0.agent0.driver0"}); |
| //| |
| //| // now, create the environment; our factory configuration will |
| //| // govern what topology gets created |
| //| env0 = new("env0"); |
| //| |
| //| // run the test (will execute build phase) |
| //| run_test(); |
| //| |
| //| end |
| //| |
| //| endmodule |
| // |
| // When the above example is run, the resulting topology (displayed via a call to |
| // <uvm_root::print_topology> in env's <uvm_component::end_of_elaboration_phase> method) |
| // is similar to the following: |
| // |
| //| # UVM_INFO @ 0 [RNTST] Running test ... |
| //| # UVM_INFO @ 0 [UVMTOP] UVM testbench topology: |
| //| # ---------------------------------------------------------------------- |
| //| # Name Type Size Value |
| //| # ---------------------------------------------------------------------- |
| //| # env0 env - env0@2 |
| //| # agent0 agent - agent0@4 |
| //| # driver0 driverB #(packet) - driver0@8 |
| //| # pkt packet - pkt@21 |
| //| # driver1 driverD #(packet) - driver1@14 |
| //| # pkt packet - pkt@23 |
| //| # agent1 agent - agent1@6 |
| //| # driver0 driverD #(packet) - driver0@24 |
| //| # pkt packet - pkt@37 |
| //| # driver1 driverD2 #(packet) - driver1@30 |
| //| # pkt packet - pkt@39 |
| //| # ---------------------------------------------------------------------- |
| // |
| //------------------------------------------------------------------------------ |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_object_wrapper |
| // |
| // The uvm_object_wrapper provides an abstract interface for creating object and |
| // component proxies. Instances of these lightweight proxies, representing every |
| // <uvm_object>-based and <uvm_component>-based object available in the test |
| // environment, are registered with the <uvm_factory>. When the factory is |
| // called upon to create an object or component, it finds and delegates the |
| // request to the appropriate proxy. |
| // |
| //------------------------------------------------------------------------------ |
| |
| virtual class uvm_object_wrapper; |
| |
| // Function: create_object |
| // |
| // Creates a new object with the optional ~name~. |
| // An object proxy (e.g., <uvm_object_registry #(T,Tname)>) implements this |
| // method to create an object of a specific type, T. |
| |
| virtual function uvm_object create_object (string name=""); |
| return null; |
| endfunction |
| |
| |
| // Function: create_component |
| // |
| // Creates a new component, passing to its constructor the given ~name~ and |
| // ~parent~. A component proxy (e.g. <uvm_component_registry #(T,Tname)>) |
| // implements this method to create a component of a specific type, T. |
| |
| virtual function uvm_component create_component (string name, |
| uvm_component parent); |
| return null; |
| endfunction |
| |
| |
| // Function: get_type_name |
| // |
| // Derived classes implement this method to return the type name of the object |
| // created by <create_component> or <create_object>. The factory uses this |
| // name when matching against the requested type in name-based lookups. |
| |
| pure virtual function string get_type_name(); |
| |
| endclass |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS- uvm_factory_override |
| // |
| // Internal class. |
| //------------------------------------------------------------------------------ |
| |
| class uvm_factory_override; |
| string full_inst_path; |
| string orig_type_name; |
| string ovrd_type_name; |
| bit selected; |
| int unsigned used; |
| uvm_object_wrapper orig_type; |
| uvm_object_wrapper ovrd_type; |
| function new (string full_inst_path="", |
| string orig_type_name="", |
| uvm_object_wrapper orig_type=null, |
| uvm_object_wrapper ovrd_type); |
| if (ovrd_type == null) begin |
| uvm_report_fatal ("NULLWR", "Attempting to register a null override object with the factory", UVM_NONE); |
| end |
| this.full_inst_path= full_inst_path; |
| this.orig_type_name = orig_type == null ? orig_type_name : orig_type.get_type_name(); |
| this.orig_type = orig_type; |
| this.ovrd_type_name = ovrd_type.get_type_name(); |
| this.ovrd_type = ovrd_type; |
| endfunction |
| endclass |
| |
| |
| //----------------------------------------------------------------------------- |
| // IMPLEMENTATION |
| //----------------------------------------------------------------------------- |
| |
| // register |
| // -------- |
| |
| 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 |
| |
| |
| // set_type_override_by_type |
| // ------------------------- |
| |
| function void uvm_default_factory::set_type_override_by_type (uvm_object_wrapper original_type, |
| uvm_object_wrapper override_type, |
| bit replace=1); |
| bit replaced; |
| |
| // check that old and new are not the same |
| if (original_type == override_type) begin |
| if (original_type.get_type_name() == "" || original_type.get_type_name() == "<unknown>") |
| uvm_report_warning("TYPDUP", {"Original and override type ", |
| "arguments are identical"}, UVM_NONE); |
| else |
| uvm_report_warning("TYPDUP", {"Original and override type ", |
| "arguments are identical: ", |
| original_type.get_type_name()}, UVM_NONE); |
| end |
| |
| // register the types if not already done so, for the benefit of string-based lookup |
| if (!m_types.exists(original_type)) |
| register(original_type); |
| |
| if (!m_types.exists(override_type)) |
| register(override_type); |
| |
| |
| // check for existing type override |
| foreach (m_type_overrides[index]) begin |
| if (m_type_overrides[index].orig_type == original_type || |
| (m_type_overrides[index].orig_type_name != "<unknown>" && |
| m_type_overrides[index].orig_type_name != "" && |
| m_type_overrides[index].orig_type_name == original_type.get_type_name())) begin |
| string msg; |
| msg = {"Original object type '",original_type.get_type_name(), |
| "' already registered to produce '", |
| m_type_overrides[index].ovrd_type_name,"'"}; |
| if (!replace) begin |
| msg = {msg, ". Set 'replace' argument to replace the existing entry."}; |
| uvm_report_info("TPREGD", msg, UVM_MEDIUM); |
| return; |
| end |
| msg = {msg, ". Replacing with override to produce type '", |
| override_type.get_type_name(),"'."}; |
| uvm_report_info("TPREGR", msg, UVM_MEDIUM); |
| replaced = 1; |
| m_type_overrides[index].orig_type = original_type; |
| m_type_overrides[index].orig_type_name = original_type.get_type_name(); |
| m_type_overrides[index].ovrd_type = override_type; |
| m_type_overrides[index].ovrd_type_name = override_type.get_type_name(); |
| end |
| end |
| |
| // make a new entry |
| if (!replaced) begin |
| uvm_factory_override override; |
| override = new(.orig_type(original_type), |
| .orig_type_name(original_type.get_type_name()), |
| .full_inst_path("*"), |
| .ovrd_type(override_type)); |
| |
| m_type_overrides.push_back(override); |
| end |
| |
| endfunction |
| |
| |
| // set_type_override_by_name |
| // ------------------------- |
| |
| function void uvm_default_factory::set_type_override_by_name (string original_type_name, |
| string override_type_name, |
| bit replace=1); |
| bit replaced; |
| |
| uvm_object_wrapper original_type; |
| uvm_object_wrapper override_type; |
| |
| if(m_type_names.exists(original_type_name)) |
| original_type = m_type_names[original_type_name]; |
| |
| if(m_type_names.exists(override_type_name)) |
| override_type = m_type_names[override_type_name]; |
| |
| // check that type is registered with the factory |
| if (override_type == null) begin |
| uvm_report_error("TYPNTF", {"Cannot register override for original type '", |
| original_type_name,"' because the override type '", |
| override_type_name, "' is not registered with the factory."}, UVM_NONE); |
| return; |
| end |
| |
| // check that old and new are not the same |
| if (original_type_name == override_type_name) begin |
| uvm_report_warning("TYPDUP", {"Requested and actual type name ", |
| " arguments are identical: ",original_type_name,". Ignoring this override."}, UVM_NONE); |
| return; |
| end |
| |
| foreach (m_type_overrides[index]) begin |
| if (m_type_overrides[index].orig_type_name == original_type_name) begin |
| if (!replace) begin |
| uvm_report_info("TPREGD", {"Original type '",original_type_name, |
| "' already registered to produce '",m_type_overrides[index].ovrd_type_name, |
| "'. Set 'replace' argument to replace the existing entry."}, UVM_MEDIUM); |
| return; |
| end |
| uvm_report_info("TPREGR", {"Original object type '",original_type_name, |
| "' already registered to produce '",m_type_overrides[index].ovrd_type_name, |
| "'. Replacing with override to produce type '",override_type_name,"'."}, UVM_MEDIUM); |
| replaced = 1; |
| m_type_overrides[index].ovrd_type = override_type; |
| m_type_overrides[index].ovrd_type_name = override_type_name; |
| end |
| end |
| |
| if (original_type == null) |
| m_lookup_strs[original_type_name] = 1; |
| |
| if (!replaced) begin |
| uvm_factory_override override; |
| override = new(.orig_type(original_type), |
| .orig_type_name(original_type_name), |
| .full_inst_path("*"), |
| .ovrd_type(override_type)); |
| |
| m_type_overrides.push_back(override); |
| // m_type_names[original_type_name] = override.ovrd_type; |
| end |
| |
| endfunction |
| |
| |
| // check_inst_override_exists |
| // -------------------------- |
| function bit uvm_default_factory::check_inst_override_exists (uvm_object_wrapper original_type, |
| uvm_object_wrapper override_type, |
| string full_inst_path); |
| uvm_factory_override override; |
| uvm_factory_queue_class qc; |
| |
| if (m_inst_override_queues.exists(original_type)) |
| qc = m_inst_override_queues[original_type]; |
| else |
| return 0; |
| |
| for (int index=0; index<qc.queue.size(); ++index) begin |
| |
| override = qc.queue[index]; |
| if (override.full_inst_path == full_inst_path && |
| override.orig_type == original_type && |
| override.ovrd_type == override_type && |
| override.orig_type_name == original_type.get_type_name()) begin |
| uvm_report_info("DUPOVRD",{"Instance override for '", |
| original_type.get_type_name(),"' already exists: override type '", |
| override_type.get_type_name(),"' with full_inst_path '", |
| full_inst_path,"'"},UVM_HIGH); |
| return 1; |
| end |
| end |
| return 0; |
| endfunction |
| |
| // set_inst_override_by_type |
| // ------------------------- |
| |
| function void uvm_default_factory::set_inst_override_by_type (uvm_object_wrapper original_type, |
| uvm_object_wrapper override_type, |
| string full_inst_path); |
| |
| uvm_factory_override override; |
| |
| // register the types if not already done so |
| if (!m_types.exists(original_type)) |
| register(original_type); |
| |
| if (!m_types.exists(override_type)) |
| register(override_type); |
| |
| if (check_inst_override_exists(original_type,override_type,full_inst_path)) |
| return; |
| |
| if(!m_inst_override_queues.exists(original_type)) |
| m_inst_override_queues[original_type] = new; |
| |
| override = new(.full_inst_path(full_inst_path), |
| .orig_type(original_type), |
| .orig_type_name(original_type.get_type_name()), |
| .ovrd_type(override_type)); |
| |
| |
| m_inst_override_queues[original_type].queue.push_back(override); |
| |
| endfunction |
| |
| |
| // set_inst_override_by_name |
| // ------------------------- |
| |
| function void uvm_default_factory::set_inst_override_by_name (string original_type_name, |
| string override_type_name, |
| string full_inst_path); |
| |
| uvm_factory_override override; |
| uvm_object_wrapper original_type; |
| uvm_object_wrapper override_type; |
| |
| if(m_type_names.exists(original_type_name)) |
| original_type = m_type_names[original_type_name]; |
| |
| if(m_type_names.exists(override_type_name)) |
| override_type = m_type_names[override_type_name]; |
| |
| // check that type is registered with the factory |
| if (override_type == null) begin |
| uvm_report_error("TYPNTF", {"Cannot register instance override with type name '", |
| original_type_name,"' and instance path '",full_inst_path,"' because the type it's supposed ", |
| "to produce, '",override_type_name,"', is not registered with the factory."}, UVM_NONE); |
| return; |
| end |
| |
| if (original_type == null) |
| m_lookup_strs[original_type_name] = 1; |
| |
| override = new(.full_inst_path(full_inst_path), |
| .orig_type(original_type), |
| .orig_type_name(original_type_name), |
| .ovrd_type(override_type)); |
| |
| if(original_type != null) begin |
| if (check_inst_override_exists(original_type,override_type,full_inst_path)) |
| return; |
| if(!m_inst_override_queues.exists(original_type)) |
| m_inst_override_queues[original_type] = new; |
| m_inst_override_queues[original_type].queue.push_back(override); |
| end |
| else begin |
| if(m_has_wildcard(original_type_name)) begin |
| foreach(m_type_names[i]) begin |
| if(uvm_is_match(original_type_name,i)) begin |
| this.set_inst_override_by_name(i, override_type_name, full_inst_path); |
| end |
| end |
| m_wildcard_inst_overrides.push_back(override); |
| end |
| else begin |
| if(!m_inst_override_name_queues.exists(original_type_name)) |
| m_inst_override_name_queues[original_type_name] = new; |
| m_inst_override_name_queues[original_type_name].queue.push_back(override); |
| end |
| end |
| |
| endfunction |
| |
| function bit uvm_default_factory::m_has_wildcard(string nm); |
| foreach (nm[i]) |
| if(nm[i] == "*" || nm[i] == "?") return 1; |
| return 0; |
| endfunction |
| |
| // 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 |
| |
| |
| // create_object_by_type |
| // --------------------- |
| |
| function uvm_object uvm_default_factory::create_object_by_type (uvm_object_wrapper requested_type, |
| string parent_inst_path="", |
| string name=""); |
| |
| string full_inst_path; |
| |
| if (parent_inst_path == "") |
| full_inst_path = name; |
| else if (name != "") |
| full_inst_path = {parent_inst_path,".",name}; |
| else |
| full_inst_path = parent_inst_path; |
| |
| m_override_info.delete(); |
| |
| requested_type = find_override_by_type(requested_type, full_inst_path); |
| |
| return requested_type.create_object(name); |
| |
| endfunction |
| |
| |
| // create_component_by_name |
| // ------------------------ |
| |
| function uvm_component uvm_default_factory::create_component_by_name (string requested_type_name, |
| string parent_inst_path="", |
| string name, |
| uvm_component parent); |
| 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 a component 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_component(name, parent); |
| |
| endfunction |
| |
| |
| // create_component_by_type |
| // ------------------------ |
| |
| function uvm_component uvm_default_factory::create_component_by_type (uvm_object_wrapper requested_type, |
| string parent_inst_path="", |
| string name, |
| uvm_component parent); |
| string full_inst_path; |
| |
| if (parent_inst_path == "") |
| full_inst_path = name; |
| else if (name != "") |
| full_inst_path = {parent_inst_path,".",name}; |
| else |
| full_inst_path = parent_inst_path; |
| |
| m_override_info.delete(); |
| |
| requested_type = find_override_by_type(requested_type, full_inst_path); |
| |
| return requested_type.create_component(name, parent); |
| |
| endfunction |
| |
| |
| |
| // find_wrapper_by_name |
| // ------------ |
| |
| function uvm_object_wrapper uvm_default_factory::find_wrapper_by_name(string type_name); |
| |
| if (m_type_names.exists(type_name)) |
| return m_type_names[type_name]; |
| |
| uvm_report_warning("UnknownTypeName", {"find_wrapper_by_name: Type name '",type_name, |
| "' not registered with the factory."}, UVM_NONE); |
| |
| endfunction |
| |
| |
| // find_override_by_name |
| // --------------------- |
| |
| function uvm_object_wrapper uvm_default_factory::find_override_by_name (string requested_type_name, |
| string full_inst_path); |
| uvm_object_wrapper rtype; |
| uvm_factory_queue_class qc; |
| uvm_factory_override lindex; |
| |
| uvm_object_wrapper override; |
| |
| if (m_type_names.exists(requested_type_name)) |
| rtype = m_type_names[requested_type_name]; |
| |
| /*** |
| if(rtype == null) begin |
| if(requested_type_name != "") begin |
| uvm_report_warning("TYPNTF", {"Requested type name ", |
| requested_type_name, " is not registered with the factory. The instance override to ", |
| full_inst_path, " is ignored"}, UVM_NONE); |
| end |
| m_lookup_strs[requested_type_name] = 1; |
| return null; |
| end |
| ***/ |
| |
| if (full_inst_path != "") begin |
| if(rtype == null) begin |
| if(m_inst_override_name_queues.exists(requested_type_name)) |
| qc = m_inst_override_name_queues[requested_type_name]; |
| end |
| else begin |
| if(m_inst_override_queues.exists(rtype)) |
| qc = m_inst_override_queues[rtype]; |
| end |
| if(qc != null) |
| for(int index = 0; index<qc.queue.size(); ++index) begin |
| if (uvm_is_match(qc.queue[index].orig_type_name, requested_type_name) && |
| uvm_is_match(qc.queue[index].full_inst_path, full_inst_path)) begin |
| m_override_info.push_back(qc.queue[index]); |
| if (m_debug_pass) begin |
| if (override == null) begin |
| override = qc.queue[index].ovrd_type; |
| qc.queue[index].selected = 1; |
| lindex=qc.queue[index]; |
| end |
| end |
| else begin |
| qc.queue[index].used++; |
| if (qc.queue[index].ovrd_type.get_type_name() == requested_type_name) |
| return qc.queue[index].ovrd_type; |
| else |
| return find_override_by_type(qc.queue[index].ovrd_type,full_inst_path); |
| end |
| end |
| end |
| end |
| |
| if(rtype != null && !m_inst_override_queues.exists(rtype) && m_wildcard_inst_overrides.size()) begin |
| m_inst_override_queues[rtype] = new; |
| foreach (m_wildcard_inst_overrides[i]) begin |
| if(uvm_is_match(m_wildcard_inst_overrides[i].orig_type_name, requested_type_name)) |
| m_inst_override_queues[rtype].queue.push_back(m_wildcard_inst_overrides[i]); |
| end |
| end |
| |
| // type override - exact match |
| foreach (m_type_overrides[index]) |
| if (m_type_overrides[index].orig_type_name == requested_type_name) begin |
| m_override_info.push_back(m_type_overrides[index]); |
| if (m_debug_pass) begin |
| if (override == null) begin |
| override = m_type_overrides[index].ovrd_type; |
| m_type_overrides[index].selected = 1; |
| lindex=m_type_overrides[index]; |
| end |
| end |
| else begin |
| m_type_overrides[index].used++; |
| return find_override_by_type(m_type_overrides[index].ovrd_type,full_inst_path); |
| end |
| end |
| |
| |
| if (m_debug_pass && override != null) begin |
| lindex.used++; |
| return find_override_by_type(override, full_inst_path); |
| end |
| |
| // No override found |
| return null; |
| |
| |
| endfunction |
| |
| |
| // find_override_by_type |
| // --------------------- |
| |
| function uvm_object_wrapper uvm_default_factory::find_override_by_type(uvm_object_wrapper requested_type, |
| string full_inst_path); |
| |
| uvm_object_wrapper override; |
| uvm_factory_override lindex; |
| |
| uvm_factory_queue_class qc; |
| qc = m_inst_override_queues.exists(requested_type) ? |
| m_inst_override_queues[requested_type] : null; |
| |
| foreach (m_override_info[index]) begin |
| if ( //index != m_override_info.size()-1 && |
| m_override_info[index].orig_type == requested_type) begin |
| uvm_report_error("OVRDLOOP", "Recursive loop detected while finding override.", UVM_NONE); |
| if (!m_debug_pass) |
| debug_create_by_type (requested_type, full_inst_path); |
| |
| m_override_info[index].used++; |
| return requested_type; |
| end |
| end |
| |
| // inst override; return first match; takes precedence over type overrides |
| if (full_inst_path != "" && qc != null) |
| for (int index = 0; index < qc.queue.size(); ++index) begin |
| if ((qc.queue[index].orig_type == requested_type || |
| (qc.queue[index].orig_type_name != "<unknown>" && |
| qc.queue[index].orig_type_name != "" && |
| qc.queue[index].orig_type_name == requested_type.get_type_name())) && |
| uvm_is_match(qc.queue[index].full_inst_path, full_inst_path)) begin |
| m_override_info.push_back(qc.queue[index]); |
| if (m_debug_pass) begin |
| if (override == null) begin |
| override = qc.queue[index].ovrd_type; |
| qc.queue[index].selected = 1; |
| lindex=qc.queue[index]; |
| end |
| end |
| else begin |
| qc.queue[index].used++; |
| if (qc.queue[index].ovrd_type == requested_type) |
| return requested_type; |
| else |
| return find_override_by_type(qc.queue[index].ovrd_type,full_inst_path); |
| end |
| end |
| end |
| |
| // type override - exact match |
| foreach (m_type_overrides[index]) begin |
| if (m_type_overrides[index].orig_type == requested_type || |
| (m_type_overrides[index].orig_type_name != "<unknown>" && |
| m_type_overrides[index].orig_type_name != "" && |
| requested_type != null && |
| m_type_overrides[index].orig_type_name == requested_type.get_type_name())) begin |
| m_override_info.push_back(m_type_overrides[index]); |
| if (m_debug_pass) begin |
| if (override == null) begin |
| override = m_type_overrides[index].ovrd_type; |
| m_type_overrides[index].selected = 1; |
| lindex=m_type_overrides[index]; |
| end |
| end |
| else begin |
| m_type_overrides[index].used++; |
| if (m_type_overrides[index].ovrd_type == requested_type) |
| return requested_type; |
| else |
| return find_override_by_type(m_type_overrides[index].ovrd_type,full_inst_path); |
| end |
| end |
| end |
| |
| // type override with wildcard match |
| //foreach (m_type_overrides[index]) |
| // if (uvm_is_match(index,requested_type.get_type_name())) begin |
| // m_override_info.push_back(m_inst_overrides[index]); |
| // return find_override_by_type(m_type_overrides[index],full_inst_path); |
| // end |
| |
| if (m_debug_pass && override != null) begin |
| lindex.used++; |
| if (override == requested_type) begin |
| return requested_type; |
| end |
| else |
| return find_override_by_type(override,full_inst_path); |
| end |
| |
| return requested_type; |
| |
| endfunction |
| |
| |
| // print |
| // ----- |
| |
| function void uvm_default_factory::print (int all_types=1); |
| |
| string key; |
| uvm_factory_queue_class sorted_override_queues[string]; |
| string qs[$]; |
| |
| string tmp; |
| int id; |
| uvm_object_wrapper obj; |
| |
| //sort the override queues |
| foreach (m_inst_override_queues[i]) begin |
| obj = i; |
| tmp = obj.get_type_name(); |
| if(tmp == "") $swrite(tmp, "__unnamed_id_%0d", id++); |
| sorted_override_queues[tmp] = m_inst_override_queues[i]; |
| |
| end |
| foreach (m_inst_override_name_queues[i]) begin |
| sorted_override_queues[i] = m_inst_override_name_queues[i]; |
| end |
| |
| qs.push_back("\n#### Factory Configuration (*)\n\n"); |
| |
| // print instance overrides |
| if(!m_type_overrides.size() && !sorted_override_queues.num()) |
| qs.push_back(" No instance or type overrides are registered with this factory\n"); |
| else begin |
| int max1,max2,max3; |
| string dash = "---------------------------------------------------------------------------------------------------"; |
| string space= " "; |
| |
| // print instance overrides |
| if(!sorted_override_queues.num()) |
| qs.push_back("No instance overrides are registered with this factory\n"); |
| else begin |
| foreach(sorted_override_queues[j]) begin |
| uvm_factory_queue_class qc; |
| qc = sorted_override_queues[j]; |
| for (int i=0; i<qc.queue.size(); ++i) begin |
| if (qc.queue[i].orig_type_name.len() > max1) |
| max1=qc.queue[i].orig_type_name.len(); |
| if (qc.queue[i].full_inst_path.len() > max2) |
| max2=qc.queue[i].full_inst_path.len(); |
| if (qc.queue[i].ovrd_type_name.len() > max3) |
| max3=qc.queue[i].ovrd_type_name.len(); |
| end |
| end |
| if (max1 < 14) max1 = 14; |
| if (max2 < 13) max2 = 13; |
| if (max3 < 13) max3 = 13; |
| |
| qs.push_back("Instance Overrides:\n\n"); |
| qs.push_back($sformatf(" %0s%0s %0s%0s %0s%0s\n","Requested Type",space.substr(1,max1-14), |
| "Override Path", space.substr(1,max2-13), |
| "Override Type", space.substr(1,max3-13))); |
| qs.push_back($sformatf(" %0s %0s %0s\n",dash.substr(1,max1), |
| dash.substr(1,max2), |
| dash.substr(1,max3))); |
| |
| foreach(sorted_override_queues[j]) begin |
| uvm_factory_queue_class qc; |
| qc = sorted_override_queues[j]; |
| for (int i=0; i<qc.queue.size(); ++i) begin |
| qs.push_back($sformatf(" %0s%0s %0s%0s",qc.queue[i].orig_type_name, |
| space.substr(1,max1-qc.queue[i].orig_type_name.len()), |
| qc.queue[i].full_inst_path, |
| space.substr(1,max2-qc.queue[i].full_inst_path.len()))); |
| qs.push_back($sformatf(" %0s\n", qc.queue[i].ovrd_type_name)); |
| end |
| end |
| end |
| |
| // print type overrides |
| if (!m_type_overrides.size()) |
| qs.push_back("\nNo type overrides are registered with this factory\n"); |
| else begin |
| // Resize for type overrides |
| if (max1 < 14) max1 = 14; |
| if (max2 < 13) max2 = 13; |
| if (max3 < 13) max3 = 13; |
| |
| foreach (m_type_overrides[i]) begin |
| if (m_type_overrides[i].orig_type_name.len() > max1) |
| max1=m_type_overrides[i].orig_type_name.len(); |
| if (m_type_overrides[i].ovrd_type_name.len() > max2) |
| max2=m_type_overrides[i].ovrd_type_name.len(); |
| end |
| if (max1 < 14) max1 = 14; |
| if (max2 < 13) max2 = 13; |
| qs.push_back("\nType Overrides:\n\n"); |
| qs.push_back($sformatf(" %0s%0s %0s%0s\n","Requested Type",space.substr(1,max1-14), |
| "Override Type", space.substr(1,max2-13))); |
| qs.push_back($sformatf(" %0s %0s\n",dash.substr(1,max1), |
| dash.substr(1,max2))); |
| foreach (m_type_overrides[index]) |
| qs.push_back($sformatf(" %0s%0s %0s\n", |
| m_type_overrides[index].orig_type_name, |
| space.substr(1,max1-m_type_overrides[index].orig_type_name.len()), |
| m_type_overrides[index].ovrd_type_name)); |
| end |
| end |
| |
| // print all registered types, if all_types >= 1 |
| if (all_types >= 1 && m_type_names.first(key)) begin |
| bit banner; |
| qs.push_back($sformatf("\nAll types registered with the factory: %0d total\n",m_types.num())); |
| do begin |
| // filter out uvm_ classes (if all_types<2) and non-types (lookup strings) |
| if (!(all_types < 2 && uvm_is_match("uvm_*", |
| m_type_names[key].get_type_name())) && |
| key == m_type_names[key].get_type_name()) begin |
| if (!banner) begin |
| qs.push_back(" Type Name\n"); |
| qs.push_back(" ---------\n"); |
| banner=1; |
| end |
| qs.push_back($sformatf(" %s\n", m_type_names[key].get_type_name())); |
| end |
| end while(m_type_names.next(key)); |
| end |
| |
| qs.push_back("(*) Types with no associated type name will be printed as <unknown>\n\n####\n\n"); |
| |
| `uvm_info("UVM/FACTORY/PRINT",`UVM_STRING_QUEUE_STREAMING_PACK(qs),UVM_NONE) |
| |
| endfunction |
| |
| |
| // debug_create_by_name |
| // -------------------- |
| |
| function void uvm_default_factory::debug_create_by_name (string requested_type_name, |
| string parent_inst_path="", |
| string name=""); |
| m_debug_create(requested_type_name, null, parent_inst_path, name); |
| endfunction |
| |
| |
| // debug_create_by_type |
| // -------------------- |
| |
| function void uvm_default_factory::debug_create_by_type (uvm_object_wrapper requested_type, |
| string parent_inst_path="", |
| string name=""); |
| m_debug_create("", requested_type, parent_inst_path, name); |
| endfunction |
| |
| |
| // m_debug_create |
| // -------------- |
| |
| function void uvm_default_factory::m_debug_create (string requested_type_name, |
| uvm_object_wrapper requested_type, |
| string parent_inst_path, |
| string name); |
| |
| string full_inst_path; |
| uvm_object_wrapper result; |
| |
| if (parent_inst_path == "") |
| full_inst_path = name; |
| else if (name != "") |
| full_inst_path = {parent_inst_path,".",name}; |
| else |
| full_inst_path = parent_inst_path; |
| |
| m_override_info.delete(); |
| |
| if (requested_type == null) begin |
| if (!m_type_names.exists(requested_type_name) && |
| !m_lookup_strs.exists(requested_type_name)) begin |
| uvm_report_warning("Factory Warning", {"The factory does not recognize '", |
| requested_type_name,"' as a registered type."}, UVM_NONE); |
| return; |
| end |
| m_debug_pass = 1; |
| |
| result = find_override_by_name(requested_type_name,full_inst_path); |
| end |
| else begin |
| m_debug_pass = 1; |
| if (!m_types.exists(requested_type)) |
| register(requested_type); |
| result = find_override_by_type(requested_type,full_inst_path); |
| if (requested_type_name == "") |
| requested_type_name = requested_type.get_type_name(); |
| end |
| |
| m_debug_display(requested_type_name, result, full_inst_path); |
| m_debug_pass = 0; |
| |
| foreach (m_override_info[index]) |
| m_override_info[index].selected = 0; |
| |
| endfunction |
| |
| |
| // m_debug_display |
| // --------------- |
| |
| function void uvm_default_factory::m_debug_display (string requested_type_name, |
| uvm_object_wrapper result, |
| string full_inst_path); |
| |
| int max1,max2,max3; |
| string dash = "---------------------------------------------------------------------------------------------------"; |
| string space= " "; |
| string qs[$]; |
| |
| qs.push_back("\n#### Factory Override Information (*)\n\n"); |
| qs.push_back( |
| $sformatf("Given a request for an object of type '%s' with an instance\npath of '%s' the factory encountered\n\n", |
| requested_type_name,full_inst_path)); |
| |
| if (m_override_info.size() == 0) |
| qs.push_back("no relevant overrides.\n\n"); |
| else begin |
| |
| qs.push_back("the following relevant overrides. An 'x' next to a match indicates a\nmatch that was ignored.\n\n"); |
| |
| foreach (m_override_info[i]) begin |
| if (m_override_info[i].orig_type_name.len() > max1) |
| max1=m_override_info[i].orig_type_name.len(); |
| if (m_override_info[i].full_inst_path.len() > max2) |
| max2=m_override_info[i].full_inst_path.len(); |
| if (m_override_info[i].ovrd_type_name.len() > max3) |
| max3=m_override_info[i].ovrd_type_name.len(); |
| end |
| |
| if (max1 < 13) max1 = 13; |
| if (max2 < 13) max2 = 13; |
| if (max3 < 13) max3 = 13; |
| |
| qs.push_back($sformatf("Original Type%0s Instance Path%0s Override Type%0s\n", |
| space.substr(1,max1-13),space.substr(1,max2-13),space.substr(1,max3-13))); |
| |
| qs.push_back($sformatf(" %0s %0s %0s\n",dash.substr(1,max1), |
| dash.substr(1,max2), |
| dash.substr(1,max3))); |
| |
| foreach (m_override_info[i]) begin |
| qs.push_back($sformatf("%s%0s%0s\n", |
| m_override_info[i].selected ? " " : "x ", |
| m_override_info[i].orig_type_name, |
| space.substr(1,max1-m_override_info[i].orig_type_name.len()))); |
| qs.push_back($sformatf(" %0s%0s", m_override_info[i].full_inst_path, |
| space.substr(1,max2-m_override_info[i].full_inst_path.len()))); |
| qs.push_back($sformatf(" %0s%0s", m_override_info[i].ovrd_type_name, |
| space.substr(1,max3-m_override_info[i].ovrd_type_name.len()))); |
| if (m_override_info[i].full_inst_path == "*") |
| qs.push_back(" <type override>"); |
| else |
| qs.push_back("\n"); |
| end |
| qs.push_back("\n"); |
| end |
| |
| |
| qs.push_back("Result:\n\n"); |
| qs.push_back($sformatf(" The factory will produce an object of type '%0s'\n", |
| result == null ? requested_type_name : result.get_type_name())); |
| |
| qs.push_back("\n(*) Types with no associated type name will be printed as <unknown>\n\n####\n\n"); |
| |
| `uvm_info("UVM/FACTORY/DUMP",`UVM_STRING_QUEUE_STREAMING_PACK(qs),UVM_NONE) |
| endfunction |
| |
| |
