| // | |
| //------------------------------------------------------------------------------ | |
| // Copyright 2007-2011 Mentor Graphics Corporation | |
| // Copyright 2007-2011 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. | |
| //------------------------------------------------------------------------------ | |
| typedef class uvm_objection; | |
| typedef class uvm_sequence_base; | |
| typedef class uvm_sequence_item; | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_component | |
| // | |
| // The uvm_component class is the root base class for UVM components. In | |
| // addition to the features inherited from <uvm_object> and <uvm_report_object>, | |
| // uvm_component provides the following interfaces: | |
| // | |
| // Hierarchy - provides methods for searching and traversing the component | |
| // hierarchy. | |
| // | |
| // Phasing - defines a phased test flow that all components follow, with a | |
| // group of standard phase methods and an API for custom phases and | |
| // multiple independent phasing domains to mirror DUT behavior e.g. power | |
| // | |
| // Configuration - provides methods for configuring component topology and other | |
| // parameters ahead of and during component construction. | |
| // | |
| // Reporting - provides a convenience interface to the <uvm_report_handler>. All | |
| // messages, warnings, and errors are processed through this interface. | |
| // | |
| // Transaction recording - provides methods for recording the transactions | |
| // produced or consumed by the component to a transaction database (vendor | |
| // specific). | |
| // | |
| // Factory - provides a convenience interface to the <uvm_factory>. The factory | |
| // is used to create new components and other objects based on type-wide and | |
| // instance-specific configuration. | |
| // | |
| // The uvm_component is automatically seeded during construction using UVM | |
| // seeding, if enabled. All other objects must be manually reseeded, if | |
| // appropriate. See <uvm_object::reseed> for more information. | |
| // | |
| //------------------------------------------------------------------------------ | |
| virtual class uvm_component extends uvm_report_object; | |
| // Function: new | |
| // | |
| // Creates a new component with the given leaf instance ~name~ and handle to | |
| // to its ~parent~. If the component is a top-level component (i.e. it is | |
| // created in a static module or interface), ~parent~ should be null. | |
| // | |
| // The component will be inserted as a child of the ~parent~ object, if any. | |
| // If ~parent~ already has a child by the given ~name~, an error is produced. | |
| // | |
| // If ~parent~ is null, then the component will become a child of the | |
| // implicit top-level component, ~uvm_top~. | |
| // | |
| // All classes derived from uvm_component must call super.new(name,parent). | |
| extern function new (string name, uvm_component parent); | |
| //---------------------------------------------------------------------------- | |
| // Group: Hierarchy Interface | |
| //---------------------------------------------------------------------------- | |
| // | |
| // These methods provide user access to information about the component | |
| // hierarchy, i.e., topology. | |
| // | |
| //---------------------------------------------------------------------------- | |
| // Function: get_parent | |
| // | |
| // Returns a handle to this component's parent, or null if it has no parent. | |
| extern virtual function uvm_component get_parent (); | |
| // Function: get_full_name | |
| // | |
| // Returns the full hierarchical name of this object. The default | |
| // implementation concatenates the hierarchical name of the parent, if any, | |
| // with the leaf name of this object, as given by <uvm_object::get_name>. | |
| extern virtual function string get_full_name (); | |
| // Function: get_children | |
| // | |
| // This function populates the end of the ~children~ array with the | |
| // list of this component's children. | |
| // | |
| //| uvm_component array[$]; | |
| //| my_comp.get_children(array); | |
| //| foreach(array[i]) | |
| //| do_something(array[i]); | |
| extern function void get_children(ref uvm_component children[$]); | |
| // Function: get_child | |
| extern function uvm_component get_child (string name); | |
| // Function: get_next_child | |
| extern function int get_next_child (ref string name); | |
| // Function: get_first_child | |
| // | |
| // These methods are used to iterate through this component's children, if | |
| // any. For example, given a component with an object handle, ~comp~, the | |
| // following code calls <uvm_object::print> for each child: | |
| // | |
| //| string name; | |
| //| uvm_component child; | |
| //| if (comp.get_first_child(name)) | |
| //| do begin | |
| //| child = comp.get_child(name); | |
| //| child.print(); | |
| //| end while (comp.get_next_child(name)); | |
| extern function int get_first_child (ref string name); | |
| // Function: get_num_children | |
| // | |
| // Returns the number of this component's children. | |
| extern function int get_num_children (); | |
| // Function: has_child | |
| // | |
| // Returns 1 if this component has a child with the given ~name~, 0 otherwise. | |
| extern function int has_child (string name); | |
| // Function - set_name | |
| // | |
| // Renames this component to ~name~ and recalculates all descendants' | |
| // full names. This is an internal function for now. | |
| extern virtual function void set_name (string name); | |
| // Function: lookup | |
| // | |
| // Looks for a component with the given hierarchical ~name~ relative to this | |
| // component. If the given ~name~ is preceded with a '.' (dot), then the search | |
| // begins relative to the top level (absolute lookup). The handle of the | |
| // matching component is returned, else null. The name must not contain | |
| // wildcards. | |
| extern function uvm_component lookup (string name); | |
| // Function: get_depth | |
| // | |
| // Returns the component's depth from the root level. uvm_top has a | |
| // depth of 0. The test and any other top level components have a depth | |
| // of 1, and so on. | |
| extern function int unsigned get_depth(); | |
| //---------------------------------------------------------------------------- | |
| // Group: Phasing Interface | |
| //---------------------------------------------------------------------------- | |
| // | |
| // These methods implement an interface which allows all components to step | |
| // through a standard schedule of phases, or a customized schedule, and | |
| // also an API to allow independent phase domains which can jump like state | |
| // machines to reflect behavior e.g. power domains on the DUT in different | |
| // portions of the testbench. The phase tasks and functions are the phase | |
| // name with the _phase suffix. For example, the build phase function is | |
| // <build_phase>. | |
| // | |
| // All processes associated with a task-based phase are killed when the phase | |
| // ends. See <uvm_phase::execute> for more details. | |
| //---------------------------------------------------------------------------- | |
| // Function: build_phase | |
| // | |
| // The <uvm_build_phase> phase implementation method. | |
| // | |
| // Any override should call super.build_phase(phase) to execute the automatic | |
| // configuration of fields registed in the component by calling | |
| // <apply_config_settings>. | |
| // To turn off automatic configuration for a component, | |
| // do not call super.build_phase(phase). | |
| // | |
| // This method should never be called directly. | |
| extern virtual function void build_phase(uvm_phase phase); | |
| // For backward compatibility the base build_phase method calls build. | |
| extern virtual function void build(); | |
| // Function: connect_phase | |
| // | |
| // The <uvm_connect_phase> phase implementation method. | |
| // | |
| // This method should never be called directly. | |
| extern virtual function void connect_phase(uvm_phase phase); | |
| // For backward compatibility the base connect_phase method calls connect. | |
| extern virtual function void connect(); | |
| // Function: end_of_elaboration_phase | |
| // | |
| // The <uvm_end_of_elaboration_phase> phase implementation method. | |
| // | |
| // This method should never be called directly. | |
| extern virtual function void end_of_elaboration_phase(uvm_phase phase); | |
| // For backward compatibility the base end_of_elaboration_phase method calls end_of_elaboration. | |
| extern virtual function void end_of_elaboration(); | |
| // Function: start_of_simulation_phase | |
| // | |
| // The <uvm_start_of_simulation_phase> phase implementation method. | |
| // | |
| // This method should never be called directly. | |
| extern virtual function void start_of_simulation_phase(uvm_phase phase); | |
| // For backward compatibility the base start_of_simulation_phase method calls start_of_simulation. | |
| extern virtual function void start_of_simulation(); | |
| // Task: run_phase | |
| // | |
| // The <uvm_run_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // Thn the phase will automatically | |
| // ends once all objections are dropped using ~phase.drop_objection()~. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // The run_phase task should never be called directly. | |
| extern virtual task run_phase(uvm_phase phase); | |
| // For backward compatibility the base run_phase method calls run. | |
| extern virtual task run(); | |
| // Task: pre_reset_phase | |
| // | |
| // The <uvm_pre_reset_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task pre_reset_phase(uvm_phase phase); | |
| // Task: reset_phase | |
| // | |
| // The <uvm_reset_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task reset_phase(uvm_phase phase); | |
| // Task: post_reset_phase | |
| // | |
| // The <uvm_post_reset_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task post_reset_phase(uvm_phase phase); | |
| // Task: pre_configure_phase | |
| // | |
| // The <uvm_pre_configure_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task pre_configure_phase(uvm_phase phase); | |
| // Task: configure_phase | |
| // | |
| // The <uvm_configure_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task configure_phase(uvm_phase phase); | |
| // Task: post_configure_phase | |
| // | |
| // The <uvm_post_configure_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task post_configure_phase(uvm_phase phase); | |
| // Task: pre_main_phase | |
| // | |
| // The <uvm_pre_main_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task pre_main_phase(uvm_phase phase); | |
| // Task: main_phase | |
| // | |
| // The <uvm_main_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task main_phase(uvm_phase phase); | |
| // Task: post_main_phase | |
| // | |
| // The <uvm_post_main_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task post_main_phase(uvm_phase phase); | |
| // Task: pre_shutdown_phase | |
| // | |
| // The <uvm_pre_shutdown_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task pre_shutdown_phase(uvm_phase phase); | |
| // Task: shutdown_phase | |
| // | |
| // The <uvm_shutdown_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task shutdown_phase(uvm_phase phase); | |
| // Task: post_shutdown_phase | |
| // | |
| // The <uvm_post_shutdown_phase> phase implementation method. | |
| // | |
| // This task returning or not does not indicate the end | |
| // or persistence of this phase. | |
| // It is necessary to raise an objection | |
| // using ~phase.raise_objection()~ to cause the phase to persist. | |
| // Once all components have dropped their respective objection | |
| // using ~phase.drop_objection()~, or if no components raises an | |
| // objection, the phase is ended. | |
| // | |
| // Any processes forked by this task continue to run | |
| // after the task returns, | |
| // but they will be killed once the phase ends. | |
| // | |
| // This method should not be called directly. | |
| extern virtual task post_shutdown_phase(uvm_phase phase); | |
| // Function: extract_phase | |
| // | |
| // The <uvm_extract_phase> phase implementation method. | |
| // | |
| // This method should never be called directly. | |
| extern virtual function void extract_phase(uvm_phase phase); | |
| // For backward compatibility the base extract_phase method calls extract. | |
| extern virtual function void extract(); | |
| // Function: check_phase | |
| // | |
| // The <uvm_check_phase> phase implementation method. | |
| // | |
| // This method should never be called directly. | |
| extern virtual function void check_phase(uvm_phase phase); | |
| // For backward compatibility the base check_phase method calls check. | |
| extern virtual function void check(); | |
| // Function: report_phase | |
| // | |
| // The <uvm_report_phase> phase implementation method. | |
| // | |
| // This method should never be called directly. | |
| extern virtual function void report_phase(uvm_phase phase); | |
| // For backward compatibility the base report_phase method calls report. | |
| extern virtual function void report(); | |
| // Function: final_phase | |
| // | |
| // The <uvm_final_phase> phase implementation method. | |
| // | |
| // This method should never be called directly. | |
| extern virtual function void final_phase(uvm_phase phase); | |
| // Function: phase_started | |
| // | |
| // Invoked at the start of each phase. The ~phase~ argument specifies | |
| // the phase being started. Any threads spawned in this callback are | |
| // not affected when the phase ends. | |
| extern virtual function void phase_started (uvm_phase phase); | |
| // Function: phase_ready_to_end | |
| // | |
| // Invoked when all objections to ending the given ~phase~ and all | |
| // sibling phases have been dropped, thus indicating that ~phase~ is | |
| // ready to begin a clean exit. Sibling phases are any phases that | |
| // have a common successor phase in the schedule plus any phases that | |
| // sync'd to the current phase. Components needing to consume delta | |
| // cycles or advance time to perform a clean exit from the phase | |
| // may raise the phase's objection. | |
| // | |
| // |phase.raise_objection(this,"Reason"); | |
| // | |
| // It is the responsibility of this component to drop the objection | |
| // once it is ready for this phase to end (and processes killed). | |
| // If no objection to the given ~phase~ or sibling phases are raised, | |
| // then phase_ended() is called after a delta cycle. If any objection | |
| // is raised, then when all objections to ending the given ~phase~ | |
| // and siblings are dropped, another iteration of phase_ready_to_end | |
| // is called. To prevent endless iterations due to coding error, | |
| // after 20 iterations, phase_ended() is called regardless of whether | |
| // previous iteration had any objections raised. | |
| extern virtual function void phase_ready_to_end (uvm_phase phase); | |
| // Function: phase_ended | |
| // | |
| // Invoked at the end of each phase. The ~phase~ argument specifies | |
| // the phase that is ending. Any threads spawned in this callback are | |
| // not affected when the phase ends. | |
| extern virtual function void phase_ended (uvm_phase phase); | |
| //-------------------------------------------------------------------- | |
| // phase / schedule / domain API | |
| //-------------------------------------------------------------------- | |
| // Function: set_domain | |
| // | |
| // Apply a phase domain to this component and, if ~hier~ is set, | |
| // recursively to all its children. | |
| // | |
| // Calls the virtual <define_domain> method, which derived components can | |
| // override to augment or replace the domain definition of ita base class. | |
| // | |
| extern function void set_domain(uvm_domain domain, int hier=1); | |
| // Function: get_domain | |
| // | |
| // Return handle to the phase domain set on this component | |
| extern function uvm_domain get_domain(); | |
| // Function: define_domain | |
| // | |
| // Builds custom phase schedules into the provided ~domain~ handle. | |
| // | |
| // This method is called by <set_domain>, which integrators use to specify | |
| // this component belongs in a domain apart from the default 'uvm' domain. | |
| // | |
| // Custom component base classes requiring a custom phasing schedule can | |
| // augment or replace the domain definition they inherit by overriding | |
| // <defined_domain>. To augment, overrides would call super.define_domain(). | |
| // To replace, overrides would not call super.define_domain(). | |
| // | |
| // The default implementation adds a copy of the ~uvm~ phasing schedule to | |
| // the given ~domain~, if one doesn't already exist, and only if the domain | |
| // is currently empty. | |
| // | |
| // Calling <set_domain> | |
| // with the default ~uvm~ domain (see <uvm_domain::get_uvm_domain>) on | |
| // a component with no ~define_domain~ override effectively reverts the | |
| // that component to using the default ~uvm~ domain. This may be useful | |
| // if a branch of the testbench hierarchy defines a custom domain, but | |
| // some child sub-branch should remain in the default ~uvm~ domain, | |
| // call <set_domain> with a new domain instance handle with ~hier~ set. | |
| // Then, in the sub-branch, call <set_domain> with the default ~uvm~ domain handle, | |
| // obtained via <uvm_domain::get_uvm_domain()>. | |
| // | |
| // Alternatively, the integrator may define the graph in a new domain externally, | |
| // then call <set_domain> to apply it to a component. | |
| extern virtual protected function void define_domain(uvm_domain domain); | |
| // Function: set_phase_imp | |
| // | |
| // Override the default implementation for a phase on this component (tree) with a | |
| // custom one, which must be created as a singleton object extending the default | |
| // one and implementing required behavior in exec and traverse methods | |
| // | |
| // The ~hier~ specifies whether to apply the custom functor to the whole tree or | |
| // just this component. | |
| extern function void set_phase_imp(uvm_phase phase, uvm_phase imp, int hier=1); | |
| // Task: suspend | |
| // | |
| // Suspend this component. | |
| // | |
| // This method must be implemented by the user to suspend the | |
| // component according to the protocol and functionality it implements. | |
| // A suspended component can be subsequently resumed using <resume()>. | |
| extern virtual task suspend (); | |
| // Task: resume | |
| // | |
| // Resume this component. | |
| // | |
| // This method must be implemented by the user to resume a component | |
| // that was previously suspended using <suspend()>. | |
| // Some component may start in the suspended state and | |
| // may need to be explicitly resumed. | |
| extern virtual task resume (); | |
| `ifndef UVM_NO_DEPRECATED | |
| // Function- status - DEPRECATED | |
| // | |
| // Returns the status of this component. | |
| // | |
| // Returns a string that describes the current status of the | |
| // components. Possible values include, but are not limited to | |
| // | |
| // "<unknown>" - Status is unknown (default) | |
| // "FINISHED" - Component has stopped on its own accord. May be resumed. | |
| // "RUNNING" - Component is running. | |
| // May be suspended after normal completion | |
| // of operation in progress. | |
| // "WAITING" - Component is waiting. May be suspended immediately. | |
| // "SUSPENDED" - Component is suspended. May be resumed. | |
| // "KILLED" - Component has been killed and is unable to operate | |
| // any further. It cannot be resumed. | |
| extern function string status (); | |
| // Function- kill - DEPRECATED | |
| // | |
| // Kills the process tree associated with this component's currently running | |
| // task-based phase, e.g., run. | |
| extern virtual function void kill (); | |
| // Function- do_kill_all - DEPRECATED | |
| // | |
| // Recursively calls <kill> on this component and all its descendants, | |
| // which abruptly ends the currently running task-based phase, e.g., run. | |
| // See <run_phase> for better options to ending a task-based phase. | |
| extern virtual function void do_kill_all (); | |
| // Task- stop_phase -- DEPRECATED | |
| // | |
| // The stop_phase task is called when this component's <enable_stop_interrupt> | |
| // bit is set and <global_stop_request> is called during a task-based phase, | |
| // e.g., run. | |
| // | |
| // Before a phase is abruptly ended, e.g., when a test deems the simulation | |
| // complete, some components may need extra time to shut down cleanly. Such | |
| // components may implement stop_phase to finish the currently executing | |
| // transaction, flush the queue, or perform other cleanup. Upon return from | |
| // stop_phase, a component signals it is ready to be stopped. | |
| // | |
| // The ~stop_phase~ method will not be called if <enable_stop_interrupt> is 0. | |
| // | |
| // The default implementation is empty, i.e., it will return immediately. | |
| // | |
| // This method should never be called directly. | |
| extern virtual task stop_phase(uvm_phase phase); | |
| // backward compat | |
| extern virtual task stop (string ph_name); | |
| // Variable- enable_stop_interrupt - DEPRECATED | |
| // | |
| // This bit allows a component to raise an objection to the stopping of the | |
| // current phase. It affects only time consuming phases (such as the run | |
| // phase). | |
| // | |
| // When this bit is set, the <stop> task in the component is called as a result | |
| // of a call to <global_stop_request>. Components that are sensitive to an | |
| // immediate killing of its run-time processes should set this bit and | |
| // implement the stop task to prepare for shutdown. | |
| int enable_stop_interrupt; | |
| `endif | |
| // Function: resolve_bindings | |
| // | |
| // Processes all port, export, and imp connections. Checks whether each port's | |
| // min and max connection requirements are met. | |
| // | |
| // It is called just before the end_of_elaboration phase. | |
| // | |
| // Users should not call directly. | |
| extern virtual function void resolve_bindings (); | |
| //---------------------------------------------------------------------------- | |
| // Group: Configuration Interface | |
| //---------------------------------------------------------------------------- | |
| // | |
| // Components can be designed to be user-configurable in terms of its | |
| // topology (the type and number of children it has), mode of operation, and | |
| // run-time parameters (knobs). The configuration interface accommodates | |
| // this common need, allowing component composition and state to be modified | |
| // without having to derive new classes or new class hierarchies for | |
| // every configuration scenario. | |
| // | |
| //---------------------------------------------------------------------------- | |
| // Used for caching config settings | |
| static bit m_config_set = 1; | |
| extern function string massage_scope(string scope); | |
| // Function: set_config_int | |
| extern virtual function void set_config_int (string inst_name, | |
| string field_name, | |
| uvm_bitstream_t value); | |
| // Function: set_config_string | |
| extern virtual function void set_config_string (string inst_name, | |
| string field_name, | |
| string value); | |
| // Function: set_config_object | |
| // | |
| // Calling set_config_* causes configuration settings to be created and | |
| // placed in a table internal to this component. There are similar global | |
| // methods that store settings in a global table. Each setting stores the | |
| // supplied ~inst_name~, ~field_name~, and ~value~ for later use by descendent | |
| // components during their construction. (The global table applies to | |
| // all components and takes precedence over the component tables.) | |
| // | |
| // When a descendant component calls a get_config_* method, the ~inst_name~ | |
| // and ~field_name~ provided in the get call are matched against all the | |
| // configuration settings stored in the global table and then in each | |
| // component in the parent hierarchy, top-down. Upon the first match, the | |
| // value stored in the configuration setting is returned. Thus, precedence is | |
| // global, following by the top-level component, and so on down to the | |
| // descendent component's parent. | |
| // | |
| // These methods work in conjunction with the get_config_* methods to | |
| // provide a configuration setting mechanism for integral, string, and | |
| // uvm_object-based types. Settings of other types, such as virtual interfaces | |
| // and arrays, can be indirectly supported by defining a class that contains | |
| // them. | |
| // | |
| // Both ~inst_name~ and ~field_name~ may contain wildcards. | |
| // | |
| // - For set_config_int, ~value~ is an integral value that can be anything | |
| // from 1 bit to 4096 bits. | |
| // | |
| // - For set_config_string, ~value~ is a string. | |
| // | |
| // - For set_config_object, ~value~ must be an <uvm_object>-based object or | |
| // null. Its clone argument specifies whether the object should be cloned. | |
| // If set, the object is cloned both going into the table (during the set) | |
| // and coming out of the table (during the get), so that multiple components | |
| // matched to the same setting (by way of wildcards) do not end up sharing | |
| // the same object. | |
| // | |
| // | |
| // See <get_config_int>, <get_config_string>, and <get_config_object> for | |
| // information on getting the configurations set by these methods. | |
| extern virtual function void set_config_object (string inst_name, | |
| string field_name, | |
| uvm_object value, | |
| bit clone=1); | |
| // Function: get_config_int | |
| extern virtual function bit get_config_int (string field_name, | |
| inout uvm_bitstream_t value); | |
| // Function: get_config_string | |
| extern virtual function bit get_config_string (string field_name, | |
| inout string value); | |
| // Function: get_config_object | |
| // | |
| // These methods retrieve configuration settings made by previous calls to | |
| // their set_config_* counterparts. As the methods' names suggest, there is | |
| // direct support for integral types, strings, and objects. Settings of other | |
| // types can be indirectly supported by defining an object to contain them. | |
| // | |
| // Configuration settings are stored in a global table and in each component | |
| // instance. With each call to a get_config_* method, a top-down search is | |
| // made for a setting that matches this component's full name and the given | |
| // ~field_name~. For example, say this component's full instance name is | |
| // top.u1.u2. First, the global configuration table is searched. If that | |
| // fails, then it searches the configuration table in component 'top', | |
| // followed by top.u1. | |
| // | |
| // The first instance/field that matches causes ~value~ to be written with the | |
| // value of the configuration setting and 1 is returned. If no match | |
| // is found, then ~value~ is unchanged and the 0 returned. | |
| // | |
| // Calling the get_config_object method requires special handling. Because | |
| // ~value~ is an output of type <uvm_object>, you must provide an uvm_object | |
| // handle to assign to (_not_ a derived class handle). After the call, you can | |
| // then $cast to the actual type. | |
| // | |
| // For example, the following code illustrates how a component designer might | |
| // call upon the configuration mechanism to assign its ~data~ object property, | |
| // whose type myobj_t derives from uvm_object. | |
| // | |
| //| class mycomponent extends uvm_component; | |
| //| | |
| //| local myobj_t data; | |
| //| | |
| //| function void build_phase(uvm_phase phase); | |
| //| uvm_object tmp; | |
| //| super.build_phase(phase); | |
| //| if(get_config_object("data", tmp)) | |
| //| if (!$cast(data, tmp)) | |
| //| $display("error! config setting for 'data' not of type myobj_t"); | |
| //| endfunction | |
| //| ... | |
| // | |
| // The above example overrides the <build_phase> method. If you want to retain | |
| // any base functionality, you must call super.build_phase(uvm_phase phase). | |
| // | |
| // The ~clone~ bit clones the data inbound. The get_config_object method can | |
| // also clone the data outbound. | |
| // | |
| // See Members for information on setting the global configuration table. | |
| extern virtual function bit get_config_object (string field_name, | |
| inout uvm_object value, | |
| input bit clone=1); | |
| // Function: check_config_usage | |
| // | |
| // Check all configuration settings in a components configuration table | |
| // to determine if the setting has been used, overridden or not used. | |
| // When ~recurse~ is 1 (default), configuration for this and all child | |
| // components are recursively checked. This function is automatically | |
| // called in the check phase, but can be manually called at any time. | |
| // | |
| // To get all configuration information prior to the run phase, do something | |
| // like this in your top object: | |
| //| function void start_of_simulation_phase(uvm_phase phase); | |
| //| check_config_usage(); | |
| //| endfunction | |
| extern function void check_config_usage (bit recurse=1); | |
| // Function: apply_config_settings | |
| // | |
| // Searches for all config settings matching this component's instance path. | |
| // For each match, the appropriate set_*_local method is called using the | |
| // matching config setting's field_name and value. Provided the set_*_local | |
| // method is implemented, the component property associated with the | |
| // field_name is assigned the given value. | |
| // | |
| // This function is called by <uvm_component::build_phase>. | |
| // | |
| // The apply_config_settings method determines all the configuration | |
| // settings targeting this component and calls the appropriate set_*_local | |
| // method to set each one. To work, you must override one or more set_*_local | |
| // methods to accommodate setting of your component's specific properties. | |
| // Any properties registered with the optional `uvm_*_field macros do not | |
| // require special handling by the set_*_local methods; the macros provide | |
| // the set_*_local functionality for you. | |
| // | |
| // If you do not want apply_config_settings to be called for a component, | |
| // then the build_phase() method should be overloaded and you should not call | |
| // super.build_phase(phase). Likewise, apply_config_settings can be overloaded to | |
| // customize automated configuration. | |
| // | |
| // When the ~verbose~ bit is set, all overrides are printed as they are | |
| // applied. If the component's <print_config_matches> property is set, then | |
| // apply_config_settings is automatically called with ~verbose~ = 1. | |
| extern virtual function void apply_config_settings (bit verbose=0); | |
| // Function: print_config_settings | |
| // | |
| // Called without arguments, print_config_settings prints all configuration | |
| // information for this component, as set by previous calls to set_config_*. | |
| // The settings are printing in the order of their precedence. | |
| // | |
| // If ~field~ is specified and non-empty, then only configuration settings | |
| // matching that field, if any, are printed. The field may not contain | |
| // wildcards. | |
| // | |
| // If ~comp~ is specified and non-null, then the configuration for that | |
| // component is printed. | |
| // | |
| // If ~recurse~ is set, then configuration information for all ~comp~'s | |
| // children and below are printed as well. | |
| // | |
| // This function has been deprecated. Use print_config instead. | |
| extern function void print_config_settings (string field="", | |
| uvm_component comp=null, | |
| bit recurse=0); | |
| // Function: print_config | |
| // | |
| // Print_config_settings prints all configuration information for this | |
| // component, as set by previous calls to set_config_* and exports to | |
| // the resources pool. The settings are printing in the order of | |
| // their precedence. | |
| // | |
| // If ~recurse~ is set, then configuration information for all | |
| // children and below are printed as well. | |
| // | |
| // if ~audit~ is set then the audit trail for each resource is printed | |
| // along with the resource name and value | |
| extern function void print_config(bit recurse = 0, bit audit = 0); | |
| // Function: print_config_with_audit | |
| // | |
| // Operates the same as print_config except that the audit bit is | |
| // forced to 1. This interface makes user code a bit more readable as | |
| // it avoids multiple arbitrary bit settings in the argument list. | |
| // | |
| // If ~recurse~ is set, then configuration information for all | |
| // children and below are printed as well. | |
| extern function void print_config_with_audit(bit recurse = 0); | |
| // Variable: print_config_matches | |
| // | |
| // Setting this static variable causes get_config_* to print info about | |
| // matching configuration settings as they are being applied. | |
| static bit print_config_matches; | |
| //---------------------------------------------------------------------------- | |
| // Group: Objection Interface | |
| //---------------------------------------------------------------------------- | |
| // | |
| // These methods provide object level hooks into the <uvm_objection> | |
| // mechanism. | |
| // | |
| //---------------------------------------------------------------------------- | |
| // Function: raised | |
| // | |
| // The ~raised~ callback is called when this or a descendant of this component | |
| // instance raises the specfied ~objection~. The ~source_obj~ is the object | |
| // that originally raised the objection. | |
| // The ~description~ is optionally provided by the ~source_obj~ to give a | |
| // reason for raising the objection. The ~count~ indicates the number of | |
| // objections raised by the ~source_obj~. | |
| virtual function void raised (uvm_objection objection, uvm_object source_obj, | |
| string description, int count); | |
| endfunction | |
| // Function: dropped | |
| // | |
| // The ~dropped~ callback is called when this or a descendant of this component | |
| // instance drops the specfied ~objection~. The ~source_obj~ is the object | |
| // that originally dropped the objection. | |
| // The ~description~ is optionally provided by the ~source_obj~ to give a | |
| // reason for dropping the objection. The ~count~ indicates the number of | |
| // objections dropped by the the ~source_obj~. | |
| virtual function void dropped (uvm_objection objection, uvm_object source_obj, | |
| string description, int count); | |
| endfunction | |
| // Task: all_dropped | |
| // | |
| // The ~all_droppped~ callback is called when all objections have been | |
| // dropped by this component and all its descendants. The ~source_obj~ is the | |
| // object that dropped the last objection. | |
| // The ~description~ is optionally provided by the ~source_obj~ to give a | |
| // reason for raising the objection. The ~count~ indicates the number of | |
| // objections dropped by the the ~source_obj~. | |
| virtual task all_dropped (uvm_objection objection, uvm_object source_obj, | |
| string description, int count); | |
| endtask | |
| //---------------------------------------------------------------------------- | |
| // Group: Factory Interface | |
| //---------------------------------------------------------------------------- | |
| // | |
| // The factory interface provides convenient access to a portion of UVM's | |
| // <uvm_factory> interface. For creating new objects and components, the | |
| // preferred method of accessing the factory is via the object or component | |
| // wrapper (see <uvm_component_registry #(T,Tname)> and | |
| // <uvm_object_registry #(T,Tname)>). The wrapper also provides functions | |
| // for setting type and instance overrides. | |
| // | |
| //---------------------------------------------------------------------------- | |
| // Function: create_component | |
| // | |
| // A convenience function for <uvm_factory::create_component_by_name>, | |
| // this method calls upon the factory to create a new child component | |
| // whose type corresponds to the preregistered type name, ~requested_type_name~, | |
| // and instance name, ~name~. This method is equivalent to: | |
| // | |
| //| factory.create_component_by_name(requested_type_name, | |
| //| get_full_name(), name, this); | |
| // | |
| // If the factory determines that a type or instance override exists, the type | |
| // of the component created may be different than the requested type. See | |
| // <set_type_override> and <set_inst_override>. See also <uvm_factory> for | |
| // details on factory operation. | |
| extern function uvm_component create_component (string requested_type_name, | |
| string name); | |
| // Function: create_object | |
| // | |
| // A convenience function for <uvm_factory::create_object_by_name>, | |
| // this method calls upon the factory to create a new object | |
| // whose type corresponds to the preregistered type name, | |
| // ~requested_type_name~, and instance name, ~name~. This method is | |
| // equivalent to: | |
| // | |
| //| factory.create_object_by_name(requested_type_name, | |
| //| get_full_name(), name); | |
| // | |
| // If the factory determines that a type or instance override exists, the | |
| // type of the object created may be different than the requested type. See | |
| // <uvm_factory> for details on factory operation. | |
| extern function uvm_object create_object (string requested_type_name, | |
| string name=""); | |
| // Function: set_type_override_by_type | |
| // | |
| // A convenience function for <uvm_factory::set_type_override_by_type>, this | |
| // method registers a factory override for components and objects created at | |
| // this level of hierarchy or below. This method is equivalent to: | |
| // | |
| //| factory.set_type_override_by_type(original_type, override_type,replace); | |
| // | |
| // The ~relative_inst_path~ is relative to this component and may include | |
| // wildcards. The ~original_type~ represents the type that is being overridden. | |
| // In subsequent calls to <uvm_factory::create_object_by_type> or | |
| // <uvm_factory::create_component_by_type>, if the requested_type matches the | |
| // ~original_type~ and the instance paths match, the factory will produce | |
| // the ~override_type~. | |
| // | |
| // The original and override type arguments are lightweight proxies to the | |
| // types they represent. See <set_inst_override_by_type> for information | |
| // on usage. | |
| extern static function void set_type_override_by_type | |
| (uvm_object_wrapper original_type, | |
| uvm_object_wrapper override_type, | |
| bit replace=1); | |
| // Function: set_inst_override_by_type | |
| // | |
| // A convenience function for <uvm_factory::set_inst_override_by_type>, this | |
| // method registers a factory override for components and objects created at | |
| // this level of hierarchy or below. In typical usage, this method is | |
| // equivalent to: | |
| // | |
| //| factory.set_inst_override_by_type({get_full_name(),".", | |
| //| relative_inst_path}, | |
| //| original_type, | |
| //| override_type); | |
| // | |
| // The ~relative_inst_path~ is relative to this component and may include | |
| // wildcards. The ~original_type~ represents the type that is being overridden. | |
| // In subsequent calls to <uvm_factory::create_object_by_type> or | |
| // <uvm_factory::create_component_by_type>, if the requested_type matches the | |
| // ~original_type~ and the instance paths match, the factory will produce the | |
| // ~override_type~. | |
| // | |
| // The original and override types are lightweight proxies to the types they | |
| // represent. They can be obtained by calling ~type::get_type()~, if | |
| // implemented by ~type~, or by directly calling ~type::type_id::get()~, where | |
| // ~type~ is the user type and ~type_id~ is the name of the typedef to | |
| // <uvm_object_registry #(T,Tname)> or <uvm_component_registry #(T,Tname)>. | |
| // | |
| // If you are employing the `uvm_*_utils macros, the typedef and the get_type | |
| // method will be implemented for you. For details on the utils macros | |
| // refer to <Utility and Field Macros for Components and Objects>. | |
| // | |
| // The following example shows `uvm_*_utils usage: | |
| // | |
| //| class comp extends uvm_component; | |
| //| `uvm_component_utils(comp) | |
| //| ... | |
| //| endclass | |
| //| | |
| //| class mycomp extends uvm_component; | |
| //| `uvm_component_utils(mycomp) | |
| //| ... | |
| //| endclass | |
| //| | |
| //| class block extends uvm_component; | |
| //| `uvm_component_utils(block) | |
| //| comp c_inst; | |
| //| virtual function void build_phase(uvm_phase phase); | |
| //| set_inst_override_by_type("c_inst",comp::get_type(), | |
| //| mycomp::get_type()); | |
| //| endfunction | |
| //| ... | |
| //| endclass | |
| extern function void set_inst_override_by_type(string relative_inst_path, | |
| uvm_object_wrapper original_type, | |
| uvm_object_wrapper override_type); | |
| // Function: set_type_override | |
| // | |
| // A convenience function for <uvm_factory::set_type_override_by_name>, | |
| // this method configures the factory to create an object of type | |
| // ~override_type_name~ whenever the factory is asked to produce a type | |
| // represented by ~original_type_name~. This method is equivalent to: | |
| // | |
| //| factory.set_type_override_by_name(original_type_name, | |
| //| override_type_name, replace); | |
| // | |
| // The ~original_type_name~ typically refers to a preregistered type in the | |
| // factory. It may, however, be any arbitrary string. Subsequent calls to | |
| // create_component or create_object with the same string and matching | |
| // instance path will produce the type represented by override_type_name. | |
| // The ~override_type_name~ must refer to a preregistered type in the factory. | |
| extern static function void set_type_override(string original_type_name, | |
| string override_type_name, | |
| bit replace=1); | |
| // Function: set_inst_override | |
| // | |
| // A convenience function for <uvm_factory::set_inst_override_by_name>, this | |
| // method registers a factory override for components created at this level | |
| // of hierarchy or below. In typical usage, this method is equivalent to: | |
| // | |
| //| factory.set_inst_override_by_name({get_full_name(),".", | |
| //| relative_inst_path}, | |
| //| original_type_name, | |
| //| override_type_name); | |
| // | |
| // The ~relative_inst_path~ is relative to this component and may include | |
| // wildcards. The ~original_type_name~ typically refers to a preregistered type | |
| // in the factory. It may, however, be any arbitrary string. Subsequent calls | |
| // to create_component or create_object with the same string and matching | |
| // instance path will produce the type represented by ~override_type_name~. | |
| // The ~override_type_name~ must refer to a preregistered type in the factory. | |
| extern function void set_inst_override(string relative_inst_path, | |
| string original_type_name, | |
| string override_type_name); | |
| // Function: print_override_info | |
| // | |
| // This factory debug method performs the same lookup process as create_object | |
| // and create_component, but instead of creating an object, it prints | |
| // information about what type of object would be created given the | |
| // provided arguments. | |
| extern function void print_override_info(string requested_type_name, | |
| string name=""); | |
| //---------------------------------------------------------------------------- | |
| // Group: Hierarchical Reporting Interface | |
| //---------------------------------------------------------------------------- | |
| // | |
| // This interface provides versions of the set_report_* methods in the | |
| // <uvm_report_object> base class that are applied recursively to this | |
| // component and all its children. | |
| // | |
| // When a report is issued and its associated action has the LOG bit set, the | |
| // report will be sent to its associated FILE descriptor. | |
| //---------------------------------------------------------------------------- | |
| // Function: set_report_id_verbosity_hier | |
| extern function void set_report_id_verbosity_hier (string id, | |
| int verbosity); | |
| // Function: set_report_severity_id_verbosity_hier | |
| // | |
| // These methods recursively associate the specified verbosity with reports of | |
| // the given ~severity~, ~id~, or ~severity-id~ pair. An verbosity associated | |
| // with a particular severity-id pair takes precedence over an verbosity | |
| // associated with id, which takes precedence over an an verbosity associated | |
| // with a severity. | |
| // | |
| // For a list of severities and their default verbosities, refer to | |
| // <uvm_report_handler>. | |
| extern function void set_report_severity_id_verbosity_hier(uvm_severity severity, | |
| string id, | |
| int verbosity); | |
| // Function: set_report_severity_action_hier | |
| extern function void set_report_severity_action_hier (uvm_severity severity, | |
| uvm_action action); | |
| // Function: set_report_id_action_hier | |
| extern function void set_report_id_action_hier (string id, | |
| uvm_action action); | |
| // Function: set_report_severity_id_action_hier | |
| // | |
| // These methods recursively associate the specified action with reports of | |
| // the given ~severity~, ~id~, or ~severity-id~ pair. An action associated | |
| // with a particular severity-id pair takes precedence over an action | |
| // associated with id, which takes precedence over an an action associated | |
| // with a severity. | |
| // | |
| // For a list of severities and their default actions, refer to | |
| // <uvm_report_handler>. | |
| extern function void set_report_severity_id_action_hier(uvm_severity severity, | |
| string id, | |
| uvm_action action); | |
| // Function: set_report_default_file_hier | |
| extern function void set_report_default_file_hier (UVM_FILE file); | |
| // Function: set_report_severity_file_hier | |
| extern function void set_report_severity_file_hier (uvm_severity severity, | |
| UVM_FILE file); | |
| // Function: set_report_id_file_hier | |
| extern function void set_report_id_file_hier (string id, | |
| UVM_FILE file); | |
| // Function: set_report_severity_id_file_hier | |
| // | |
| // These methods recursively associate the specified FILE descriptor with | |
| // reports of the given ~severity~, ~id~, or ~severity-id~ pair. A FILE | |
| // associated with a particular severity-id pair takes precedence over a FILE | |
| // associated with id, which take precedence over an a FILE associated with a | |
| // severity, which takes precedence over the default FILE descriptor. | |
| // | |
| // For a list of severities and other information related to the report | |
| // mechanism, refer to <uvm_report_handler>. | |
| extern function void set_report_severity_id_file_hier(uvm_severity severity, | |
| string id, | |
| UVM_FILE file); | |
| // Function: set_report_verbosity_level_hier | |
| // | |
| // This method recursively sets the maximum verbosity level for reports for | |
| // this component and all those below it. Any report from this component | |
| // subtree whose verbosity exceeds this maximum will be ignored. | |
| // | |
| // See <uvm_report_handler> for a list of predefined message verbosity levels | |
| // and their meaning. | |
| extern function void set_report_verbosity_level_hier (int verbosity); | |
| // Function: pre_abort | |
| // | |
| // This callback is executed when the message system is executing a | |
| // <UVM_EXIT> action. The exit action causes an immediate termination of | |
| // the simulation, but the pre_abort callback hook gives components an | |
| // opportunity to provide additional information to the user before | |
| // the termination happens. For example, a test may want to executed | |
| // the report function of a particular component even when an error | |
| // condition has happened to force a premature termination you would | |
| // write a function like: | |
| // | |
| //| function void mycomponent::pre_abort(); | |
| //| report(); | |
| //| endfunction | |
| // | |
| // The pre_abort() callback hooks are called in a bottom-up fashion. | |
| virtual function void pre_abort; | |
| endfunction | |
| //---------------------------------------------------------------------------- | |
| // Group: Recording Interface | |
| //---------------------------------------------------------------------------- | |
| // These methods comprise the component-based transaction recording | |
| // interface. The methods can be used to record the transactions that | |
| // this component "sees", i.e. produces or consumes. | |
| // | |
| // The API and implementation are subject to change once a vendor-independent | |
| // use-model is determined. | |
| //---------------------------------------------------------------------------- | |
| // Function: accept_tr | |
| // | |
| // This function marks the acceptance of a transaction, ~tr~, by this | |
| // component. Specifically, it performs the following actions: | |
| // | |
| // - Calls the ~tr~'s <uvm_transaction::accept_tr> method, passing to it the | |
| // ~accept_time~ argument. | |
| // | |
| // - Calls this component's <do_accept_tr> method to allow for any post-begin | |
| // action in derived classes. | |
| // | |
| // - Triggers the component's internal accept_tr event. Any processes waiting | |
| // on this event will resume in the next delta cycle. | |
| extern function void accept_tr (uvm_transaction tr, time accept_time=0); | |
| // Function: do_accept_tr | |
| // | |
| // The <accept_tr> method calls this function to accommodate any user-defined | |
| // post-accept action. Implementations should call super.do_accept_tr to | |
| // ensure correct operation. | |
| extern virtual protected function void do_accept_tr (uvm_transaction tr); | |
| // Function: begin_tr | |
| // | |
| // This function marks the start of a transaction, ~tr~, by this component. | |
| // Specifically, it performs the following actions: | |
| // | |
| // - Calls ~tr~'s <uvm_transaction::begin_tr> method, passing to it the | |
| // ~begin_time~ argument. The ~begin_time~ should be greater than or equal | |
| // to the accept time. By default, when ~begin_time~ = 0, the current | |
| // simulation time is used. | |
| // | |
| // If recording is enabled (recording_detail != UVM_OFF), then a new | |
| // database-transaction is started on the component's transaction stream | |
| // given by the stream argument. No transaction properties are recorded at | |
| // this time. | |
| // | |
| // - Calls the component's <do_begin_tr> method to allow for any post-begin | |
| // action in derived classes. | |
| // | |
| // - Triggers the component's internal begin_tr event. Any processes waiting | |
| // on this event will resume in the next delta cycle. | |
| // | |
| // A handle to the transaction is returned. The meaning of this handle, as | |
| // well as the interpretation of the arguments ~stream_name~, ~label~, and | |
| // ~desc~ are vendor specific. | |
| extern function integer begin_tr (uvm_transaction tr, | |
| string stream_name="main", | |
| string label="", | |
| string desc="", | |
| time begin_time=0, | |
| integer parent_handle=0); | |
| // Function: begin_child_tr | |
| // | |
| // This function marks the start of a child transaction, ~tr~, by this | |
| // component. Its operation is identical to that of <begin_tr>, except that | |
| // an association is made between this transaction and the provided parent | |
| // transaction. This association is vendor-specific. | |
| extern function integer begin_child_tr (uvm_transaction tr, | |
| integer parent_handle=0, | |
| string stream_name="main", | |
| string label="", | |
| string desc="", | |
| time begin_time=0); | |
| // Function: do_begin_tr | |
| // | |
| // The <begin_tr> and <begin_child_tr> methods call this function to | |
| // accommodate any user-defined post-begin action. Implementations should call | |
| // super.do_begin_tr to ensure correct operation. | |
| extern virtual protected | |
| function void do_begin_tr (uvm_transaction tr, | |
| string stream_name, | |
| integer tr_handle); | |
| // Function: end_tr | |
| // | |
| // This function marks the end of a transaction, ~tr~, by this component. | |
| // Specifically, it performs the following actions: | |
| // | |
| // - Calls ~tr~'s <uvm_transaction::end_tr> method, passing to it the | |
| // ~end_time~ argument. The ~end_time~ must at least be greater than the | |
| // begin time. By default, when ~end_time~ = 0, the current simulation time | |
| // is used. | |
| // | |
| // The transaction's properties are recorded to the database-transaction on | |
| // which it was started, and then the transaction is ended. Only those | |
| // properties handled by the transaction's do_record method (and optional | |
| // `uvm_*_field macros) are recorded. | |
| // | |
| // - Calls the component's <do_end_tr> method to accommodate any post-end | |
| // action in derived classes. | |
| // | |
| // - Triggers the component's internal end_tr event. Any processes waiting on | |
| // this event will resume in the next delta cycle. | |
| // | |
| // The ~free_handle~ bit indicates that this transaction is no longer needed. | |
| // The implementation of free_handle is vendor-specific. | |
| extern function void end_tr (uvm_transaction tr, | |
| time end_time=0, | |
| bit free_handle=1); | |
| // Function: do_end_tr | |
| // | |
| // The <end_tr> method calls this function to accommodate any user-defined | |
| // post-end action. Implementations should call super.do_end_tr to ensure | |
| // correct operation. | |
| extern virtual protected function void do_end_tr (uvm_transaction tr, | |
| integer tr_handle); | |
| // Function: record_error_tr | |
| // | |
| // This function marks an error transaction by a component. Properties of the | |
| // given uvm_object, ~info~, as implemented in its <uvm_object::do_record> method, | |
| // are recorded to the transaction database. | |
| // | |
| // An ~error_time~ of 0 indicates to use the current simulation time. The | |
| // ~keep_active~ bit determines if the handle should remain active. If 0, | |
| // then a zero-length error transaction is recorded. A handle to the | |
| // database-transaction is returned. | |
| // | |
| // Interpretation of this handle, as well as the strings ~stream_name~, | |
| // ~label~, and ~desc~, are vendor-specific. | |
| extern function integer record_error_tr (string stream_name="main", | |
| uvm_object info=null, | |
| string label="error_tr", | |
| string desc="", | |
| time error_time=0, | |
| bit keep_active=0); | |
| // Function: record_event_tr | |
| // | |
| // This function marks an event transaction by a component. | |
| // | |
| // An ~event_time~ of 0 indicates to use the current simulation time. | |
| // | |
| // A handle to the transaction is returned. The ~keep_active~ bit determines | |
| // if the handle may be used for other vendor-specific purposes. | |
| // | |
| // The strings for ~stream_name~, ~label~, and ~desc~ are vendor-specific | |
| // identifiers for the transaction. | |
| extern function integer record_event_tr (string stream_name="main", | |
| uvm_object info=null, | |
| string label="event_tr", | |
| string desc="", | |
| time event_time=0, | |
| bit keep_active=0); | |
| // Variable: print_enabled | |
| // | |
| // This bit determines if this component should automatically be printed as a | |
| // child of its parent object. | |
| // | |
| // By default, all children are printed. However, this bit allows a parent | |
| // component to disable the printing of specific children. | |
| bit print_enabled = 1; | |
| // Variable: recorder | |
| // | |
| // Specifies the <uvm_recorder> object to use for <begin_tr> and other | |
| // methods in the <Recording Interface>. Default is <uvm_default_recorder>. | |
| // | |
| uvm_recorder recorder; | |
| //---------------------------------------------------------------------------- | |
| // PRIVATE or PSUEDO-PRIVATE members | |
| // *** Do not call directly *** | |
| // Implementation and even existence are subject to change. | |
| //---------------------------------------------------------------------------- | |
| // Most local methods are prefixed with m_, indicating they are not | |
| // user-level methods. SystemVerilog does not support friend classes, | |
| // which forces some otherwise internal methods to be exposed (i.e. not | |
| // be protected via 'local' keyword). These methods are also prefixed | |
| // with m_ to indicate they are not intended for public use. | |
| // | |
| // Internal methods will not be documented, although their implementa- | |
| // tions are freely available via the open-source license. | |
| //---------------------------------------------------------------------------- | |
| protected uvm_domain m_domain; // set_domain stores our domain handle | |
| /*protected*/ uvm_phase m_phase_imps[uvm_phase]; // functors to override ovm_root defaults | |
| //TND review protected, provide read-only accessor. | |
| uvm_phase m_current_phase; // the most recently executed phase | |
| protected process m_phase_process; | |
| /*protected*/ bit m_build_done; | |
| /*protected*/ int m_phasing_active; | |
| extern function void set_int_local(string field_name, | |
| uvm_bitstream_t value, | |
| bit recurse=1); | |
| /*protected*/ uvm_component m_parent; | |
| protected uvm_component m_children[string]; | |
| protected uvm_component m_children_by_handle[uvm_component]; | |
| extern protected virtual function bit m_add_child(uvm_component child); | |
| extern local virtual function void m_set_full_name(); | |
| extern function void do_resolve_bindings(); | |
| extern function void do_flush(); | |
| extern virtual function void flush (); | |
| extern local function void m_extract_name(string name , | |
| output string leaf , | |
| output string remainder ); | |
| // overridden to disable | |
| extern virtual function uvm_object create (string name=""); | |
| extern virtual function uvm_object clone (); | |
| local integer m_stream_handle[string]; | |
| local integer m_tr_h[uvm_transaction]; | |
| extern protected function integer m_begin_tr (uvm_transaction tr, | |
| integer parent_handle=0, bit has_parent=0, | |
| string stream_name="main", string label="", | |
| string desc="", time begin_time=0); | |
| string m_name; | |
| const static string type_name = "uvm_component"; | |
| virtual function string get_type_name(); | |
| return type_name; | |
| endfunction | |
| protected uvm_event_pool event_pool; | |
| int unsigned recording_detail = UVM_NONE; | |
| extern function void do_print(uvm_printer printer); | |
| // Internal methods for setting up command line messaging stuff | |
| extern function void m_set_cl_msg_args; | |
| extern function void m_set_cl_verb; | |
| extern function void m_set_cl_action; | |
| extern function void m_set_cl_sev; | |
| extern function void m_apply_verbosity_settings(uvm_phase phase); | |
| // The verbosity settings may have a specific phase to start at. | |
| // We will do this work in the phase_started callback. | |
| typedef struct { | |
| string comp; | |
| string phase; | |
| time offset; | |
| uvm_verbosity verbosity; | |
| string id; | |
| } m_verbosity_setting; | |
| m_verbosity_setting m_verbosity_settings[$]; | |
| static m_verbosity_setting m_time_settings[$]; | |
| // does the pre abort callback hierarchically | |
| extern /*local*/ function void m_do_pre_abort; | |
| endclass : uvm_component | |
| `include "base/uvm_root.svh" | |
| //------------------------------------------------------------------------------ | |
| // IMPLEMENTATION | |
| //------------------------------------------------------------------------------ | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS- uvm_component | |
| // | |
| //------------------------------------------------------------------------------ | |
| // new | |
| // --- | |
| function uvm_component::new (string name, uvm_component parent); | |
| string error_str; | |
| uvm_root top; | |
| super.new(name); | |
| // If uvm_top, reset name to "" so it doesn't show in full paths then return | |
| if (parent==null && name == "__top__") begin | |
| set_name(""); // *** VIRTUAL | |
| return; | |
| end | |
| top = uvm_root::get(); | |
| // Check that we're not in or past end_of_elaboration | |
| begin | |
| uvm_phase bld; | |
| uvm_domain common; | |
| common = uvm_domain::get_common_domain(); | |
| bld = common.find(uvm_build_phase::get()); | |
| if (bld == null) | |
| uvm_report_fatal("COMP/INTERNAL", | |
| "attempt to find build phase object failed",UVM_NONE); | |
| if (bld.get_state() == UVM_PHASE_DONE) begin | |
| uvm_report_fatal("ILLCRT", {"It is illegal to create a component ('", | |
| name,"' under '", | |
| (parent == null ? top.get_full_name() : parent.get_full_name()), | |
| "') after the build phase has ended."}, | |
| UVM_NONE); | |
| end | |
| end | |
| if (name == "") begin | |
| name.itoa(m_inst_count); | |
| name = {"COMP_", name}; | |
| end | |
| if(parent == this) begin | |
| `uvm_fatal("THISPARENT", "cannot set the parent of a component to itself") | |
| end | |
| if (parent == null) | |
| parent = top; | |
| if(uvm_report_enabled(UVM_MEDIUM+1, UVM_INFO, "NEWCOMP")) | |
| `uvm_info("NEWCOMP", {"Creating ", | |
| (parent==top?"uvm_top":parent.get_full_name()),".",name},UVM_MEDIUM+1) | |
| if (parent.has_child(name) && this != parent.get_child(name)) begin | |
| if (parent == top) begin | |
| error_str = {"Name '",name,"' is not unique to other top-level ", | |
| "instances. If parent is a module, build a unique name by combining the ", | |
| "the module name and component name: $sformatf(\"\%m.\%s\",\"",name,"\")."}; | |
| `uvm_fatal("CLDEXT",error_str) | |
| end | |
| else | |
| `uvm_fatal("CLDEXT", | |
| $sformatf("Cannot set '%s' as a child of '%s', %s", | |
| name, parent.get_full_name(), | |
| "which already has a child by that name.")) | |
| return; | |
| end | |
| m_parent = parent; | |
| set_name(name); // *** VIRTUAL | |
| if (!m_parent.m_add_child(this)) | |
| m_parent = null; | |
| event_pool = new("event_pool"); | |
| m_domain = parent.m_domain; // by default, inherit domains from parents | |
| // Now that inst name is established, reseed (if use_uvm_seeding is set) | |
| reseed(); | |
| // Do local configuration settings | |
| if (!uvm_config_db #(uvm_bitstream_t)::get(this, "", "recording_detail", recording_detail)) | |
| void'(uvm_config_db #(int)::get(this, "", "recording_detail", recording_detail)); | |
| set_report_verbosity_level(parent.get_report_verbosity_level()); | |
| m_set_cl_msg_args(); | |
| endfunction | |
| // m_add_child | |
| // ----------- | |
| function bit uvm_component::m_add_child(uvm_component child); | |
| if (m_children.exists(child.get_name()) && | |
| m_children[child.get_name()] != child) begin | |
| `uvm_warning("BDCLD", | |
| $sformatf("A child with the name '%0s' (type=%0s) already exists.", | |
| child.get_name(), m_children[child.get_name()].get_type_name())) | |
| return 0; | |
| end | |
| if (m_children_by_handle.exists(child)) begin | |
| `uvm_warning("BDCHLD", | |
| $sformatf("A child with the name '%0s' %0s %0s'", | |
| child.get_name(), | |
| "already exists in parent under name '", | |
| m_children_by_handle[child].get_name())) | |
| return 0; | |
| end | |
| m_children[child.get_name()] = child; | |
| m_children_by_handle[child] = child; | |
| return 1; | |
| endfunction | |
| //------------------------------------------------------------------------------ | |
| // | |
| // Hierarchy Methods | |
| // | |
| //------------------------------------------------------------------------------ | |
| // get_children | |
| // ------------ | |
| function void uvm_component::get_children(ref uvm_component children[$]); | |
| foreach(m_children[i]) | |
| children.push_back(m_children[i]); | |
| endfunction | |
| // get_first_child | |
| // --------------- | |
| function int uvm_component::get_first_child(ref string name); | |
| return m_children.first(name); | |
| endfunction | |
| // get_next_child | |
| // -------------- | |
| function int uvm_component::get_next_child(ref string name); | |
| return m_children.next(name); | |
| endfunction | |
| // get_child | |
| // --------- | |
| function uvm_component uvm_component::get_child(string name); | |
| if (m_children.exists(name)) | |
| return m_children[name]; | |
| `uvm_warning("NOCHILD",{"Component with name '",name, | |
| "' is not a child of component '",get_full_name(),"'"}) | |
| return null; | |
| endfunction | |
| // has_child | |
| // --------- | |
| function int uvm_component::has_child(string name); | |
| return m_children.exists(name); | |
| endfunction | |
| // get_num_children | |
| // ---------------- | |
| function int uvm_component::get_num_children(); | |
| return m_children.num(); | |
| endfunction | |
| // get_full_name | |
| // ------------- | |
| function string uvm_component::get_full_name (); | |
| // Note- Implementation choice to construct full name once since the | |
| // full name may be used often for lookups. | |
| if(m_name == "") | |
| return get_name(); | |
| else | |
| return m_name; | |
| endfunction | |
| // get_parent | |
| // ---------- | |
| function uvm_component uvm_component::get_parent (); | |
| return m_parent; | |
| endfunction | |
| // set_name | |
| // -------- | |
| function void uvm_component::set_name (string name); | |
| if(m_name != "") begin | |
| `uvm_error("INVSTNM", $sformatf("It is illegal to change the name of a component. The component name will not be changed to \"%s\"", name)) | |
| return; | |
| end | |
| super.set_name(name); | |
| m_set_full_name(); | |
| endfunction | |
| // m_set_full_name | |
| // --------------- | |
| function void uvm_component::m_set_full_name(); | |
| uvm_root top; | |
| top = uvm_top; | |
| if (m_parent == top || m_parent==null) | |
| m_name = get_name(); | |
| else | |
| m_name = {m_parent.get_full_name(), ".", get_name()}; | |
| foreach (m_children[c]) begin | |
| uvm_component tmp; | |
| tmp = m_children[c]; | |
| tmp.m_set_full_name(); | |
| end | |
| endfunction | |
| // lookup | |
| // ------ | |
| function uvm_component uvm_component::lookup( string name ); | |
| string leaf , remainder; | |
| uvm_component comp; | |
| uvm_root top; | |
| top = uvm_root::get(); | |
| comp = this; | |
| m_extract_name(name, leaf, remainder); | |
| if (leaf == "") begin | |
| comp = top; // absolute lookup | |
| m_extract_name(remainder, leaf, remainder); | |
| end | |
| if (!comp.has_child(leaf)) begin | |
| `uvm_warning("Lookup Error", | |
| $sformatf("Cannot find child %0s",leaf)) | |
| return null; | |
| end | |
| if( remainder != "" ) | |
| return comp.m_children[leaf].lookup(remainder); | |
| return comp.m_children[leaf]; | |
| endfunction | |
| // get_depth | |
| // --------- | |
| function int unsigned uvm_component::get_depth(); | |
| if(m_name == "") return 0; | |
| get_depth = 1; | |
| foreach(m_name[i]) | |
| if(m_name[i] == ".") ++get_depth; | |
| endfunction | |
| // m_extract_name | |
| // -------------- | |
| function void uvm_component::m_extract_name(input string name , | |
| output string leaf , | |
| output string remainder ); | |
| int i , len; | |
| string extract_str; | |
| len = name.len(); | |
| for( i = 0; i < name.len(); i++ ) begin | |
| if( name[i] == "." ) begin | |
| break; | |
| end | |
| end | |
| if( i == len ) begin | |
| leaf = name; | |
| remainder = ""; | |
| return; | |
| end | |
| leaf = name.substr( 0 , i - 1 ); | |
| remainder = name.substr( i + 1 , len - 1 ); | |
| return; | |
| endfunction | |
| // flush | |
| // ----- | |
| function void uvm_component::flush(); | |
| return; | |
| endfunction | |
| // do_flush (flush_hier?) | |
| // -------- | |
| function void uvm_component::do_flush(); | |
| foreach( m_children[s] ) | |
| m_children[s].do_flush(); | |
| flush(); | |
| endfunction | |
| //------------------------------------------------------------------------------ | |
| // | |
| // Factory Methods | |
| // | |
| //------------------------------------------------------------------------------ | |
| // create | |
| // ------ | |
| function uvm_object uvm_component::create (string name =""); | |
| `uvm_error("ILLCRT", | |
| "create cannot be called on a uvm_component. Use create_component instead.") | |
| return null; | |
| endfunction | |
| // clone | |
| // ------ | |
| function uvm_object uvm_component::clone (); | |
| `uvm_error("ILLCLN", $sformatf("Attempting to clone '%s'. Clone cannot be called on a uvm_component. The clone target variable will be set to null.", get_full_name())) | |
| return null; | |
| endfunction | |
| // print_override_info | |
| // ------------------- | |
| function void uvm_component::print_override_info (string requested_type_name, | |
| string name=""); | |
| factory.debug_create_by_name(requested_type_name, get_full_name(), name); | |
| endfunction | |
| // create_component | |
| // ---------------- | |
| function uvm_component uvm_component::create_component (string requested_type_name, | |
| string name); | |
| return factory.create_component_by_name(requested_type_name, get_full_name(), | |
| name, this); | |
| endfunction | |
| // create_object | |
| // ------------- | |
| function uvm_object uvm_component::create_object (string requested_type_name, | |
| string name=""); | |
| return factory.create_object_by_name(requested_type_name, | |
| get_full_name(), name); | |
| endfunction | |
| // set_type_override (static) | |
| // ----------------- | |
| function void uvm_component::set_type_override (string original_type_name, | |
| string override_type_name, | |
| bit replace=1); | |
| factory.set_type_override_by_name(original_type_name, | |
| override_type_name, replace); | |
| endfunction | |
| // set_type_override_by_type (static) | |
| // ------------------------- | |
| function void uvm_component::set_type_override_by_type (uvm_object_wrapper original_type, | |
| uvm_object_wrapper override_type, | |
| bit replace=1); | |
| factory.set_type_override_by_type(original_type, override_type, replace); | |
| endfunction | |
| // set_inst_override | |
| // ----------------- | |
| function void uvm_component::set_inst_override (string relative_inst_path, | |
| string original_type_name, | |
| string override_type_name); | |
| string full_inst_path; | |
| if (relative_inst_path == "") | |
| full_inst_path = get_full_name(); | |
| else | |
| full_inst_path = {get_full_name(), ".", relative_inst_path}; | |
| factory.set_inst_override_by_name( | |
| original_type_name, | |
| override_type_name, | |
| full_inst_path); | |
| endfunction | |
| // set_inst_override_by_type | |
| // ------------------------- | |
| function void uvm_component::set_inst_override_by_type (string relative_inst_path, | |
| uvm_object_wrapper original_type, | |
| uvm_object_wrapper override_type); | |
| string full_inst_path; | |
| if (relative_inst_path == "") | |
| full_inst_path = get_full_name(); | |
| else | |
| full_inst_path = {get_full_name(), ".", relative_inst_path}; | |
| factory.set_inst_override_by_type(original_type, override_type, full_inst_path); | |
| endfunction | |
| //------------------------------------------------------------------------------ | |
| // | |
| // Hierarchical report configuration interface | |
| // | |
| //------------------------------------------------------------------------------ | |
| // set_report_id_verbosity_hier | |
| // ------------------------- | |
| function void uvm_component::set_report_id_verbosity_hier( string id, int verbosity); | |
| set_report_id_verbosity(id, verbosity); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_id_verbosity_hier(id, verbosity); | |
| endfunction | |
| // set_report_severity_id_verbosity_hier | |
| // ---------------------------------- | |
| function void uvm_component::set_report_severity_id_verbosity_hier( uvm_severity severity, | |
| string id, | |
| int verbosity); | |
| set_report_severity_id_verbosity(severity, id, verbosity); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_severity_id_verbosity_hier(severity, id, verbosity); | |
| endfunction | |
| // set_report_severity_action_hier | |
| // ------------------------- | |
| function void uvm_component::set_report_severity_action_hier( uvm_severity severity, | |
| uvm_action action); | |
| set_report_severity_action(severity, action); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_severity_action_hier(severity, action); | |
| endfunction | |
| // set_report_id_action_hier | |
| // ------------------------- | |
| function void uvm_component::set_report_id_action_hier( string id, uvm_action action); | |
| set_report_id_action(id, action); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_id_action_hier(id, action); | |
| endfunction | |
| // set_report_severity_id_action_hier | |
| // ---------------------------------- | |
| function void uvm_component::set_report_severity_id_action_hier( uvm_severity severity, | |
| string id, | |
| uvm_action action); | |
| set_report_severity_id_action(severity, id, action); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_severity_id_action_hier(severity, id, action); | |
| endfunction | |
| // set_report_severity_file_hier | |
| // ----------------------------- | |
| function void uvm_component::set_report_severity_file_hier( uvm_severity severity, | |
| UVM_FILE file); | |
| set_report_severity_file(severity, file); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_severity_file_hier(severity, file); | |
| endfunction | |
| // set_report_default_file_hier | |
| // ---------------------------- | |
| function void uvm_component::set_report_default_file_hier( UVM_FILE file); | |
| set_report_default_file(file); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_default_file_hier(file); | |
| endfunction | |
| // set_report_id_file_hier | |
| // ----------------------- | |
| function void uvm_component::set_report_id_file_hier( string id, UVM_FILE file); | |
| set_report_id_file(id, file); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_id_file_hier(id, file); | |
| endfunction | |
| // set_report_severity_id_file_hier | |
| // -------------------------------- | |
| function void uvm_component::set_report_severity_id_file_hier ( uvm_severity severity, | |
| string id, | |
| UVM_FILE file); | |
| set_report_severity_id_file(severity, id, file); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_severity_id_file_hier(severity, id, file); | |
| endfunction | |
| // set_report_verbosity_level_hier | |
| // ------------------------------- | |
| function void uvm_component::set_report_verbosity_level_hier(int verbosity); | |
| set_report_verbosity_level(verbosity); | |
| foreach( m_children[c] ) | |
| m_children[c].set_report_verbosity_level_hier(verbosity); | |
| endfunction | |
| //------------------------------------------------------------------------------ | |
| // | |
| // Phase interface | |
| // | |
| //------------------------------------------------------------------------------ | |
| // phase methods | |
| //-------------- | |
| // these are prototypes for the methods to be implemented in user components | |
| // build_phase() has a default implementation, the others have an empty default | |
| function void uvm_component::build_phase(uvm_phase phase); | |
| m_build_done = 1; | |
| build(); | |
| endfunction | |
| // Backward compatibility build function | |
| function void uvm_component::build(); | |
| m_build_done = 1; | |
| apply_config_settings(print_config_matches); | |
| if(m_phasing_active == 0) begin | |
| uvm_report_warning("UVM_DEPRECATED", "build()/build_phase() has been called explicitly, outside of the phasing system. This usage of build is deprecated and may lead to unexpected behavior."); | |
| end | |
| endfunction | |
| // these phase methods are common to all components in UVM. For backward | |
| // compatibility, they call the old style name (without the _phse) | |
| function void uvm_component::connect_phase(uvm_phase phase); | |
| connect(); | |
| return; | |
| endfunction | |
| function void uvm_component::start_of_simulation_phase(uvm_phase phase); | |
| start_of_simulation(); | |
| return; | |
| endfunction | |
| function void uvm_component::end_of_elaboration_phase(uvm_phase phase); | |
| end_of_elaboration(); | |
| return; | |
| endfunction | |
| task uvm_component::run_phase(uvm_phase phase); | |
| run(); | |
| return; | |
| endtask | |
| function void uvm_component::extract_phase(uvm_phase phase); | |
| extract(); | |
| return; | |
| endfunction | |
| function void uvm_component::check_phase(uvm_phase phase); | |
| check(); | |
| return; | |
| endfunction | |
| function void uvm_component::report_phase(uvm_phase phase); | |
| report(); | |
| return; | |
| endfunction | |
| // These are the old style phase names. In order for runtime phase names | |
| // to not conflict with user names, the _phase postfix was added. | |
| function void uvm_component::connect(); return; endfunction | |
| function void uvm_component::start_of_simulation(); return; endfunction | |
| function void uvm_component::end_of_elaboration(); return; endfunction | |
| task uvm_component::run(); return; endtask | |
| function void uvm_component::extract(); return; endfunction | |
| function void uvm_component::check(); return; endfunction | |
| function void uvm_component::report(); return; endfunction | |
| function void uvm_component::final_phase(uvm_phase phase); return; endfunction | |
| // these runtime phase methods are only called if a set_domain() is done | |
| task uvm_component::pre_reset_phase(uvm_phase phase); return; endtask | |
| task uvm_component::reset_phase(uvm_phase phase); return; endtask | |
| task uvm_component::post_reset_phase(uvm_phase phase); return; endtask | |
| task uvm_component::pre_configure_phase(uvm_phase phase); return; endtask | |
| task uvm_component::configure_phase(uvm_phase phase); return; endtask | |
| task uvm_component::post_configure_phase(uvm_phase phase); return; endtask | |
| task uvm_component::pre_main_phase(uvm_phase phase); return; endtask | |
| task uvm_component::main_phase(uvm_phase phase); return; endtask | |
| task uvm_component::post_main_phase(uvm_phase phase); return; endtask | |
| task uvm_component::pre_shutdown_phase(uvm_phase phase); return; endtask | |
| task uvm_component::shutdown_phase(uvm_phase phase); return; endtask | |
| task uvm_component::post_shutdown_phase(uvm_phase phase); return; endtask | |
| //------------------------------ | |
| // current phase convenience API | |
| //------------------------------ | |
| // phase_started | |
| // ------------- | |
| // phase_started() and phase_ended() are extra callbacks called at the | |
| // beginning and end of each phase, respectively. Since they are | |
| // called for all phases the phase is passed in as an argument so the | |
| // extender can decide what to do, if anything, for each phase. | |
| function void uvm_component::phase_started(uvm_phase phase); | |
| endfunction | |
| // phase_ended | |
| // ----------- | |
| function void uvm_component::phase_ended(uvm_phase phase); | |
| endfunction | |
| // phase_ready_to_end | |
| // ------------------ | |
| function void uvm_component::phase_ready_to_end (uvm_phase phase); | |
| endfunction | |
| //------------------------------ | |
| // phase / schedule / domain API | |
| //------------------------------ | |
| // methods for VIP creators and integrators to use to set up schedule domains | |
| // - a schedule is a named, organized group of phases for a component base type | |
| // - a domain is a named instance of a schedule in the master phasing schedule | |
| // define_domain | |
| // ------------- | |
| function void uvm_component::define_domain(uvm_domain domain); | |
| uvm_phase schedule; | |
| //schedule = domain.find(uvm_domain::get_uvm_schedule()); | |
| schedule = domain.find_by_name("uvm_sched"); | |
| if (schedule == null) begin | |
| uvm_domain common; | |
| schedule = new("uvm_sched", UVM_PHASE_SCHEDULE); | |
| uvm_domain::add_uvm_phases(schedule); | |
| domain.add(schedule); | |
| common = uvm_domain::get_common_domain(); | |
| if (common.find(domain,0) == null) | |
| common.add(domain,.with_phase(uvm_run_phase::get())); | |
| end | |
| endfunction | |
| // set_domain | |
| // ---------- | |
| // assigns this component [tree] to a domain. adds required schedules into graph | |
| // If called from build, ~hier~ won't recurse into all chilren (which don't exist yet) | |
| // If we have components inherit their parent's domain by default, then ~hier~ | |
| // isn't needed and we need a way to prevent children from inheriting this component's domain | |
| function void uvm_component::set_domain(uvm_domain domain, int hier=1); | |
| // build and store the custom domain | |
| m_domain = domain; | |
| define_domain(domain); | |
| if (hier) | |
| foreach (m_children[c]) | |
| m_children[c].set_domain(domain); | |
| endfunction | |
| // get_domain | |
| // ---------- | |
| // | |
| function uvm_domain uvm_component::get_domain(); | |
| return m_domain; | |
| endfunction | |
| // set_phase_imp | |
| // ------------- | |
| function void uvm_component::set_phase_imp(uvm_phase phase, uvm_phase imp, int hier=1); | |
| m_phase_imps[phase] = imp; | |
| if (hier) | |
| foreach (m_children[c]) | |
| m_children[c].set_phase_imp(phase,imp,hier); | |
| endfunction | |
| //-------------------------- | |
| // phase runtime control API | |
| //-------------------------- | |
| `ifndef UVM_NO_DEPRECATED | |
| // do_kill_all | |
| // ----------- | |
| function void uvm_component::do_kill_all(); | |
| foreach(m_children[c]) | |
| m_children[c].do_kill_all(); | |
| kill(); | |
| endfunction | |
| // kill | |
| // ---- | |
| function void uvm_component::kill(); | |
| if (m_phase_process != null) begin | |
| m_phase_process.kill; | |
| m_phase_process = null; | |
| end | |
| endfunction | |
| `endif | |
| // suspend | |
| // ------- | |
| task uvm_component::suspend(); | |
| `uvm_warning("COMP/SPND/UNIMP", "suspend() not implemented") | |
| endtask | |
| // resume | |
| // ------ | |
| task uvm_component::resume(); | |
| `uvm_warning("COMP/RSUM/UNIMP", "resume() not implemented") | |
| endtask | |
| // status | |
| //------- | |
| `ifndef UVM_NO_DEPRECATED | |
| function string uvm_component::status(); | |
| `ifdef UVM_USE_SUSPEND_RESUME | |
| `ifdef UVM_USE_PROCESS_STATE | |
| process::state ps; | |
| if(m_phase_process == null) | |
| return "<unknown>"; | |
| ps = m_phase_process.status(); | |
| return ps.name(); | |
| `else | |
| if(m_phase_process == null) | |
| return "<unknown>"; | |
| case(m_phase_process.status()) | |
| 0: return "FINISHED"; | |
| 1: return "RUNNING"; | |
| 2: return "WAITING"; | |
| 3: return "SUSPENDED"; | |
| 4: return "KILLED"; | |
| default: return "<unknown>"; | |
| endcase | |
| `endif | |
| `endif | |
| return "<unknown>"; | |
| endfunction | |
| // stop | |
| // ---- | |
| task uvm_component::stop(string ph_name); | |
| return; | |
| endtask | |
| // stop_phase | |
| // ---------- | |
| task uvm_component::stop_phase(uvm_phase phase); | |
| stop(phase.get_name()); | |
| return; | |
| endtask | |
| `endif | |
| // resolve_bindings | |
| // ---------------- | |
| function void uvm_component::resolve_bindings(); | |
| return; | |
| endfunction | |
| // do_resolve_bindings | |
| // ------------------- | |
| function void uvm_component::do_resolve_bindings(); | |
| foreach( m_children[s] ) | |
| m_children[s].do_resolve_bindings(); | |
| resolve_bindings(); | |
| endfunction | |
| //------------------------------------------------------------------------------ | |
| // | |
| // Recording interface | |
| // | |
| //------------------------------------------------------------------------------ | |
| // accept_tr | |
| // --------- | |
| function void uvm_component::accept_tr (uvm_transaction tr, | |
| time accept_time=0); | |
| uvm_event e; | |
| tr.accept_tr(accept_time); | |
| do_accept_tr(tr); | |
| e = event_pool.get("accept_tr"); | |
| if(e!=null) | |
| e.trigger(); | |
| endfunction | |
| // begin_tr | |
| // -------- | |
| function integer uvm_component::begin_tr (uvm_transaction tr, | |
| string stream_name ="main", | |
| string label="", | |
| string desc="", | |
| time begin_time=0, | |
| integer parent_handle=0); | |
| return m_begin_tr(tr, parent_handle, (parent_handle!=0), stream_name, label, desc, begin_time); | |
| endfunction | |
| // begin_child_tr | |
| // -------------- | |
| function integer uvm_component::begin_child_tr (uvm_transaction tr, | |
| integer parent_handle=0, | |
| string stream_name="main", | |
| string label="", | |
| string desc="", | |
| time begin_time=0); | |
| return m_begin_tr(tr, parent_handle, 1, stream_name, label, desc, begin_time); | |
| endfunction | |
| // m_begin_tr | |
| // ---------- | |
| function integer uvm_component::m_begin_tr (uvm_transaction tr, | |
| integer parent_handle=0, | |
| bit has_parent=0, | |
| string stream_name="main", | |
| string label="", | |
| string desc="", | |
| time begin_time=0); | |
| uvm_event e; | |
| integer stream_h=0; | |
| integer tr_h; | |
| integer link_tr_h; | |
| string name; | |
| string kind; | |
| uvm_recorder recordr; | |
| if (tr == null) | |
| return 0; | |
| recordr = (recorder == null) ? uvm_default_recorder : recorder; | |
| if (!has_parent) begin | |
| uvm_sequence_item seq; | |
| if ($cast(seq,tr)) begin | |
| uvm_sequence_base parent_seq = seq.get_parent_sequence(); | |
| if (parent_seq != null) begin | |
| parent_handle = parent_seq.m_tr_handle; | |
| if (parent_handle!=0) | |
| has_parent = 1; | |
| end | |
| end | |
| end | |
| tr_h = 0; | |
| if(has_parent) | |
| link_tr_h = tr.begin_child_tr(begin_time, parent_handle); | |
| else | |
| link_tr_h = tr.begin_tr(begin_time); | |
| if (tr.get_name() != "") | |
| name = tr.get_name(); | |
| else | |
| name = tr.get_type_name(); | |
| if(stream_name == "") stream_name="main"; | |
| if (uvm_verbosity'(recording_detail) != UVM_NONE) begin | |
| if(m_stream_handle.exists(stream_name)) | |
| stream_h = m_stream_handle[stream_name]; | |
| if (recordr.check_handle_kind("Fiber", stream_h) != 1) begin | |
| stream_h = recordr.create_stream(stream_name, "TVM", get_full_name()); | |
| m_stream_handle[stream_name] = stream_h; | |
| end | |
| kind = (has_parent == 0) ? "Begin_No_Parent, Link" : "Begin_End, Link"; | |
| tr_h = recordr.begin_tr(kind, stream_h, name, label, desc, begin_time); | |
| if (has_parent && parent_handle != 0) | |
| recordr.link_tr(parent_handle, tr_h, "child"); | |
| m_tr_h[tr] = tr_h; | |
| if (recordr.check_handle_kind("Transaction", link_tr_h) == 1) | |
| recordr.link_tr(tr_h,link_tr_h); | |
| do_begin_tr(tr,stream_name,tr_h); | |
| end | |
| e = event_pool.get("begin_tr"); | |
| if (e!=null) | |
| e.trigger(tr); | |
| return tr_h; | |
| endfunction | |
| // end_tr | |
| // ------ | |
| function void uvm_component::end_tr (uvm_transaction tr, | |
| time end_time=0, | |
| bit free_handle=1); | |
| uvm_event e; | |
| integer tr_h; | |
| uvm_recorder recordr; | |
| if (tr == null) | |
| return; | |
| recordr = (recorder == null) ? uvm_default_recorder : recorder; | |
| tr_h = 0; | |
| tr.end_tr(end_time,free_handle); | |
| if (uvm_verbosity'(recording_detail) != UVM_NONE) begin | |
| if (m_tr_h.exists(tr)) begin | |
| tr_h = m_tr_h[tr]; | |
| do_end_tr(tr, tr_h); // callback | |
| m_tr_h.delete(tr); | |
| if (recordr.check_handle_kind("Transaction", tr_h) == 1) begin | |
| recordr.tr_handle = tr_h; | |
| tr.record(recordr); | |
| recordr.end_tr(tr_h,end_time); | |
| if (free_handle) | |
| recordr.free_tr(tr_h); | |
| end | |
| end | |
| else begin | |
| do_end_tr(tr, tr_h); // callback | |
| end | |
| end | |
| e = event_pool.get("end_tr"); | |
| if(e!=null) | |
| e.trigger(); | |
| endfunction | |
| // record_error_tr | |
| // --------------- | |
| function integer uvm_component::record_error_tr (string stream_name="main", | |
| uvm_object info=null, | |
| string label="error_tr", | |
| string desc="", | |
| time error_time=0, | |
| bit keep_active=0); | |
| string etype; | |
| integer stream_h; | |
| uvm_recorder recordr; | |
| recordr = (recorder == null) ? uvm_default_recorder : recorder; | |
| if(keep_active) etype = "Error, Link"; | |
| else etype = "Error"; | |
| if(error_time == 0) error_time = $realtime; | |
| stream_h = m_stream_handle[stream_name]; | |
| if (recordr.check_handle_kind("Fiber", stream_h) != 1) begin | |
| stream_h = recordr.create_stream(stream_name, "TVM", get_full_name()); | |
| m_stream_handle[stream_name] = stream_h; | |
| end | |
| record_error_tr = recordr.begin_tr(etype, stream_h, label, | |
| label, desc, error_time); | |
| if(info!=null) begin | |
| recordr.tr_handle = record_error_tr; | |
| info.record(recordr); | |
| end | |
| recordr.end_tr(record_error_tr,error_time); | |
| endfunction | |
| // record_event_tr | |
| // --------------- | |
| function integer uvm_component::record_event_tr (string stream_name="main", | |
| uvm_object info=null, | |
| string label="event_tr", | |
| string desc="", | |
| time event_time=0, | |
| bit keep_active=0); | |
| string etype; | |
| integer stream_h; | |
| uvm_recorder recordr; | |
| recordr = (recorder == null) ? uvm_default_recorder : recorder; | |
| if(keep_active) etype = "Event, Link"; | |
| else etype = "Event"; | |
| if(event_time == 0) event_time = $realtime; | |
| stream_h = m_stream_handle[stream_name]; | |
| if (recordr.check_handle_kind("Fiber", stream_h) != 1) begin | |
| stream_h = recordr.create_stream(stream_name, "TVM", get_full_name()); | |
| m_stream_handle[stream_name] = stream_h; | |
| end | |
| record_event_tr = recordr.begin_tr(etype, stream_h, label, | |
| label, desc, event_time); | |
| if(info!=null) begin | |
| recordr.tr_handle = record_event_tr; | |
| info.record(recordr); | |
| end | |
| recordr.end_tr(record_event_tr,event_time); | |
| endfunction | |
| // do_accept_tr | |
| // ------------ | |
| function void uvm_component::do_accept_tr (uvm_transaction tr); | |
| return; | |
| endfunction | |
| // do_begin_tr | |
| // ----------- | |
| function void uvm_component::do_begin_tr (uvm_transaction tr, | |
| string stream_name, | |
| integer tr_handle); | |
| return; | |
| endfunction | |
| // do_end_tr | |
| // --------- | |
| function void uvm_component::do_end_tr (uvm_transaction tr, | |
| integer tr_handle); | |
| return; | |
| endfunction | |
| //------------------------------------------------------------------------------ | |
| // | |
| // Configuration interface | |
| // | |
| //------------------------------------------------------------------------------ | |
| function string uvm_component::massage_scope(string scope); | |
| // uvm_top | |
| if(scope == "") | |
| return "^$"; | |
| if(scope == "*") | |
| return {get_full_name(), ".*"}; | |
| // absolute path to the top-level test | |
| if(scope == "uvm_test_top") | |
| return "uvm_test_top"; | |
| // absolute path to uvm_root | |
| if(scope[0] == ".") | |
| return {get_full_name(), scope}; | |
| return {get_full_name(), ".", scope}; | |
| endfunction | |
| // | |
| // set_config_int | |
| // | |
| typedef uvm_config_db#(uvm_bitstream_t) uvm_config_int; | |
| typedef uvm_config_db#(string) uvm_config_string; | |
| typedef uvm_config_db#(uvm_object) uvm_config_object; | |
| // Undocumented struct for storing clone bit along w/ | |
| // object on set_config_object(...) calls | |
| class uvm_config_object_wrapper; | |
| uvm_object obj; | |
| bit clone; | |
| endclass : uvm_config_object_wrapper | |
| function void uvm_component::set_config_int(string inst_name, | |
| string field_name, | |
| uvm_bitstream_t value); | |
| uvm_config_int::set(this, inst_name, field_name, value); | |
| endfunction | |
| // | |
| // set_config_string | |
| // | |
| function void uvm_component::set_config_string(string inst_name, | |
| string field_name, | |
| string value); | |
| uvm_config_string::set(this, inst_name, field_name, value); | |
| endfunction | |
| // | |
| // set_config_object | |
| // | |
| function void uvm_component::set_config_object(string inst_name, | |
| string field_name, | |
| uvm_object value, | |
| bit clone = 1); | |
| uvm_object tmp; | |
| uvm_config_object_wrapper wrapper; | |
| if(value == null) | |
| `uvm_warning("NULLCFG", {"A null object was provided as a ", | |
| $sformatf("configuration object for set_config_object(\"%s\",\"%s\")", | |
| inst_name, field_name), ". Verify that this is intended."}) | |
| if(clone && (value != null)) begin | |
| tmp = value.clone(); | |
| if(tmp == null) begin | |
| uvm_component comp; | |
| if ($cast(comp,value)) begin | |
| `uvm_error("INVCLNC", {"Clone failed during set_config_object ", | |
| "with an object that is an uvm_component. Components cannot be cloned."}) | |
| return; | |
| end | |
| else begin | |
| `uvm_warning("INVCLN", {"Clone failed during set_config_object, ", | |
| "the original reference will be used for configuration. Check that ", | |
| "the create method for the object type is defined properly."}) | |
| end | |
| end | |
| else | |
| value = tmp; | |
| end | |
| uvm_config_object::set(this, inst_name, field_name, value); | |
| wrapper = new; | |
| wrapper.obj = value; | |
| wrapper.clone = clone; | |
| uvm_config_db#(uvm_config_object_wrapper)::set(this, inst_name, field_name, wrapper); | |
| endfunction | |
| // | |
| // get_config_int | |
| // | |
| function bit uvm_component::get_config_int (string field_name, | |
| inout uvm_bitstream_t value); | |
| return uvm_config_int::get(this, "", field_name, value); | |
| endfunction | |
| // | |
| // get_config_string | |
| // | |
| function bit uvm_component::get_config_string(string field_name, | |
| inout string value); | |
| return uvm_config_string::get(this, "", field_name, value); | |
| endfunction | |
| // | |
| // get_config_object | |
| // | |
| // | |
| // Note that this does not honor the set_config_object clone bit | |
| function bit uvm_component::get_config_object (string field_name, | |
| inout uvm_object value, | |
| input bit clone=1); | |
| if(!uvm_config_object::get(this, "", field_name, value)) begin | |
| return 0; | |
| end | |
| if(clone && value != null) begin | |
| value = value.clone(); | |
| end | |
| return 1; | |
| endfunction | |
| // check_config_usage | |
| // ------------------ | |
| function void uvm_component::check_config_usage ( bit recurse=1 ); | |
| uvm_resource_pool rp = uvm_resource_pool::get(); | |
| uvm_queue#(uvm_resource_base) rq; | |
| rq = rp.find_unused_resources(); | |
| if(rq.size() == 0) | |
| return; | |
| uvm_report_info("CFGNRD"," ::: The following resources have at least one write and no reads :::",UVM_INFO); | |
| rp.print_resources(rq, 1); | |
| endfunction | |
| // apply_config_settings | |
| // --------------------- | |
| function void uvm_component::apply_config_settings (bit verbose=0); | |
| uvm_resource_pool rp = uvm_resource_pool::get(); | |
| uvm_queue#(uvm_resource_base) rq; | |
| uvm_resource_base r; | |
| string name; | |
| string search_name; | |
| int unsigned i; | |
| int unsigned j; | |
| // populate an internal 'field_array' with list of | |
| // fields declared with `uvm_field macros (checking | |
| // that there aren't any duplicates along the way) | |
| __m_uvm_field_automation (null, UVM_CHECK_FIELDS, ""); | |
| // if no declared fields, nothing to do. | |
| if (__m_uvm_status_container.field_array.size() == 0) | |
| return; | |
| if(verbose) | |
| uvm_report_info("CFGAPL","applying configuration settings", UVM_NONE); | |
| // Note: the following is VERY expensive. Needs refactoring. Should | |
| // get config only for the specific field names in 'field_array'. | |
| // That's because the resource pool is organized first by field name. | |
| // Can further optimize by encoding the value for each 'field_array' | |
| // entry to indicate string, uvm_bitstream_t, or object. That way, | |
| // we call 'get' for specific fields of specific types rather than | |
| // the search-and-cast approach here. | |
| rq = rp.lookup_scope(get_full_name()); | |
| rp.sort_by_precedence(rq); | |
| // rq is in precedence order now, so we have to go through in reverse | |
| // order to do the settings. | |
| for(int i=rq.size()-1; i>=0; --i) begin | |
| r = rq.get(i); | |
| name = r.get_name(); | |
| // does name have brackets [] in it? | |
| for(j = 0; j < name.len(); j++) | |
| if(name[j] == "[" || name[j] == ".") | |
| break; | |
| // If it does have brackets then we'll use the name | |
| // up to the brackets to search __m_uvm_status_container.field_array | |
| if(j < name.len()) | |
| search_name = name.substr(0, j-1); | |
| else | |
| search_name = name; | |
| if(!uvm_resource_pool::m_has_wildcard_names && | |
| !__m_uvm_status_container.field_array.exists(search_name) && | |
| search_name != "recording_detail") | |
| continue; | |
| if(verbose) | |
| uvm_report_info("CFGAPL",$sformatf("applying configuration to field %s", name),UVM_NONE); | |
| begin | |
| uvm_resource#(uvm_bitstream_t) rbs; | |
| if($cast(rbs, r)) | |
| set_int_local(name, rbs.read(this)); | |
| else begin | |
| uvm_resource#(int) ri; | |
| if($cast(ri, r)) | |
| set_int_local(name, ri.read(this)); | |
| else begin | |
| uvm_resource#(int unsigned) riu; | |
| if($cast(riu, r)) | |
| set_int_local(name, riu.read(this)); | |
| else begin | |
| uvm_resource#(string) rs; | |
| if($cast(rs, r)) | |
| set_string_local(name, rs.read(this)); | |
| else begin | |
| uvm_resource#(uvm_config_object_wrapper) rcow; | |
| if ($cast(rcow, r)) begin | |
| uvm_config_object_wrapper cow = rcow.read(); | |
| set_object_local(name, cow.obj, cow.clone); | |
| end | |
| else begin | |
| uvm_resource#(uvm_object) ro; | |
| if($cast(ro, r)) begin | |
| set_object_local(name, ro.read(this), 0); | |
| end | |
| else if (verbose) begin | |
| uvm_report_info("CFGAPL", $sformatf("field %s has an unsupported type", name), UVM_NONE); | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| __m_uvm_status_container.field_array.delete(); | |
| endfunction | |
| // print_config | |
| // ------------ | |
| function void uvm_component::print_config(bit recurse = 0, audit = 0); | |
| uvm_resource_pool rp = uvm_resource_pool::get(); | |
| uvm_report_info("CFGPRT","visible resources:",UVM_INFO); | |
| rp.print_resources(rp.lookup_scope(get_full_name()), audit); | |
| if(recurse) begin | |
| uvm_component c; | |
| foreach(m_children[name]) begin | |
| c = m_children[name]; | |
| c.print_config(recurse, audit); | |
| end | |
| end | |
| endfunction | |
| // print_config_settings | |
| // --------------------- | |
| function void uvm_component::print_config_settings (string field="", | |
| uvm_component comp=null, | |
| bit recurse=0); | |
| static bit have_been_warned; | |
| if(!have_been_warned) begin | |
| uvm_report_warning("deprecated", "uvm_component::print_config_settings has been deprecated. Use print_config() instead"); | |
| have_been_warned = 1; | |
| end | |
| print_config(recurse, 1); | |
| endfunction | |
| // print_config_with_audit | |
| // ----------------------- | |
| function void uvm_component::print_config_with_audit(bit recurse = 0); | |
| print_config(recurse, 1); | |
| endfunction | |
| // do_print (override) | |
| // -------- | |
| function void uvm_component::do_print(uvm_printer printer); | |
| string v; | |
| super.do_print(printer); | |
| // It is printed only if its value is other than the default (UVM_NONE) | |
| if(uvm_verbosity'(recording_detail) != UVM_NONE) | |
| case (recording_detail) | |
| UVM_LOW : printer.print_generic("recording_detail", "uvm_verbosity", | |
| $bits(recording_detail), "UVM_LOW"); | |
| UVM_MEDIUM : printer.print_generic("recording_detail", "uvm_verbosity", | |
| $bits(recording_detail), "UVM_MEDIUM"); | |
| UVM_HIGH : printer.print_generic("recording_detail", "uvm_verbosity", | |
| $bits(recording_detail), "UVM_HIGH"); | |
| UVM_FULL : printer.print_generic("recording_detail", "uvm_verbosity", | |
| $bits(recording_detail), "UVM_FULL"); | |
| default : printer.print_int("recording_detail", recording_detail, | |
| $bits(recording_detail), UVM_DEC, , "integral"); | |
| endcase | |
| `ifndef UVM_NO_DEPRECATED | |
| if (enable_stop_interrupt != 0) begin | |
| printer.print_int("enable_stop_interrupt", enable_stop_interrupt, | |
| $bits(enable_stop_interrupt), UVM_BIN, ".", "bit"); | |
| end | |
| `endif | |
| endfunction | |
| // set_int_local (override) | |
| // ------------- | |
| function void uvm_component::set_int_local (string field_name, | |
| uvm_bitstream_t value, | |
| bit recurse=1); | |
| //call the super function to get child recursion and any registered fields | |
| super.set_int_local(field_name, value, recurse); | |
| //set the local properties | |
| if(uvm_is_match(field_name, "recording_detail")) | |
| recording_detail = value; | |
| endfunction | |
| // Internal methods for setting messagin parameters from command line switches | |
| typedef class uvm_cmdline_processor; | |
| // m_set_cl_msg_args | |
| // ----------------- | |
| function void uvm_component::m_set_cl_msg_args; | |
| m_set_cl_verb(); | |
| m_set_cl_action(); | |
| m_set_cl_sev(); | |
| endfunction | |
| // m_set_cl_verb | |
| // ------------- | |
| function void uvm_component::m_set_cl_verb; | |
| // _ALL_ can be used for ids | |
| // +uvm_set_verbosity=<comp>,<id>,<verbosity>,<phase|time>,<offset> | |
| // +uvm_set_verbosity=uvm_test_top.env0.agent1.*,_ALL_,UVM_FULL,time,800 | |
| static string values[$]; | |
| static bit first = 1; | |
| string args[$]; | |
| uvm_cmdline_processor clp = uvm_cmdline_processor::get_inst(); | |
| uvm_root top = uvm_root::get(); | |
| if(!values.size()) | |
| void'(uvm_cmdline_proc.get_arg_values("+uvm_set_verbosity=",values)); | |
| foreach(values[i]) begin | |
| m_verbosity_setting setting; | |
| args.delete(); | |
| uvm_split_string(values[i], ",", args); | |
| // Warning is already issued in uvm_root, so just don't keep it | |
| if(first && ( ((args.size() != 4) && (args.size() != 5)) || | |
| (clp.m_convert_verb(args[2], setting.verbosity) == 0)) ) | |
| begin | |
| values.delete(i); | |
| end | |
| else begin | |
| setting.comp = args[0]; | |
| setting.id = args[1]; | |
| void'(clp.m_convert_verb(args[2],setting.verbosity)); | |
| setting.phase = args[3]; | |
| setting.offset = 0; | |
| if(args.size() == 5) setting.offset = args[4].atoi(); | |
| if((setting.phase == "time") && (this == top)) begin | |
| m_time_settings.push_back(setting); | |
| end | |
| if (uvm_is_match(setting.comp, get_full_name()) ) begin | |
| if((setting.phase == "" || setting.phase == "build" || setting.phase == "time") && | |
| (setting.offset == 0) ) | |
| begin | |
| if(setting.id == "_ALL_") | |
| set_report_verbosity_level(setting.verbosity); | |
| else | |
| set_report_id_verbosity(setting.id, setting.verbosity); | |
| end | |
| else begin | |
| if(setting.phase != "time") begin | |
| m_verbosity_settings.push_back(setting); | |
| end | |
| end | |
| end | |
| end | |
| end | |
| // do time based settings | |
| if(this == top) begin | |
| fork begin | |
| time last_time = 0; | |
| if (m_time_settings.size() > 0) | |
| m_time_settings.sort() with ( item.offset ); | |
| foreach(m_time_settings[i]) begin | |
| uvm_component comps[$]; | |
| top.find_all(m_time_settings[i].comp,comps); | |
| #(m_time_settings[i].offset - last_time); | |
| last_time = m_time_settings[i].offset; | |
| if(m_time_settings[i].id == "_ALL_") begin | |
| foreach(comps[j]) begin | |
| comps[j].set_report_verbosity_level(m_time_settings[i].verbosity); | |
| end | |
| end | |
| else begin | |
| foreach(comps[j]) begin | |
| comps[j].set_report_id_verbosity(m_time_settings[i].id, m_time_settings[i].verbosity); | |
| end | |
| end | |
| end | |
| end join_none // fork begin | |
| end | |
| first = 0; | |
| endfunction | |
| // m_set_cl_action | |
| // --------------- | |
| function void uvm_component::m_set_cl_action; | |
| // _ALL_ can be used for ids or severities | |
| // +uvm_set_action=<comp>,<id>,<severity>,<action[|action]> | |
| // +uvm_set_action=uvm_test_top.env0.*,_ALL_,UVM_ERROR,UVM_NO_ACTION | |
| static string values[$]; | |
| string args[$]; | |
| uvm_severity sev; | |
| uvm_action action; | |
| if(!values.size()) | |
| void'(uvm_cmdline_proc.get_arg_values("+uvm_set_action=",values)); | |
| foreach(values[i]) begin | |
| uvm_split_string(values[i], ",", args); | |
| if(args.size() != 4) begin | |
| `uvm_warning("INVLCMDARGS", $sformatf("+uvm_set_action requires 4 arguments, only %0d given for command +uvm_set_action=%s, Usage: +uvm_set_action=<comp>,<id>,<severity>,<action[|action]>", args.size(), values[i])) | |
| values.delete(i); | |
| break; | |
| end | |
| if (!uvm_is_match(args[0], get_full_name()) ) break; | |
| if((args[2] != "_ALL_") && !uvm_string_to_severity(args[2], sev)) begin | |
| `uvm_warning("INVLCMDARGS", $sformatf("Bad severity argument \"%s\" given to command +uvm_set_action=%s, Usage: +uvm_set_action=<comp>,<id>,<severity>,<action[|action]>", args[2], values[i])) | |
| values.delete(i); | |
| break; | |
| end | |
| if(!uvm_string_to_action(args[3], action)) begin | |
| `uvm_warning("INVLCMDARGS", $sformatf("Bad action argument \"%s\" given to command +uvm_set_action=%s, Usage: +uvm_set_action=<comp>,<id>,<severity>,<action[|action]>", args[3], values[i])) | |
| values.delete(i); | |
| break; | |
| end | |
| if(args[1] == "_ALL_") begin | |
| if(args[2] == "_ALL_") begin | |
| set_report_severity_action(UVM_INFO, action); | |
| set_report_severity_action(UVM_WARNING, action); | |
| set_report_severity_action(UVM_ERROR, action); | |
| set_report_severity_action(UVM_FATAL, action); | |
| end | |
| else begin | |
| set_report_severity_action(sev, action); | |
| end | |
| end | |
| else begin | |
| if(args[2] == "_ALL_") begin | |
| set_report_id_action(args[1], action); | |
| end | |
| else begin | |
| set_report_severity_id_action(sev, args[1], action); | |
| end | |
| end | |
| end | |
| endfunction | |
| // m_set_cl_sev | |
| // ------------ | |
| function void uvm_component::m_set_cl_sev; | |
| // _ALL_ can be used for ids or severities | |
| // +uvm_set_severity=<comp>,<id>,<orig_severity>,<new_severity> | |
| // +uvm_set_severity=uvm_test_top.env0.*,BAD_CRC,UVM_ERROR,UVM_WARNING | |
| static string values[$]; | |
| static bit first = 1; | |
| string args[$]; | |
| uvm_severity orig_sev, sev; | |
| if(!values.size()) | |
| void'(uvm_cmdline_proc.get_arg_values("+uvm_set_severity=",values)); | |
| foreach(values[i]) begin | |
| uvm_split_string(values[i], ",", args); | |
| if(args.size() != 4) begin | |
| `uvm_warning("INVLCMDARGS", $sformatf("+uvm_set_severity requires 4 arguments, only %0d given for command +uvm_set_severity=%s, Usage: +uvm_set_severity=<comp>,<id>,<orig_severity>,<new_severity>", args.size(), values[i])) | |
| values.delete(i); | |
| break; | |
| end | |
| if (!uvm_is_match(args[0], get_full_name()) ) break; | |
| if(args[2] != "_ALL_" && !uvm_string_to_severity(args[2], orig_sev)) begin | |
| `uvm_warning("INVLCMDARGS", $sformatf("Bad severity argument \"%s\" given to command +uvm_set_severity=%s, Usage: +uvm_set_severity=<comp>,<id>,<orig_severity>,<new_severity>", args[2], values[i])) | |
| values.delete(i); | |
| break; | |
| end | |
| if(!uvm_string_to_severity(args[3], sev)) begin | |
| `uvm_warning("INVLCMDARGS", $sformatf("Bad severity argument \"%s\" given to command +uvm_set_severity=%s, Usage: +uvm_set_severity=<comp>,<id>,<orig_severity>,<new_severity>", args[3], values[i])) | |
| values.delete(i); | |
| break; | |
| end | |
| if(args[1] == "_ALL_" && args[2] == "_ALL_") begin | |
| set_report_severity_override(UVM_INFO,sev); | |
| set_report_severity_override(UVM_WARNING,sev); | |
| set_report_severity_override(UVM_ERROR,sev); | |
| set_report_severity_override(UVM_FATAL,sev); | |
| end | |
| else if(args[1] == "_ALL_") begin | |
| set_report_severity_override(orig_sev,sev); | |
| end | |
| else if(args[2] == "_ALL_") begin | |
| set_report_severity_id_override(UVM_INFO,args[1],sev); | |
| set_report_severity_id_override(UVM_WARNING,args[1],sev); | |
| set_report_severity_id_override(UVM_ERROR,args[1],sev); | |
| set_report_severity_id_override(UVM_FATAL,args[1],sev); | |
| end | |
| else begin | |
| set_report_severity_id_override(orig_sev,args[1],sev); | |
| end | |
| end | |
| endfunction | |
| // m_apply_verbosity_settings | |
| // -------------------------- | |
| function void uvm_component::m_apply_verbosity_settings(uvm_phase phase); | |
| foreach(m_verbosity_settings[i]) begin | |
| if(phase.get_name() == m_verbosity_settings[i].phase) begin | |
| if( m_verbosity_settings[i].offset == 0 ) begin | |
| if(m_verbosity_settings[i].id == "_ALL_") | |
| set_report_verbosity_level(m_verbosity_settings[i].verbosity); | |
| else | |
| set_report_id_verbosity(m_verbosity_settings[i].id, m_verbosity_settings[i].verbosity); | |
| end | |
| else begin | |
| process p = process::self(); | |
| string p_rand = p.get_randstate(); | |
| fork begin | |
| m_verbosity_setting setting = m_verbosity_settings[i]; | |
| #setting.offset; | |
| if(setting.id == "_ALL_") | |
| set_report_verbosity_level(setting.verbosity); | |
| else | |
| set_report_id_verbosity(setting.id, setting.verbosity); | |
| end join_none; | |
| p.set_randstate(p_rand); | |
| end | |
| // Remove after use | |
| m_verbosity_settings.delete(i); | |
| end | |
| end | |
| endfunction | |
| // m_do_pre_abort | |
| // -------------- | |
| function void uvm_component::m_do_pre_abort; | |
| foreach(m_children[i]) | |
| m_children[i].m_do_pre_abort(); | |
| pre_abort(); | |
| endfunction |