| // $Id: //dvt/vtech/dev/main/ovm/src/base/ovm_component.svh#56 $ | |
| //------------------------------------------------------------------------------ | |
| // Copyright 2007-2009 Mentor Graphics Corporation | |
| // Copyright 2007-2009 Cadence Design Systems, 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. | |
| //------------------------------------------------------------------------------ | |
| `ifndef OVM_COMPONENT_SVH | |
| `define OVM_COMPONENT_SVH | |
| typedef class ovm_objection; | |
| `include "base/ovm_config.svh" | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: ovm_component | |
| // | |
| // The ovm_component class is the root base class for OVM components. In | |
| // addition to the features inherited from <ovm_object> and <ovm_report_object>, | |
| // ovm_component provides the following interfaces: | |
| // | |
| // Hierarchy - provides methods for searching and traversing the component | |
| // hierarchy. | |
| // | |
| // Configuration - provides methods for configuring component topology and other | |
| // parameters ahead of and during component construction. | |
| // | |
| // Phasing - defines a phased test flow that all components follow. Derived | |
| // components implement one or more of the predefined phase callback methods | |
| // to perform their function. During simulation, all components' callbacks | |
| // are executed in precise order. Phasing is controlled by ovm_top, the | |
| // singleton instance of <ovm_root>. | |
| // | |
| // Reporting - provides a convenience interface to the <ovm_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 <ovm_factory>. The factory | |
| // is used to create new components and other objects based on type-wide and | |
| // instance-specific configuration. | |
| // | |
| // The ovm_component is automatically seeded during construction using OVM | |
| // seeding, if enabled. All other objects must be manually reseeded, if | |
| // appropriate. See <ovm_object::reseed> for more information. | |
| // | |
| //------------------------------------------------------------------------------ | |
| virtual class ovm_component extends ovm_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, ~ovm_top~. | |
| // | |
| // All classes derived from ovm_component must call super.new(name,parent). | |
| extern function new (string name, ovm_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 ovm_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 <ovm_object::get_name>. | |
| extern virtual function string get_full_name (); | |
| // Function: get_child | |
| extern function ovm_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 <ovm_object::print> for each child: | |
| // | |
| //| string name; | |
| //| ovm_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. | |
| 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 ovm_component lookup (string name); | |
| //---------------------------------------------------------------------------- | |
| // Group: Phasing Interface | |
| //---------------------------------------------------------------------------- | |
| // Components execute their behavior in strictly ordered, pre-defined phases. | |
| // Each phase is defined by its own method, which derived components can | |
| // override to incorporate component-specific behavior. During simulation, | |
| // the phases are executed one by one, where one phase must complete before | |
| // the next phase begins. The following briefly describe each phase: | |
| // | |
| // new - Also known as the ~constructor~, the component does basic | |
| // initialization of any members not subject to configuration. | |
| // | |
| // build - The component constructs its children. It uses the get_config | |
| // interface to obtain any configuration for itself, the set_config | |
| // interface to set any configuration for its own children, and the | |
| // factory interface for actually creating the children and other | |
| // objects it might need. | |
| // | |
| // connect - The component now makes connections (binds TLM ports and | |
| // exports) from child-to-child or from child-to-self (i.e. to promote a | |
| // child port or export up the hierarchy for external access. Afterward, | |
| // all connections are checked via <resolve_bindings> before entering | |
| // the <end_of_elaboration> phase. | |
| // | |
| // end_of_elaboration - At this point, the entire testbench environment has | |
| // been built and connected. No new components and connections may be | |
| // created from this point forward. Components can do final checks for | |
| // proper connectivity, and it can initiate communication with other tools | |
| // that require stable, quasi-static component structure.. | |
| // | |
| // start_of_simulation - The simulation is about to begin, and this phase | |
| // can be used to perform any pre-run activity such as displaying banners, | |
| // printing final testbench topology and configuration information. | |
| // | |
| // run - This is where verification takes place. It is the only predefined, | |
| // time-consuming phase. A component's primary function is implemented | |
| // in the <run> task. Other processes may be forked if desired. When | |
| // a component returns from its run task, it does not signify completion | |
| // of its run phase. Any processes that it may have forked ~continue to | |
| // run~. The run phase terminates in one of four ways: | |
| // | |
| // stop - When a component's <enable_stop_interrupt> bit is set and | |
| // <global_stop_request> is called, the component's <stop> task | |
| // is called. Components can implement stop to allow completion | |
| // of in-progress transactions, <flush> queues, etc. Upon return | |
| // from stop() by all enabled components, a <do_kill_all> is | |
| // issued. If the <ovm_test_done_objection> is being used, | |
| // this stopping procedure is deferred until all outstanding | |
| // objections on <ovm_test_done> have been dropped. | |
| // | |
| // objections dropped - The <ovm_test_done_objection> will implicitly | |
| // call <global_stop_request> when all objections to ending the | |
| // phase are dropped. The stop procedure described above is | |
| // then allowed to proceed normally. | |
| // | |
| // kill - When called, all component's <run> processes are killed | |
| // immediately. While kill can be called directly, it is | |
| // recommended that components use the stopping mechanism, | |
| // which affords a more ordered and safe shut-down. | |
| // | |
| // timeout - If a timeout was set, then the phase ends if it expires | |
| // before either of the above occur. Without a stop, kill, or | |
| // timeout, simulation can continue "forever", or the simulator | |
| // may end simulation prematurely if it determines that | |
| // all processes are waiting. | |
| // | |
| // extract - This phase can be used to extract simulation results from | |
| // coverage collectors and scoreboards, collect status/error counts, | |
| // statistics, and other information from components in bottom-up order. | |
| // Being a separate phase, extract ensures all relevant data from | |
| // potentially independent sources (i.e. other components) are collected | |
| // before being checked in the next phase. | |
| // | |
| // check - Having extracted vital simulation results in the previous phase, | |
| // the check phase can be used to validate such data and determine | |
| // the overall simulation outcome. It too executes bottom-up. | |
| // | |
| // report - Finally, the report phase is used to output results to files | |
| // and/or the screen. | |
| // | |
| // All task-based phases (<run> is the only pre-defined task phase) will run | |
| // forever until killed or stopped via <kill> or <global_stop_request>. | |
| // The latter causes each component's <stop> task to get called back if | |
| // its <enable_stop_interrupt> bit is set. After all components' stop tasks | |
| // return, the OVM will end the phase. | |
| // | |
| // Note- the post_new, export_connections, import_connections, configure, | |
| // and pre_run phases are deprecated. <build> replaces post_new, <connect> | |
| // replaces both import_ and export_connections, and <start_of_simulation> | |
| // replaces pre_run. | |
| // | |
| //---------------------------------------------------------------------------- | |
| // Function: build | |
| // | |
| // The build phase callback is the first of several methods automatically | |
| // called during the course of simulation. The build phase is the second of | |
| // a two-pass construction process (the first is the built-in new method). | |
| // | |
| // The build phase can add additional hierarchy based on configuration | |
| // information not available at time of initial construction. | |
| // Any override should call super.build(). | |
| // | |
| // Starting after the initial construction phase (<new> method) has completed, | |
| // the build phase consists of calling all components' build methods | |
| // recursively top-down, i.e., parents' build are executed before the | |
| // children. This is the only phase that executes top-down. | |
| // | |
| // The build phase of the ovm_component class executes 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() in the subtype's build method. | |
| // | |
| // See <ovm_phase> for more information on phases. | |
| extern virtual function void build (); | |
| // Function: connect | |
| // | |
| // The connect phase callback is one of several methods automatically called | |
| // during the course of simulation. | |
| // | |
| // Starting after the <build> phase has completed, the connect phase consists | |
| // of calling all components' connect methods recursively in depth-first, | |
| // bottom-up order, i.e., children are executed before their parents. | |
| // | |
| // Generally, derived classes should override this method to make port and | |
| // export connections via the similarly-named <ovm_port_base #(IF)::connect> | |
| // method. Any override should call super.connect(). | |
| // | |
| // This method should never be called directly. | |
| // | |
| // See <ovm_phase> for more information on phases. | |
| extern virtual function void connect (); | |
| // Function: end_of_elaboration | |
| // | |
| // The end_of_elaboration phase callback is one of several methods | |
| // automatically called during the course of simulation. | |
| // | |
| // Starting after the <connect> phase has completed, this phase consists of | |
| // calling all components' end_of_elaboration methods recursively in | |
| // depth-first, bottom-up order, i.e., children are executed before their | |
| // parents. | |
| // | |
| // Generally, derived classes should override this method to perform any | |
| // checks on the elaborated hierarchy before the simulation phases begin. | |
| // Any override should call super.end_of_elaboration(). | |
| // | |
| // This method should never be called directly. | |
| // | |
| // See <ovm_phase> for more information on phases. | |
| extern virtual function void end_of_elaboration (); | |
| // Function: start_of_simulation | |
| // | |
| // The start_of_simulation phase callback is one of several methods | |
| // automatically called during the course of simulation. | |
| // | |
| // Starting after the <end_of_elaboration> phase has completed, this phase | |
| // consists of calling all components' start_of_simulation methods recursively | |
| // in depth-first, bottom-up order, i.e. children are executed before their | |
| // parents. | |
| // | |
| // Generally, derived classes should override this method to perform component- | |
| // specific pre-run operations, such as discovery of the elaborated hierarchy, | |
| // printing banners, etc. Any override should call super.start_of_simulation(). | |
| // | |
| // This method should never be called directly. | |
| // | |
| // See <ovm_phase> for more information on phases. | |
| extern virtual function void start_of_simulation (); | |
| // Task: run | |
| // | |
| // The run phase callback is the only predefined phase that is time-consuming, | |
| // i.e., task-based. It executes after the <start_of_simulation> phase has | |
| // completed. Derived classes should override this method to perform the bulk | |
| // of its functionality, forking additional processes if needed. | |
| // | |
| // In the run phase, all components' run tasks are forked as independent | |
| // processes. Returning from its run task does not signify completion of a | |
| // component's run phase; any processes forked by run continue to run. | |
| // | |
| // The run phase terminates in one of four ways. | |
| // | |
| // 1 - explicit call to <global_stop_request> - | |
| // When <global_stop_request> is called, an ordered shut-down for the | |
| // currently running phase begins. First, all enabled components' status | |
| // tasks are called bottom-up, i.e., childrens' <stop> tasks are called before | |
| // the parent's. A component is enabled by its enable_stop_interrupt bit. | |
| // Each component can implement stop to allow completion of in-progress | |
| // transactions, flush queues, and other shut-down activities. Upon return | |
| // from stop by all enabled components, the recursive do_kill_all is called | |
| // on all top-level component(s). If the <ovm_test_done> objection> is being | |
| // used, this stopping procedure is deferred until all outstanding objections | |
| // on <ovm_test_done> have been dropped. | |
| // | |
| // 2 - all objections to <ovm_test_done> have been dropped - | |
| // When all objections on the <ovm_test_done> objection have been dropped, | |
| // <global_stop_request> is called automatically, thus kicking off the | |
| // stopping procedure described above. See <ovm_objection> for details on | |
| // using the objection mechanism. | |
| // | |
| // 3 - explicit call to <kill> or <do_kill_all> - | |
| // When <kill> is called, this component's run processes are killed immediately. | |
| // The <do_kill_all> methods applies to this component and all its | |
| // descendants. Use of this method is not recommended. It is better to use | |
| // the stopping mechanism, which affords a more ordered, safer shut-down. | |
| // | |
| // 4 - timeout - | |
| // The phase ends if the timeout expires before an explicit call to | |
| // <global_stop_request> or kill. By default, the timeout is set to near the | |
| // maximum simulation time possible. You may override this via | |
| // <set_global_timeout>, but you cannot disable the timeout completely. | |
| // | |
| // If the default timeout occurs in your simulation, or if simulation never | |
| // ends despite completion of your test stimulus, then it usually indicates | |
| // a missing call to <global_stop_request>. | |
| // | |
| // The run task should never be called directly. | |
| // | |
| // See <ovm_phase> for more information on phases. | |
| extern virtual task run (); | |
| // Function: extract | |
| // | |
| // The extract phase callback is one of several methods automatically called | |
| // during the course of simulation. | |
| // | |
| // Starting after the <run> phase has completed, the extract phase consists of | |
| // calling all components' extract methods recursively in depth-first, | |
| // bottom-up order, i.e., children are executed before their parents. | |
| // | |
| // Generally, derived classes should override this method to collect | |
| // information for the subsequent <check> phase when such information needs to | |
| // be collected in a hierarchical, bottom-up manner. Any override should | |
| // call super.extract(). | |
| // | |
| // This method should never be called directly. | |
| // | |
| // See <ovm_phase> for more information on phases. | |
| extern virtual function void extract (); | |
| // Function: check | |
| // | |
| // The check phase callback is one of several methods automatically called | |
| // during the course of simulation. | |
| // | |
| // Starting after the <extract> phase has completed, the check phase consists of | |
| // calling all components' check methods recursively in depth-first, bottom-up | |
| // order, i.e., children are executed before their parents. | |
| // | |
| // Generally, derived classes should override this method to perform component | |
| // specific, end-of-test checks. Any override should call super.check(). | |
| // | |
| // This method should never be called directly. | |
| // | |
| // See <ovm_phase> for more information on phases. | |
| extern virtual function void check (); | |
| // Function: report | |
| // | |
| // The report phase callback is the last of several predefined phase | |
| // methods automatically called during the course of simulation. | |
| // | |
| // Starting after the <check> phase has completed, the report phase consists | |
| // of calling all components' report methods recursively in depth-first, | |
| // bottom-up order, i.e., children are executed before their parents. | |
| // | |
| // Generally, derived classes should override this method to perform | |
| // component-specific reporting of test results. Any override should | |
| // call super.report(). | |
| // | |
| // This method should never be called directly. | |
| // | |
| // See <ovm_phase> for more information on phases. | |
| extern virtual function void report (); | |
| // Task: suspend | |
| // | |
| // Suspends the process tree spawned from this component's currently | |
| // executing task-based phase, e.g. <run>. | |
| extern virtual task suspend (); | |
| // Task: resume | |
| // | |
| // Resumes the process tree spawned from this component's currently | |
| // executing task-based phase, e.g. <run>. | |
| extern virtual task resume (); | |
| // Function: status | |
| // | |
| // Returns the status of the parent process associated with the currently | |
| // running task-based phase, e.g., <run>. | |
| extern function string status (); | |
| // Function: kill | |
| // | |
| // Kills the process tree associated with this component's currently running | |
| // task-based phase, e.g., <run>. | |
| // | |
| // An alternative mechanism for stopping the <run> phase is the stop request. | |
| // Calling <global_stop_request> causes all components' run processes to be | |
| // killed, but only after all components have had the opportunity to complete | |
| // in progress transactions and shutdown cleanly via their <stop> tasks. | |
| extern virtual function void kill (); | |
| // Function: do_kill_all | |
| // | |
| // Recursively calls <kill> on this component and all its descendants, | |
| // which abruptly ends the currently running task-based phase, e.g., <run>. | |
| // See <run> for better options to ending a task-based phase. | |
| extern virtual function void do_kill_all (); | |
| // Task: stop | |
| // | |
| // The stop 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 to finish the currently executing | |
| // transaction, flush the queue, or perform other cleanup. Upon return from | |
| // its stop, a component signals it is ready to be stopped. | |
| // | |
| // The stop method will not be called if <enable_stop_interrupt> is 0. | |
| // | |
| // The default implementation of stop is empty, i.e., it will return immediately. | |
| // | |
| // This method should never be called directly. | |
| extern virtual task stop (string ph_name); | |
| // Variable: enable_stop_interrupt | |
| // | |
| // 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. | |
| protected int enable_stop_interrupt = 0; | |
| // 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; | |
| // Function: set_config_int | |
| extern virtual function void set_config_int (string inst_name, | |
| string field_name, | |
| ovm_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 | |
| // ovm_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 <ovm_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. | |
| // | |
| // The following message tags are used for configuration setting. You can | |
| // use the standard ovm report messaging interface to control these | |
| // messages. | |
| // CFGNTS -- The configuration setting was not used by any component. | |
| // This is a warning. | |
| // CFGOVR -- The configuration setting was overridden by a setting above. | |
| // CFGSET -- The configuration setting was used at least once. | |
| // | |
| // | |
| // 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, | |
| ovm_object value, | |
| bit clone=1); | |
| // Function: get_config_int | |
| extern virtual function bit get_config_int (string field_name, | |
| inout ovm_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 <ovm_object>, you must provide an ovm_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 ovm_object. | |
| // | |
| //| class mycomponent extends ovm_component; | |
| //| | |
| //| local myobj_t data; | |
| //| | |
| //| function void build(); | |
| //| ovm_object tmp; | |
| //| super.build(); | |
| //| 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> method. If you want to retain | |
| // any base functionality, you must call super.build(). | |
| // | |
| // 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 ovm_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. | |
| // | |
| // Additional detail is provided by the following message tags: | |
| // * CFGOVR -- lists all configuration settings that have been overridden | |
| // from above. | |
| // * CFGSET -- lists all configuration settings that have been set. | |
| // | |
| // To get all configuration information prior to the run phase, do something | |
| // like this in your top object: | |
| //| function void start_of_simulation(); | |
| //| set_report_id_action_hier(CFGOVR, OVM_DISPLAY); | |
| //| set_report_id_action_hier(CFGSET, OVM_DISPLAY); | |
| //| 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 <ovm_component::build>. | |
| // | |
| // 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 `ovm_*_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() method should be overloaded and you should not call | |
| // super.build(). If this case, you must also set the m_build_done | |
| // bit. 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. | |
| extern function void print_config_settings (string field="", | |
| ovm_component comp=null, | |
| 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 = 0; | |
| //---------------------------------------------------------------------------- | |
| // Group: Objection Interface | |
| //---------------------------------------------------------------------------- | |
| // | |
| // These methods provide object level hooks into the <ovm_objection> | |
| // mechanism. | |
| // | |
| //---------------------------------------------------------------------------- | |
| // Function: raised | |
| // | |
| // The raised callback is called when a decendant of the component instance | |
| // raises the specfied ~objection~. The ~source_obj~ is the object which | |
| // originally raised the object. ~count~ is an optional count that was used | |
| // to indicate a number of objections which were raised. | |
| virtual function void raised (ovm_objection objection, ovm_object source_obj, | |
| int count); | |
| endfunction | |
| // Function: dropped | |
| // | |
| // The dropped callback is called when a decendant of the component instance | |
| // raises the specfied ~objection~. The ~source_obj~ is the object which | |
| // originally dropped the object. ~count~ is an optional count that was used | |
| // to indicate a number of objections which were dropped. | |
| virtual function void dropped (ovm_objection objection, ovm_object source_obj, | |
| int count); | |
| endfunction | |
| // Task: all_dropped | |
| // | |
| // The all_dropped callback is called when a decendant of the component instance | |
| // raises the specfied ~objection~. The ~source_obj~ is the object which | |
| // originally all_dropped the object. ~count~ is an optional count that was used | |
| // to indicate a number of objections which were dropped. This callback is | |
| // time-consuming and the all_dropped conditional will not be propagated | |
| // up to the object's parent until the callback returns. | |
| virtual task all_dropped (ovm_objection objection, ovm_object source_obj, | |
| int count); | |
| endtask | |
| //---------------------------------------------------------------------------- | |
| // Group: Factory Interface | |
| //---------------------------------------------------------------------------- | |
| // | |
| // The factory interface provides convenient access to a portion of OVM's | |
| // <ovm_factory> interface. For creating new objects and components, the | |
| // preferred method of accessing the factory is via the object or component | |
| // wrapper (see <ovm_component_registry #(T,Tname)> and | |
| // <ovm_object_registry #(T,Tname)>). The wrapper also provides functions | |
| // for setting type and instance overrides. | |
| // | |
| //---------------------------------------------------------------------------- | |
| // Function: create_component | |
| // | |
| // A convenience function for <ovm_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 <ovm_factory> for | |
| // details on factory operation. | |
| extern function ovm_component create_component (string requested_type_name, | |
| string name); | |
| // Function: create_object | |
| // | |
| // A convenience function for <ovm_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 | |
| // <ovm_factory> for details on factory operation. | |
| extern function ovm_object create_object (string requested_type_name, | |
| string name=""); | |
| // Function: set_type_override_by_type | |
| // | |
| // A convenience function for <ovm_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 <ovm_factory::create_object_by_type> or | |
| // <ovm_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 | |
| (ovm_object_wrapper original_type, | |
| ovm_object_wrapper override_type, | |
| bit replace=1); | |
| // Function: set_inst_override_by_type | |
| // | |
| // A convenience function for <ovm_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 <ovm_factory::create_object_by_type> or | |
| // <ovm_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, or by directly calling type::type_id::get(), where type is the | |
| // user type and type_id is the name of the typedef to | |
| // <ovm_object_registry #(T,Tname)> or <ovm_component_registry #(T,Tname)>. | |
| // | |
| // If you are employing the `ovm_*_utils macros, the typedef and the get_type | |
| // method will be implemented for you. | |
| // | |
| // The following example shows `ovm_*_utils usage: | |
| // | |
| //| class comp extends ovm_component; | |
| //| `ovm_component_utils(comp) | |
| //| ... | |
| //| endclass | |
| //| | |
| //| class mycomp extends ovm_component; | |
| //| `ovm_component_utils(mycomp) | |
| //| ... | |
| //| endclass | |
| //| | |
| //| class block extends ovm_component; | |
| //| `ovm_component_utils(block) | |
| //| comp c_inst; | |
| //| virtual function void build(); | |
| //| 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, | |
| ovm_object_wrapper original_type, | |
| ovm_object_wrapper override_type); | |
| // Function: set_type_override | |
| // | |
| // A convenience function for <ovm_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 <ovm_factory::set_inst_override_by_type>, 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 | |
| // <ovm_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_severity_action_hier | |
| extern function void set_report_severity_action_hier (ovm_severity severity, | |
| ovm_action action); | |
| // Function: set_report_id_action_hier | |
| extern function void set_report_id_action_hier (string id, | |
| ovm_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 | |
| // <ovm_report_handler>. | |
| extern function void set_report_severity_id_action_hier(ovm_severity severity, | |
| string id, | |
| ovm_action action); | |
| // Function: set_report_default_file_hier | |
| extern function void set_report_default_file_hier (OVM_FILE file); | |
| // Function: set_report_severity_file_hier | |
| extern function void set_report_severity_file_hier (ovm_severity severity, | |
| OVM_FILE file); | |
| // Function: set_report_id_file_hier | |
| extern function void set_report_id_file_hier (string id, | |
| OVM_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 <ovm_report_handler>. | |
| extern function void set_report_severity_id_file_hier(ovm_severity severity, | |
| string id, | |
| OVM_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 <ovm_report_handler> for a list of predefined message verbosity levels | |
| // and their meaning. | |
| extern function void set_report_verbosity_level_hier (int verbosity); | |
| //---------------------------------------------------------------------------- | |
| // 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 <ovm_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 (ovm_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 (ovm_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 <ovm_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 != OVM_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 (ovm_transaction tr, | |
| string stream_name="main", | |
| string label="", | |
| string desc="", | |
| time begin_time=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 (ovm_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 (ovm_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 <ovm_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 | |
| // `ovm_*_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 (ovm_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 (ovm_transaction tr, | |
| integer tr_handle); | |
| // Function: record_error_tr | |
| // | |
| // This function marks an error transaction by a component. Properties of the | |
| // given ovm_object, ~info~, as implemented in its <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", | |
| ovm_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", | |
| ovm_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; | |
| //---------------------------------------------------------------------------- | |
| // 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. | |
| //---------------------------------------------------------------------------- | |
| extern local function void m_component_path (ref ovm_component path[$]); | |
| extern local function void m_get_config_matches | |
| (ref ovm_config_setting cfg_matches[$], | |
| input ovm_config_setting::ovm_config_type cfgtype, | |
| string field_name); | |
| /*protected*/ ovm_component m_parent; | |
| protected ovm_component m_children[string]; | |
| protected ovm_component m_children_by_handle[ovm_component]; | |
| extern local function bit m_add_child (ovm_component child); | |
| extern virtual local function void m_set_full_name (); | |
| extern virtual function void do_func_phase (ovm_phase phase); | |
| extern virtual task do_task_phase (ovm_phase phase); | |
| extern function void do_resolve_bindings (); | |
| extern function void do_flush(); | |
| extern virtual function void flush (); | |
| ovm_phase m_curr_phase=null; | |
| protected ovm_config_setting m_configuration_table[$]; | |
| protected bit m_build_done=0; | |
| extern local function void m_extract_name(string name , | |
| output string leaf , | |
| output string remainder ); | |
| local static bit m_phases_loaded = 0; | |
| // overridden to disable | |
| extern virtual function ovm_object create (string name=""); | |
| extern virtual function ovm_object clone (); | |
| local integer m_stream_handle[string]; | |
| local integer m_tr_h[ovm_transaction]; | |
| extern protected function integer m_begin_tr (ovm_transaction tr, | |
| integer parent_handle=0, bit has_parent=0, | |
| string stream_name="main", string label="", | |
| string desc="", time begin_time=0); | |
| `ifndef INCA | |
| protected process m_phase_process; | |
| `endif | |
| protected event m_kill_request; | |
| string m_name; | |
| protected ovm_event_pool event_pool; | |
| extern virtual task restart (); | |
| //---------------------------------------------------------------------------- | |
| // DEPRECATED MEMBERS | |
| // *** Do not use in new code *** | |
| // Convert existing code when appropriate. | |
| //---------------------------------------------------------------------------- | |
| // Deprecated static methods: | |
| // | |
| // global_stop_request | |
| // replaced by ovm_top.stop_request | |
| // | |
| // Deprecated phases: | |
| // | |
| // post_new | |
| // replaced by build (top-down) | |
| // | |
| // import/export_connections | |
| // Consolidated into the connect phase; deferred binding enforcement | |
| // via resolve_bindings allows connections to be order-independent | |
| // | |
| // pre_run | |
| // replaced by start_of_simulation | |
| //---------------------------------------------------------------------------- | |
| extern static function void global_stop_request(); | |
| extern virtual function void post_new (); | |
| extern virtual function void import_connections (); | |
| extern virtual function void configure (); | |
| extern virtual function void export_connections (); | |
| extern virtual function void pre_run (); | |
| extern static function ovm_component find_component (string comp_match); | |
| extern static function void find_components (string comp_match, | |
| ref ovm_component comps[$]); | |
| extern static function ovm_component get_component (int ele); | |
| extern static function int get_num_components (); | |
| `include "compatibility/urm_message_compatibility.svh" | |
| endclass : ovm_component | |
| // for backward compatibility | |
| typedef ovm_component ovm_threaded_component; | |
| `endif // OVM_COMPONENT_SVH | |