| //---------------------------------------------------------------------- |
| // Copyright 2007-2011 Mentor Graphics Corporation |
| // Copyright 2007-2010 Cadence Design Systems, Inc. |
| // Copyright 2010-2011 Synopsys, 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. |
| //---------------------------------------------------------------------- |
| |
| `include "uvm_macros.svh" |
| |
| `ifndef UVM_CALLBACK_SVH |
| `define UVM_CALLBACK_SVH |
| |
| //------------------------------------------------------------------------------ |
| // Title: Callbacks Classes |
| // |
| // This section defines the classes used for callback registration, management, |
| // and user-defined callbacks. |
| //------------------------------------------------------------------------------ |
| |
| typedef class uvm_root; |
| typedef class uvm_callback; |
| typedef class uvm_callbacks_base; |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Class - uvm_typeid_base |
| // |
| //------------------------------------------------------------------------------ |
| // |
| // Simple typeid interface. Need this to set up the base-super mapping. |
| // This is similar to the factory, but much simpler. The idea of this |
| // interface is that each object type T has a typeid that can be |
| // used for mapping type relationships. This is not a user visible class. |
| |
| class uvm_typeid_base; |
| static string typename; |
| static uvm_callbacks_base typeid_map[uvm_typeid_base]; |
| static uvm_typeid_base type_map[uvm_callbacks_base]; |
| endclass |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Class - uvm_typeid#(T) |
| // |
| //------------------------------------------------------------------------------ |
| |
| class uvm_typeid#(type T=uvm_object) extends uvm_typeid_base; |
| static uvm_typeid#(T) m_b_inst; |
| static function uvm_typeid#(T) get(); |
| if(m_b_inst == null) |
| m_b_inst = new; |
| return m_b_inst; |
| endfunction |
| endclass |
| |
| //------------------------------------------------------------------------------ |
| // Class - uvm_callbacks_base |
| // |
| // Base class singleton that holds generic queues for all instance |
| // specific objects. This is an internal class. This class contains a |
| // global pool that has all of the instance specific callback queues in it. |
| // All of the typewide callback queues live in the derivative class |
| // uvm_typed_callbacks#(T). This is not a user visible class. |
| // |
| // This class holds the class inheritance hierarchy information |
| // (super types and derivative types). |
| // |
| // Note, all derivative uvm_callbacks#() class singletons access this |
| // global m_pool object in order to get access to their specific |
| // instance queue. |
| //------------------------------------------------------------------------------ |
| |
| class uvm_callbacks_base extends uvm_object; |
| |
| typedef uvm_callbacks_base this_type; |
| |
| /*protected*/ static bit m_tracing = 1; |
| static this_type m_b_inst; |
| |
| static uvm_pool#(uvm_object,uvm_queue#(uvm_callback)) m_pool; |
| |
| static function this_type m_initialize(); |
| if(m_b_inst == null) begin |
| m_b_inst = new; |
| m_pool = new; |
| end |
| return m_b_inst; |
| endfunction |
| |
| //Type checking interface |
| this_type m_this_type[$]; //one to many T->T/CB |
| uvm_typeid_base m_super_type; //one to one relation |
| uvm_typeid_base m_derived_types[$]; //one to many relation |
| |
| virtual function bit m_am_i_a(uvm_object obj); |
| return 0; |
| endfunction |
| |
| virtual function bit m_is_for_me(uvm_callback cb); |
| return 0; |
| endfunction |
| |
| virtual function bit m_is_registered(uvm_object obj, uvm_callback cb); |
| return 0; |
| endfunction |
| |
| virtual function uvm_queue#(uvm_callback) m_get_tw_cb_q(uvm_object obj); |
| return null; |
| endfunction |
| |
| virtual function void m_add_tw_cbs(uvm_callback cb, uvm_apprepend ordering); |
| endfunction |
| |
| virtual function bit m_delete_tw_cbs(uvm_callback cb); |
| return 0; |
| endfunction |
| |
| //Check registration. To test registration, start at this class and |
| //work down the class hierarchy. If any class returns true then |
| //the pair is legal. |
| function bit check_registration(uvm_object obj, uvm_callback cb); |
| this_type st, dt; |
| |
| if (m_is_registered(obj,cb)) |
| return 1; |
| |
| // Need to look at all possible T/CB pairs of this type |
| foreach(m_this_type[i]) |
| if(m_b_inst != m_this_type[i] && m_this_type[i].m_is_registered(obj,cb)) |
| return 1; |
| |
| if(obj == null) begin |
| foreach(m_derived_types[i]) begin |
| dt = uvm_typeid_base::typeid_map[m_derived_types[i] ]; |
| if(dt != null && dt.check_registration(null,cb)) |
| return 1; |
| end |
| end |
| |
| return 0; |
| endfunction |
| |
| endclass |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Class - uvm_typed_callbacks#(T) |
| // |
| //------------------------------------------------------------------------------ |
| // |
| // Another internal class. This contains the queue of typewide |
| // callbacks. It also contains some of the public interface methods, |
| // but those methods are accessed via the uvm_callbacks#() class |
| // so they are documented in that class even though the implementation |
| // is in this class. |
| // |
| // The <add>, <delete>, and <display> methods are implemented in this class. |
| |
| class uvm_typed_callbacks#(type T=uvm_object) extends uvm_callbacks_base; |
| |
| static uvm_queue#(uvm_callback) m_tw_cb_q; |
| static string m_typename; |
| |
| typedef uvm_typed_callbacks#(T) this_type; |
| typedef uvm_callbacks_base super_type; |
| |
| //The actual global object from the derivative class. Note that this is |
| //just a reference to the object that is generated in the derived class. |
| static this_type m_t_inst; |
| |
| static function this_type m_initialize(); |
| if(m_t_inst == null) begin |
| void'(super_type::m_initialize()); |
| m_t_inst = new; |
| m_t_inst.m_tw_cb_q = new("typewide_queue"); |
| end |
| return m_t_inst; |
| endfunction |
| |
| //Type checking interface: is given ~obj~ of type T? |
| virtual function bit m_am_i_a(uvm_object obj); |
| T this_type; |
| if (obj == null) |
| return 1; |
| return($cast(this_type,obj)); |
| endfunction |
| |
| //Getting the typewide queue |
| virtual function uvm_queue#(uvm_callback) m_get_tw_cb_q(uvm_object obj); |
| if(m_am_i_a(obj)) begin |
| foreach(m_derived_types[i]) begin |
| super_type dt; |
| dt = uvm_typeid_base::typeid_map[m_derived_types[i] ]; |
| if(dt != null && dt != this) begin |
| m_get_tw_cb_q = dt.m_get_tw_cb_q(obj); |
| if(m_get_tw_cb_q != null) |
| return m_get_tw_cb_q; |
| end |
| end |
| return m_t_inst.m_tw_cb_q; |
| end |
| else |
| return null; |
| endfunction |
| |
| static function int m_cb_find(uvm_queue#(uvm_callback) q, uvm_callback cb); |
| for(int i=0; i<q.size(); ++i) |
| if(q.get(i) == cb) |
| return i; |
| return -1; |
| endfunction |
| |
| static function int m_cb_find_name(uvm_queue#(uvm_callback) q, string name, string where); |
| uvm_callback cb; |
| for(int i=0; i<q.size(); ++i) begin |
| cb = q.get(i); |
| if(cb.get_name() == name) begin |
| `uvm_warning("UVM/CB/NAM/SAM", {"A callback named \"", name, |
| "\" is already registered with ", where}) |
| return 1; |
| end |
| end |
| return 0; |
| endfunction |
| |
| //For a typewide callback, need to add to derivative types as well. |
| virtual function void m_add_tw_cbs(uvm_callback cb, uvm_apprepend ordering); |
| super_type cb_pair; |
| uvm_object obj; |
| T me; |
| bit warned; |
| uvm_queue#(uvm_callback) q; |
| if(m_cb_find(m_t_inst.m_tw_cb_q,cb) == -1) begin |
| warned = m_cb_find_name(m_t_inst.m_tw_cb_q, cb.get_name(), "type"); |
| if(ordering == UVM_APPEND) |
| m_t_inst.m_tw_cb_q.push_back(cb); |
| else |
| m_t_inst.m_tw_cb_q.push_front(cb); |
| end |
| if(m_t_inst.m_pool.first(obj)) begin |
| do begin |
| if($cast(me,obj)) begin |
| q = m_t_inst.m_pool.get(obj); |
| if(q==null) begin |
| q=new; |
| m_t_inst.m_pool.add(obj,q); |
| end |
| if(m_cb_find(q,cb) == -1) begin |
| if (!warned) begin |
| void'(m_cb_find_name(q, cb.get_name(), {"object instance ", me.get_full_name()})); |
| end |
| if(ordering == UVM_APPEND) |
| q.push_back(cb); |
| else |
| q.push_front(cb); |
| end |
| end |
| end while(m_t_inst.m_pool.next(obj)); |
| end |
| foreach(m_derived_types[i]) begin |
| cb_pair = uvm_typeid_base::typeid_map[m_derived_types[i] ]; |
| if(cb_pair != this) |
| cb_pair.m_add_tw_cbs(cb,ordering); |
| end |
| endfunction |
| |
| |
| //For a typewide callback, need to remove from derivative types as well. |
| virtual function bit m_delete_tw_cbs(uvm_callback cb); |
| super_type cb_pair; |
| uvm_object obj; |
| uvm_queue#(uvm_callback) q; |
| int pos = m_cb_find(m_t_inst.m_tw_cb_q,cb); |
| |
| if(pos != -1) begin |
| m_t_inst.m_tw_cb_q.delete(pos); |
| m_delete_tw_cbs = 1; |
| end |
| |
| if(m_t_inst.m_pool.first(obj)) begin |
| do begin |
| q = m_t_inst.m_pool.get(obj); |
| if(q==null) begin |
| q=new; |
| m_t_inst.m_pool.add(obj,q); |
| end |
| pos = m_cb_find(q,cb); |
| if(pos != -1) begin |
| q.delete(pos); |
| m_delete_tw_cbs = 1; |
| end |
| end while(m_t_inst.m_pool.next(obj)); |
| end |
| foreach(m_derived_types[i]) begin |
| cb_pair = uvm_typeid_base::typeid_map[m_derived_types[i] ]; |
| if(cb_pair != this) |
| m_delete_tw_cbs |= cb_pair.m_delete_tw_cbs(cb); |
| end |
| endfunction |
| |
| |
| static function void display(T obj=null); |
| T me; |
| super_type ib = m_t_inst; |
| string cbq[$]; |
| string inst_q[$]; |
| string mode_q[$]; |
| uvm_callback cb; |
| string blanks = " "; |
| uvm_object bobj = obj; |
| string qs[$]; |
| |
| uvm_queue#(uvm_callback) q; |
| string tname, str; |
| |
| int max_cb_name=0, max_inst_name=0; |
| |
| m_tracing = 0; //don't allow tracing during display |
| |
| if(m_typename != "") tname = m_typename; |
| else if(obj != null) tname = obj.get_type_name(); |
| else tname = "*"; |
| |
| q = m_t_inst.m_tw_cb_q; |
| for(int i=0; i<q.size(); ++i) begin |
| cb = q.get(i); |
| cbq.push_back(cb.get_name()); |
| inst_q.push_back("(*)"); |
| if(cb.is_enabled()) mode_q.push_back("ON"); |
| else mode_q.push_back("OFF"); |
| |
| str = cb.get_name(); |
| max_cb_name = max_cb_name > str.len() ? max_cb_name : str.len(); |
| str = "(*)"; |
| max_inst_name = max_inst_name > str.len() ? max_inst_name : str.len(); |
| end |
| |
| if(obj ==null) begin |
| if(m_t_inst.m_pool.first(bobj)) begin |
| do |
| if($cast(me,bobj)) break; |
| while(m_t_inst.m_pool.next(bobj)); |
| end |
| if(me != null || m_t_inst.m_tw_cb_q.size()) begin |
| qs.push_back($sformatf("Registered callbacks for all instances of %s\n", tname)); |
| qs.push_back("---------------------------------------------------------------\n"); |
| end |
| if(me != null) begin |
| do begin |
| if($cast(me,bobj)) begin |
| q = m_t_inst.m_pool.get(bobj); |
| if (q==null) begin |
| q=new; |
| m_t_inst.m_pool.add(bobj,q); |
| end |
| for(int i=0; i<q.size(); ++i) begin |
| cb = q.get(i); |
| cbq.push_back(cb.get_name()); |
| inst_q.push_back(bobj.get_full_name()); |
| if(cb.is_enabled()) mode_q.push_back("ON"); |
| else mode_q.push_back("OFF"); |
| |
| str = cb.get_name(); |
| max_cb_name = max_cb_name > str.len() ? max_cb_name : str.len(); |
| str = bobj.get_full_name(); |
| max_inst_name = max_inst_name > str.len() ? max_inst_name : str.len(); |
| end |
| end |
| end while (m_t_inst.m_pool.next(bobj)); |
| end |
| else begin |
| qs.push_back($sformatf("No callbacks registered for any instances of type %s\n", tname)); |
| end |
| end |
| else begin |
| if(m_t_inst.m_pool.exists(bobj) || m_t_inst.m_tw_cb_q.size()) begin |
| qs.push_back($sformatf("Registered callbacks for instance %s of %s\n", obj.get_full_name(), tname)); |
| qs.push_back("---------------------------------------------------------------\n"); |
| end |
| if(m_t_inst.m_pool.exists(bobj)) begin |
| q = m_t_inst.m_pool.get(bobj); |
| if(q==null) begin |
| q=new; |
| m_t_inst.m_pool.add(bobj,q); |
| end |
| for(int i=0; i<q.size(); ++i) begin |
| cb = q.get(i); |
| cbq.push_back(cb.get_name()); |
| inst_q.push_back(bobj.get_full_name()); |
| if(cb.is_enabled()) mode_q.push_back("ON"); |
| else mode_q.push_back("OFF"); |
| |
| str = cb.get_name(); |
| max_cb_name = max_cb_name > str.len() ? max_cb_name : str.len(); |
| str = bobj.get_full_name(); |
| max_inst_name = max_inst_name > str.len() ? max_inst_name : str.len(); |
| end |
| end |
| end |
| if(!cbq.size()) begin |
| if(obj == null) str = "*"; |
| else str = obj.get_full_name(); |
| qs.push_back($sformatf("No callbacks registered for instance %s of type %s\n", str, tname)); |
| end |
| |
| foreach (cbq[i]) begin |
| qs.push_back($sformatf("%s %s %s on %s %s\n", cbq[i], blanks.substr(0,max_cb_name-cbq[i].len()-1), inst_q[i], blanks.substr(0,max_inst_name - inst_q[i].len()-1), mode_q[i])); |
| end |
| `uvm_info("UVM/CB/DISPLAY",`UVM_STRING_QUEUE_STREAMING_PACK(qs),UVM_NONE) |
| |
| m_tracing = 1; //allow tracing to be resumed |
| endfunction |
| |
| endclass |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_callbacks #(T,CB) |
| // |
| // The ~uvm_callbacks~ class provides a base class for implementing callbacks, |
| // which are typically used to modify or augment component behavior without |
| // changing the component class. To work effectively, the developer of the |
| // component class defines a set of "hook" methods that enable users to |
| // customize certain behaviors of the component in a manner that is controlled |
| // by the component developer. The integrity of the component's overall behavior |
| // is intact, while still allowing certain customizable actions by the user. |
| // |
| // To enable compile-time type-safety, the class is parameterized on both the |
| // user-defined callback interface implementation as well as the object type |
| // associated with the callback. The object type-callback type pair are |
| // associated together using the <`uvm_register_cb> macro to define |
| // a valid pairing; valid pairings are checked when a user attempts to add |
| // a callback to an object. |
| // |
| // To provide the most flexibility for end-user customization and reuse, it |
| // is recommended that the component developer also define a corresponding set |
| // of virtual method hooks in the component itself. This affords users the ability |
| // to customize via inheritance/factory overrides as well as callback object |
| // registration. The implementation of each virtual method would provide the |
| // default traversal algorithm for the particular callback being called. Being |
| // virtual, users can define subtypes that override the default algorithm, |
| // perform tasks before and/or after calling super.<method> to execute any |
| // registered callbacks, or to not call the base implementation, effectively |
| // disabling that particular hook. A demonstration of this methodology is |
| // provided in an example included in the kit. |
| //------------------------------------------------------------------------------ |
| |
| class uvm_callbacks #(type T=uvm_object, type CB=uvm_callback) |
| extends uvm_typed_callbacks#(T); |
| |
| // Parameter: T |
| // |
| // This type parameter specifies the base object type with which the |
| // <CB> callback objects will be registered. This object must be |
| // a derivative of ~uvm_object~. |
| |
| // Parameter: CB |
| // |
| // This type parameter specifies the base callback type that will be |
| // managed by this callback class. The callback type is typically a |
| // interface class, which defines one or more virtual method prototypes |
| // that users can override in subtypes. This type must be a derivative |
| // of <uvm_callback>. |
| |
| typedef uvm_typed_callbacks#(T) super_type; |
| typedef uvm_callbacks#(T,CB) this_type; |
| |
| |
| // Singleton instance is used for type checking |
| local static this_type m_inst; |
| |
| // typeinfo |
| static uvm_typeid_base m_typeid; |
| static uvm_typeid_base m_cb_typeid; |
| |
| static string m_typename; |
| static string m_cb_typename; |
| static uvm_report_object reporter = new("cb_tracer"); |
| static uvm_callbacks#(T,uvm_callback) m_base_inst; |
| |
| bit m_registered; |
| |
| // get |
| // --- |
| |
| static function this_type get(); |
| |
| if (m_inst == null) begin |
| uvm_typeid_base cb_base_type; |
| |
| void'(super_type::m_initialize()); |
| |
| cb_base_type = uvm_typeid#(uvm_callback)::get(); |
| m_cb_typeid = uvm_typeid#(CB)::get(); |
| m_typeid = uvm_typeid#(T)::get(); |
| |
| m_inst = new; |
| |
| if (cb_base_type == m_cb_typeid) begin |
| $cast(m_base_inst, m_inst); |
| // The base inst in the super class gets set to this base inst |
| m_t_inst = m_base_inst; |
| uvm_typeid_base::typeid_map[m_typeid] = m_inst; |
| uvm_typeid_base::type_map[m_b_inst] = m_typeid; |
| end |
| else begin |
| m_base_inst = uvm_callbacks#(T,uvm_callback)::get(); |
| m_base_inst.m_this_type.push_back(m_inst); |
| end |
| |
| if (m_inst == null) |
| `uvm_fatal("CB/INTERNAL","get(): m_inst is null") |
| end |
| |
| return m_inst; |
| endfunction |
| |
| |
| |
| // m_register_pair |
| // ------------- |
| // Register valid callback type |
| |
| static function bit m_register_pair(string tname="", cbname=""); |
| this_type inst = get(); |
| |
| m_typename = tname; |
| super_type::m_typename = tname; |
| m_typeid.typename = tname; |
| |
| m_cb_typename = cbname; |
| m_cb_typeid.typename = cbname; |
| |
| inst.m_registered = 1; |
| |
| return 1; |
| endfunction |
| |
| virtual function bit m_is_registered(uvm_object obj, uvm_callback cb); |
| if(m_is_for_me(cb) && m_am_i_a(obj)) begin |
| return m_registered; |
| end |
| endfunction |
| |
| //Does type check to see if the callback is valid for this type |
| virtual function bit m_is_for_me(uvm_callback cb); |
| CB this_cb; |
| return($cast(this_cb,cb)); |
| endfunction |
| |
| // Group: Add/delete interface |
| |
| // Function: add |
| // |
| // Registers the given callback object, ~cb~, with the given |
| // ~obj~ handle. The ~obj~ handle can be ~null~, which allows |
| // registration of callbacks without an object context. If |
| // ~ordering~ is UVM_APPEND (default), the callback will be executed |
| // after previously added callbacks, else the callback |
| // will be executed ahead of previously added callbacks. The ~cb~ |
| // is the callback handle; it must be non-~null~, and if the callback |
| // has already been added to the object instance then a warning is |
| // issued. Note that the CB parameter is optional. For example, the |
| // following are equivalent: |
| // |
| //| uvm_callbacks#(my_comp)::add(comp_a, cb); |
| //| uvm_callbacks#(my_comp, my_callback)::add(comp_a,cb); |
| |
| static function void add(T obj, uvm_callback cb, uvm_apprepend ordering=UVM_APPEND); |
| uvm_queue#(uvm_callback) q; |
| string nm,tnm; |
| |
| void'(get()); |
| |
| if (cb==null) begin |
| if (obj==null) |
| nm = "(*)"; |
| else |
| nm = obj.get_full_name(); |
| |
| if (m_base_inst.m_typename!="") |
| tnm = m_base_inst.m_typename; |
| else if (obj != null) |
| tnm = obj.get_type_name(); |
| else |
| tnm = "uvm_object"; |
| |
| uvm_report_error("CBUNREG", |
| {"Null callback object cannot be registered with object ", |
| nm, " (", tnm, ")"}, UVM_NONE); |
| return; |
| end |
| |
| if (!m_base_inst.check_registration(obj,cb)) begin |
| |
| if (obj==null) |
| nm = "(*)"; |
| else |
| nm = obj.get_full_name(); |
| |
| if (m_base_inst.m_typename!="") |
| tnm = m_base_inst.m_typename; |
| else if(obj != null) |
| tnm = obj.get_type_name(); |
| else |
| tnm = "uvm_object"; |
| |
| uvm_report_warning("CBUNREG", |
| {"Callback ", cb.get_name(), " cannot be registered with object ", |
| nm, " because callback type ", cb.get_type_name(), |
| " is not registered with object type ", tnm }, UVM_NONE); |
| end |
| |
| if(obj == null) begin |
| |
| if (m_cb_find(m_t_inst.m_tw_cb_q,cb) != -1) begin |
| |
| if (m_base_inst.m_typename!="") |
| tnm = m_base_inst.m_typename; |
| else tnm = "uvm_object"; |
| |
| uvm_report_warning("CBPREG", |
| {"Callback object ", cb.get_name(), |
| " is already registered with type ", tnm }, UVM_NONE); |
| end |
| else begin |
| `uvm_cb_trace_noobj(cb,$sformatf("Add (%s) typewide callback %0s for type %s", |
| ordering.name(), cb.get_name(), m_base_inst.m_typename)) |
| m_t_inst.m_add_tw_cbs(cb,ordering); |
| end |
| end |
| |
| else begin |
| |
| `uvm_cb_trace_noobj(cb,$sformatf("Add (%s) callback %0s to object %0s ", |
| ordering.name(), cb.get_name(), obj.get_full_name())) |
| |
| q = m_base_inst.m_pool.get(obj); |
| |
| if (q==null) begin |
| q=new; |
| m_base_inst.m_pool.add(obj,q); |
| end |
| |
| if(q.size() == 0) begin |
| // Need to make sure that registered report catchers are added. This |
| // way users don't need to set up uvm_report_object as a super type. |
| uvm_report_object o; |
| |
| if($cast(o,obj)) begin |
| uvm_queue#(uvm_callback) qr; |
| void'(uvm_callbacks#(uvm_report_object, uvm_callback)::get()); |
| qr = uvm_callbacks#(uvm_report_object,uvm_callback)::m_t_inst.m_tw_cb_q; |
| for(int i=0; i<qr.size(); ++i) |
| q.push_back(qr.get(i)); |
| end |
| |
| for(int i=0; i<m_t_inst.m_tw_cb_q.size(); ++i) |
| q.push_back(m_t_inst.m_tw_cb_q.get(i)); |
| end |
| |
| //check if already exists in the queue |
| if(m_cb_find(q,cb) != -1) begin |
| uvm_report_warning("CBPREG", { "Callback object ", cb.get_name(), " is already registered", |
| " with object ", obj.get_full_name() }, UVM_NONE); |
| end |
| else begin |
| void'(m_cb_find_name(q, cb.get_name(), {"object instance ", obj.get_full_name()})); |
| if(ordering == UVM_APPEND) |
| q.push_back(cb); |
| else |
| q.push_front(cb); |
| end |
| end |
| endfunction |
| |
| // Function: add_by_name |
| // |
| // Registers the given callback object, ~cb~, with one or more uvm_components. |
| // The components must already exist and must be type T or a derivative. As |
| // with <add> the CB parameter is optional. ~root~ specifies the location in |
| // the component hierarchy to start the search for ~name~. See <uvm_root::find_all> |
| // for more details on searching by name. |
| |
| static function void add_by_name(string name, |
| uvm_callback cb, |
| uvm_component root, |
| uvm_apprepend ordering=UVM_APPEND); |
| uvm_component cq[$]; |
| uvm_root top; |
| uvm_coreservice_t cs; |
| T t; |
| void'(get()); |
| cs = uvm_coreservice_t::get(); |
| top = cs.get_root(); |
| |
| if(cb==null) begin |
| uvm_report_error("CBUNREG", { "Null callback object cannot be registered with object(s) ", |
| name }, UVM_NONE); |
| return; |
| end |
| `uvm_cb_trace_noobj(cb,$sformatf("Add (%s) callback %0s by name to object(s) %0s ", |
| ordering.name(), cb.get_name(), name)) |
| top.find_all(name,cq,root); |
| if(cq.size() == 0) begin |
| uvm_report_warning("CBNOMTC", { "add_by_name failed to find any components matching the name ", |
| name, ", callback ", cb.get_name(), " will not be registered." }, UVM_NONE); |
| end |
| foreach(cq[i]) begin |
| if($cast(t,cq[i])) begin |
| add(t,cb,ordering); |
| end |
| end |
| endfunction |
| |
| |
| // Function: delete |
| // |
| // Deletes the given callback object, ~cb~, from the queue associated with |
| // the given ~obj~ handle. The ~obj~ handle can be ~null~, which allows |
| // de-registration of callbacks without an object context. |
| // The ~cb~ is the callback handle; it must be non-~null~, and if the callback |
| // has already been removed from the object instance then a warning is |
| // issued. Note that the CB parameter is optional. For example, the |
| // following are equivalent: |
| // |
| //| uvm_callbacks#(my_comp)::delete(comp_a, cb); |
| //| uvm_callbacks#(my_comp, my_callback)::delete(comp_a,cb); |
| |
| static function void delete(T obj, uvm_callback cb); |
| uvm_object b_obj = obj; |
| uvm_queue#(uvm_callback) q; |
| bit found; |
| int pos; |
| void'(get()); |
| |
| if(obj == null) begin |
| `uvm_cb_trace_noobj(cb,$sformatf("Delete typewide callback %0s for type %s", |
| cb.get_name(), m_base_inst.m_typename)) |
| found = m_t_inst.m_delete_tw_cbs(cb); |
| end |
| else begin |
| `uvm_cb_trace_noobj(cb,$sformatf("Delete callback %0s from object %0s ", |
| cb.get_name(), obj.get_full_name())) |
| q = m_base_inst.m_pool.get(b_obj); |
| pos = m_cb_find(q,cb); |
| if(pos != -1) begin |
| q.delete(pos); |
| found = 1; |
| end |
| end |
| if(!found) begin |
| string nm; |
| if(obj==null) nm = "(*)"; else nm = obj.get_full_name(); |
| uvm_report_warning("CBUNREG", { "Callback ", cb.get_name(), " cannot be removed from object ", |
| nm, " because it is not currently registered to that object." }, UVM_NONE); |
| end |
| endfunction |
| |
| |
| // Function: delete_by_name |
| // |
| // Removes the given callback object, ~cb~, associated with one or more |
| // uvm_component callback queues. As with <delete> the CB parameter is |
| // optional. ~root~ specifies the location in the component hierarchy to start |
| // the search for ~name~. See <uvm_root::find_all> for more details on searching |
| // by name. |
| |
| static function void delete_by_name(string name, uvm_callback cb, |
| uvm_component root); |
| uvm_component cq[$]; |
| uvm_root top; |
| T t; |
| uvm_coreservice_t cs; |
| void'(get()); |
| cs = uvm_coreservice_t::get(); |
| top = cs.get_root(); |
| |
| `uvm_cb_trace_noobj(cb,$sformatf("Delete callback %0s by name from object(s) %0s ", |
| cb.get_name(), name)) |
| top.find_all(name,cq,root); |
| if(cq.size() == 0) begin |
| uvm_report_warning("CBNOMTC", { "delete_by_name failed to find any components matching the name ", |
| name, ", callback ", cb.get_name(), " will not be unregistered." }, UVM_NONE); |
| end |
| foreach(cq[i]) begin |
| if($cast(t,cq[i])) begin |
| delete(t,cb); |
| end |
| end |
| endfunction |
| |
| |
| //-------------------------- |
| // Group: Iterator Interface |
| //-------------------------- |
| // |
| // This set of functions provide an iterator interface for callback queues. A facade |
| // class, <uvm_callback_iter> is also available, and is the generally preferred way to |
| // iterate over callback queues. |
| |
| static function void m_get_q (ref uvm_queue #(uvm_callback) q, input T obj); |
| if(!m_base_inst.m_pool.exists(obj)) begin //no instance specific |
| q = (obj == null) ? m_t_inst.m_tw_cb_q : m_t_inst.m_get_tw_cb_q(obj); |
| end |
| else begin |
| q = m_base_inst.m_pool.get(obj); |
| if(q==null) begin |
| q=new; |
| m_base_inst.m_pool.add(obj,q); |
| end |
| end |
| endfunction |
| |
| |
| // Function: get_first |
| // |
| // Returns the first enabled callback of type CB which resides in the queue for ~obj~. |
| // If ~obj~ is ~null~ then the typewide queue for T is searched. ~itr~ is the iterator; |
| // it will be updated with a value that can be supplied to <get_next> to get the next |
| // callback object. |
| // |
| // If the queue is empty then ~null~ is returned. |
| // |
| // The iterator class <uvm_callback_iter> may be used as an alternative, simplified, |
| // iterator interface. |
| |
| static function CB get_first (ref int itr, input T obj); |
| uvm_queue#(uvm_callback) q; |
| CB cb; |
| void'(get()); |
| m_get_q(q,obj); |
| for(itr = 0; itr<q.size(); ++itr) |
| if($cast(cb, q.get(itr)) && cb.callback_mode()) |
| return cb; |
| return null; |
| endfunction |
| |
| // Function: get_last |
| // |
| // Returns the last enabled callback of type CB which resides in the queue for ~obj~. |
| // If ~obj~ is ~null~ then the typewide queue for T is searched. ~itr~ is the iterator; |
| // it will be updated with a value that can be supplied to <get_prev> to get the previous |
| // callback object. |
| // |
| // If the queue is empty then ~null~ is returned. |
| // |
| // The iterator class <uvm_callback_iter> may be used as an alternative, simplified, |
| // iterator interface. |
| |
| static function CB get_last (ref int itr, input T obj); |
| uvm_queue#(uvm_callback) q; |
| CB cb; |
| void'(get()); |
| m_get_q(q,obj); |
| for(itr = q.size()-1; itr>=0; --itr) |
| if ($cast(cb, q.get(itr)) && cb.callback_mode()) |
| return cb; |
| return null; |
| endfunction |
| |
| |
| // Function: get_next |
| // |
| // Returns the next enabled callback of type CB which resides in the queue for ~obj~, |
| // using ~itr~ as the starting point. If ~obj~ is ~null~ then the typewide queue for T |
| // is searched. ~itr~ is the iterator; it will be updated with a value that can be |
| // supplied to <get_next> to get the next callback object. |
| // |
| // If no more callbacks exist in the queue, then ~null~ is returned. <get_next> will |
| // continue to return ~null~ in this case until <get_first> or <get_last> has been used to reset |
| // the iterator. |
| // |
| // The iterator class <uvm_callback_iter> may be used as an alternative, simplified, |
| // iterator interface. |
| |
| static function CB get_next (ref int itr, input T obj); |
| uvm_queue#(uvm_callback) q; |
| CB cb; |
| void'(get()); |
| m_get_q(q,obj); |
| for(itr = itr+1; itr<q.size(); ++itr) |
| if ($cast(cb, q.get(itr)) && cb.callback_mode()) |
| return cb; |
| return null; |
| endfunction |
| |
| |
| // Function: get_prev |
| // |
| // Returns the previous enabled callback of type CB which resides in the queue for ~obj~, |
| // using ~itr~ as the starting point. If ~obj~ is ~null~ then the typewide queue for T |
| // is searched. ~itr~ is the iterator; it will be updated with a value that can be |
| // supplied to <get_prev> to get the previous callback object. |
| // |
| // If no more callbacks exist in the queue, then ~null~ is returned. <get_prev> will |
| // continue to return ~null~ in this case until <get_first> or <get_last> has been used to reset |
| // the iterator. |
| // |
| // The iterator class <uvm_callback_iter> may be used as an alternative, simplified, |
| // iterator interface. |
| |
| static function CB get_prev (ref int itr, input T obj); |
| uvm_queue#(uvm_callback) q; |
| CB cb; |
| void'(get()); |
| m_get_q(q,obj); |
| for(itr = itr-1; itr>= 0; --itr) |
| if($cast(cb, q.get(itr)) && cb.callback_mode()) |
| return cb; |
| return null; |
| endfunction |
| |
| |
| //------------- |
| // Group: Debug |
| //------------- |
| |
| // Function: display |
| // |
| // This function displays callback information for ~obj~. If ~obj~ is |
| // ~null~, then it displays callback information for all objects |
| // of type ~T~, including typewide callbacks. |
| |
| static function void display(T obj=null); |
| // For documentation purposes, need a function wrapper here. |
| void'(get()); |
| super_type::display(obj); |
| endfunction |
| |
| endclass |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Class- uvm_derived_callbacks #(T,ST,CB) |
| // |
| //------------------------------------------------------------------------------ |
| // This type is not really expected to be used directly by the user, instead they are |
| // expected to use the macro `uvm_set_super_type. The sole purpose of this type is to |
| // allow for setting up of the derived_type/super_type mapping. |
| //------------------------------------------------------------------------------ |
| |
| class uvm_derived_callbacks#(type T=uvm_object, type ST=uvm_object, type CB=uvm_callback) |
| extends uvm_callbacks#(T,CB); |
| |
| typedef uvm_derived_callbacks#(T,ST,CB) this_type; |
| typedef uvm_callbacks#(T) this_user_type; |
| typedef uvm_callbacks#(ST) this_super_type; |
| |
| // Singleton instance is used for type checking |
| static this_type m_d_inst; |
| static this_user_type m_user_inst; |
| static this_super_type m_super_inst; |
| |
| // typeinfo |
| static uvm_typeid_base m_s_typeid; |
| |
| static function this_type get(); |
| m_user_inst = this_user_type::get(); |
| m_super_inst = this_super_type::get(); |
| m_s_typeid = uvm_typeid#(ST)::get(); |
| if(m_d_inst == null) begin |
| m_d_inst = new; |
| end |
| return m_d_inst; |
| endfunction |
| |
| static function bit register_super_type(string tname="", sname=""); |
| this_user_type u_inst = this_user_type::get(); |
| this_type inst = this_type::get(); |
| uvm_callbacks_base s_obj; |
| |
| this_user_type::m_t_inst.m_typename = tname; |
| |
| if(sname != "") m_s_typeid.typename = sname; |
| |
| if(u_inst.m_super_type != null) begin |
| if(u_inst.m_super_type == m_s_typeid) return 1; |
| uvm_report_warning("CBTPREG", { "Type ", tname, " is already registered to super type ", |
| this_super_type::m_t_inst.m_typename, ". Ignoring attempt to register to super type ", |
| sname}, UVM_NONE); |
| return 1; |
| end |
| if(this_super_type::m_t_inst.m_typename == "") |
| this_super_type::m_t_inst.m_typename = sname; |
| u_inst.m_super_type = m_s_typeid; |
| u_inst.m_base_inst.m_super_type = m_s_typeid; |
| s_obj = uvm_typeid_base::typeid_map[m_s_typeid]; |
| s_obj.m_derived_types.push_back(m_typeid); |
| return 1; |
| endfunction |
| |
| endclass |
| |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_callback_iter |
| // |
| //------------------------------------------------------------------------------ |
| // The ~uvm_callback_iter~ class is an iterator class for iterating over |
| // callback queues of a specific callback type. The typical usage of |
| // the class is: |
| // |
| //| uvm_callback_iter#(mycomp,mycb) iter = new(this); |
| //| for(mycb cb = iter.first(); cb != null; cb = iter.next()) |
| //| cb.dosomething(); |
| // |
| // The callback iteration macros, <`uvm_do_callbacks> and |
| // <`uvm_do_callbacks_exit_on> provide a simple method for iterating |
| // callbacks and executing the callback methods. |
| //------------------------------------------------------------------------------ |
| |
| class uvm_callback_iter#(type T = uvm_object, type CB = uvm_callback); |
| |
| local int m_i; |
| local T m_obj; |
| local CB m_cb; |
| |
| // Function: new |
| // |
| // Creates a new callback iterator object. It is required that the object |
| // context be provided. |
| |
| function new(T obj); |
| m_obj = obj; |
| endfunction |
| |
| // Function: first |
| // |
| // Returns the first valid (enabled) callback of the callback type (or |
| // a derivative) that is in the queue of the context object. If the |
| // queue is empty then ~null~ is returned. |
| |
| function CB first(); |
| m_cb = uvm_callbacks#(T,CB)::get_first(m_i, m_obj); |
| return m_cb; |
| endfunction |
| |
| // Function: last |
| // |
| // Returns the last valid (enabled) callback of the callback type (or |
| // a derivative) that is in the queue of the context object. If the |
| // queue is empty then ~null~ is returned. |
| |
| function CB last(); |
| m_cb = uvm_callbacks#(T,CB)::get_last(m_i, m_obj); |
| return m_cb; |
| endfunction |
| |
| // Function: next |
| // |
| // Returns the next valid (enabled) callback of the callback type (or |
| // a derivative) that is in the queue of the context object. If there |
| // are no more valid callbacks in the queue, then ~null~ is returned. |
| |
| function CB next(); |
| m_cb = uvm_callbacks#(T,CB)::get_next(m_i, m_obj); |
| return m_cb; |
| endfunction |
| |
| // Function: prev |
| // |
| // Returns the previous valid (enabled) callback of the callback type (or |
| // a derivative) that is in the queue of the context object. If there |
| // are no more valid callbacks in the queue, then ~null~ is returned. |
| |
| function CB prev(); |
| m_cb = uvm_callbacks#(T,CB)::get_prev(m_i, m_obj); |
| return m_cb; |
| endfunction |
| |
| // Function: get_cb |
| // |
| // Returns the last callback accessed via a first() or next() |
| // call. |
| |
| function CB get_cb(); |
| return m_cb; |
| endfunction |
| |
| /**** |
| function void trace(uvm_object obj = null); |
| if (m_cb != null && T::cbs::get_debug_flags() & UVM_CALLBACK_TRACE) begin |
| uvm_report_object reporter = null; |
| string who = "Executing "; |
| void'($cast(reporter, obj)); |
| if (reporter == null) void'($cast(reporter, m_obj)); |
| if (reporter == null) reporter = uvm_top; |
| if (obj != null) who = {obj.get_full_name(), " is executing "}; |
| else if (m_obj != null) who = {m_obj.get_full_name(), " is executing "}; |
| reporter.uvm_report_info("CLLBK_TRC", {who, "callback ", m_cb.get_name()}, UVM_LOW); |
| end |
| endfunction |
| ****/ |
| endclass |
| |
| |
| |
| //------------------------------------------------------------------------------ |
| // CLASS: uvm_callback |
| // |
| // The ~uvm_callback~ class is the base class for user-defined callback classes. |
| // Typically, the component developer defines an application-specific callback |
| // class that extends from this class. In it, he defines one or more virtual |
| // methods, called a ~callback interface~, that represent the hooks available |
| // for user override. |
| // |
| // Methods intended for optional override should not be declared ~pure.~ Usually, |
| // all the callback methods are defined with empty implementations so users have |
| // the option of overriding any or all of them. |
| // |
| // The prototypes for each hook method are completely application specific with |
| // no restrictions. |
| //------------------------------------------------------------------------------ |
| |
| class uvm_callback extends uvm_object; |
| |
| static uvm_report_object reporter = new("cb_tracer"); |
| |
| protected bit m_enabled = 1; |
| |
| // Function: new |
| // |
| // Creates a new uvm_callback object, giving it an optional ~name~. |
| |
| function new(string name="uvm_callback"); |
| super.new(name); |
| endfunction |
| |
| |
| // Function: callback_mode |
| // |
| // Enable/disable callbacks (modeled like rand_mode and constraint_mode). |
| |
| function bit callback_mode(int on=-1); |
| if(on == 0 || on == 1) begin |
| `uvm_cb_trace_noobj(this,$sformatf("Setting callback mode for %s to %s", |
| get_name(), ((on==1) ? "ENABLED":"DISABLED"))) |
| end |
| else begin |
| `uvm_cb_trace_noobj(this,$sformatf("Callback mode for %s is %s", |
| get_name(), ((m_enabled==1) ? "ENABLED":"DISABLED"))) |
| end |
| callback_mode = m_enabled; |
| if(on==0) m_enabled=0; |
| if(on==1) m_enabled=1; |
| endfunction |
| |
| |
| // Function: is_enabled |
| // |
| // Returns 1 if the callback is enabled, 0 otherwise. |
| |
| function bit is_enabled(); |
| return callback_mode(); |
| endfunction |
| |
| static string type_name = "uvm_callback"; |
| |
| |
| // Function: get_type_name |
| // |
| // Returns the type name of this callback object. |
| |
| virtual function string get_type_name(); |
| return type_name; |
| endfunction |
| |
| endclass |
| |
| |
| `endif // UVM_CALLBACK_SVH |
| |
| |
