# 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
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.

Summary

uvm_component
The uvm_component class is the root base class for UVM components.
Class Hierarchy
uvm_void
uvm_object
uvm_report_object
uvm_component
Class Declaration
> virtual class uvm_component extends uvm_report_object
new | Creates a new component with the given leaf instance name and handle to its parent.
Hierarchy Interface | These methods provide user access to information about the component hierarchy, i.e., topology.
get_parent | Returns a handle to this component’s parent, or null if it has no parent.
get_full_name | Returns the full hierarchical name of this object.
get_children | This function populates the end of the children array with the list of this component’s children.
get_child |
get_next_child |
get_first_child | These methods are used to iterate through this component’s children, if any.
get_num_children | Returns the number of this component’s children.
has_child | Returns 1 if this component has a child with the given name, 0 otherwise.
lookup | Looks for a component with the given hierarchical name relative to this component.
get_depth | Returns the component’s depth from the root level.
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.
build_phase | The uvm_build_phase phase implementation method.
connect_phase | The uvm_connect_phase phase implementation method.
end_of_elaboration_phase | The uvm_end_of_elaboration_phase phase implementation method.
start_of_simulation_phase | The uvm_start_of_simulation_phase phase implementation method.
run_phase | The uvm_run_phase phase implementation method.
pre_reset_phase | The uvm_pre_reset_phase phase implementation method.
reset_phase | The uvm_reset_phase phase implementation method.
post_reset_phase | The uvm_post_reset_phase phase implementation method.
pre_configure_phase | The uvm_pre_configure_phase phase implementation method.
configure_phase | The uvm_configure_phase phase implementation method.
post_configure_phase | The uvm_post_configure_phase phase implementation method.
pre_main_phase | The uvm_pre_main_phase phase implementation method.
main_phase | The uvm_main_phase phase implementation method.
post_main_phase | The uvm_post_main_phase phase implementation method.
pre_shutdown_phase | The uvm_pre_shutdown_phase phase implementation method.
shutdown_phase | The uvm_shutdown_phase phase implementation method.
post_shutdown_phase | The uvm_post_shutdown_phase phase implementation method.
extract_phase | The uvm_extract_phase phase implementation method.
check_phase | The uvm_check_phase phase implementation method.
report_phase | The uvm_report_phase phase implementation method.
final_phase | The uvm_final_phase phase implementation method.
phase_started | Invoked at the start of each phase.
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.
phase_ended | Invoked at the end of each phase.
set_domain | Apply a phase domain to this component and, if hier is set, recursively to all its children.
get_domain | Return handle to the phase domain set on this component
define_domain | Builds custom phase schedules into the provided domain handle.
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
suspend | Suspend this component.
resume | Resume this component.
resolve_bindings | Processes all port, export, and imp connections.
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).
check_config_usage | Check all configuration settings in a components configuration table to determine if the setting has been used, overridden or not used.
apply_config_settings | Searches for all config settings matching this component’s instance path.
print_config_settings | Called without arguments, print_config_settings prints all configuration information for this component, as set by previous calls to uvm_config_db::set().
print_config | Print_config_settings prints all configuration information for this component, as set by previous calls to uvm_config_db::set() and exports to the resources pool.
print_config_with_audit | Operates the same as print_config except that the audit bit is forced to 1.
print_config_matches | Setting this static variable causes uvm_config_db::get() to print info about matching configuration settings as they are being applied.
Objection Interface | These methods provide object level hooks into the uvm_objection mechanism.
raised | The raised callback is called when this or a descendant of this component instance raises the specified objection.
dropped | The dropped callback is called when this or a descendant of this component instance drops the specified objection.
all_dropped | The all_droppped callback is called when all objections have been dropped by this component and all its descendants.
Factory Interface | The factory interface provides convenient access to a portion of UVM’s uvm_factory interface.
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.
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.
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.
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.
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.
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.
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.
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.
set_report_id_verbosity_hier |
set_report_severity_id_verbosity_hier | These methods recursively associate the specified verbosity with reports of the given severity, id, or severity-id pair.
set_report_severity_action_hier |
set_report_id_action_hier |
set_report_severity_id_action_hier | These methods recursively associate the specified action with reports of the given severity, id, or severity-id pair.
set_report_default_file_hier |
set_report_severity_file_hier |
set_report_id_file_hier |
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.
set_report_verbosity_level_hier | This method recursively sets the maximum verbosity level for reports for this component and all those below it.
pre_abort | This callback is executed when the message system is executing a UVM_EXIT action.
Recording Interface | These methods comprise the component-based transaction recording interface.
accept_tr | This function marks the acceptance of a transaction, tr, by this component.
do_accept_tr | The accept_tr method calls this function to accommodate any user-defined post-accept action.
begin_tr | This function marks the start of a transaction, tr, by this component.
begin_child_tr | This function marks the start of a child transaction, tr, by this component.
do_begin_tr | The begin_tr and begin_child_tr methods call this function to accommodate any user-defined post-begin action.
end_tr | This function marks the end of a transaction, tr, by this component.
do_end_tr | The end_tr method calls this function to accommodate any user-defined post-end action.
record_error_tr | This function marks an error transaction by a component.
record_event_tr | This function marks an event transaction by a component.
get_tr_stream | Returns a tr stream with this component’s full name as a scope.
free_tr_stream | Frees the internal references associated with stream.
print_enabled | This bit determines if this component should automatically be printed as a child of its parent object.
tr_database | Specifies the uvm_tr_database object to use for begin_tr and other methods in the Recording Interface.

### new

> function new (
> | string | name,
> | uvm_component | parent
> )

Creates a new component with the given leaf instance name and handle 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).

### Hierarchy Interface

These methods provide user access to information about the component hierarchy, i.e., topology.

### get_parent

> virtual function uvm_component get_parent ()

Returns a handle to this component’s parent, or null if it has no parent.

### get_full_name

> virtual function string 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.

### get_children

> function void get_children(
> | ref | uvm_component | 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]);

### get_child

> function uvm_component get_child (
> | string | name
> )

### get_next_child

> function int get_next_child (
> | ref | string | name
> )

### get_first_child

> function int get_first_child (
> | ref | string | name
> )

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));

### get_num_children

> function int get_num_children ()

Returns the number of this component’s children.

### has_child

> function int has_child (
> | string | name
> )

Returns 1 if this component has a child with the given name, 0 otherwise.

### lookup

> function uvm_component lookup (
> | string | name
> )

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.

### get_depth

> function int unsigned 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.

### 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_task_phase for more details.

### build_phase

> virtual function void build_phase(
> | uvm_phase | phase
> )

The uvm_build_phase phase implementation method.

Any override should call super.build_phase(phase) to execute the automatic configuration of fields registered 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.

### connect_phase

> virtual function void connect_phase(
> | uvm_phase | phase
> )

The uvm_connect_phase phase implementation method.

This method should never be called directly.

### end_of_elaboration_phase

> virtual function void end_of_elaboration_phase(
> | uvm_phase | phase
> )

The uvm_end_of_elaboration_phase phase implementation method.

This method should never be called directly.

### start_of_simulation_phase

> virtual function void start_of_simulation_phase(
> | uvm_phase | phase
> )

The uvm_start_of_simulation_phase phase implementation method.

This method should never be called directly.

### run_phase

> virtual task run_phase(
> | uvm_phase | phase
> )

The uvm_run_phase phase implementation method.

This task returning or not does not indicate the end or persistence of this phase. Thus the phase will automatically end 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.

### pre_reset_phase

> virtual task pre_reset_phase(
> | uvm_phase | 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.

### reset_phase

> virtual task reset_phase(
> | uvm_phase | 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.

### post_reset_phase

> virtual task post_reset_phase(
> | uvm_phase | 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.

### pre_configure_phase

> virtual task pre_configure_phase(
> | uvm_phase | 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.

### configure_phase

> virtual task configure_phase(
> | uvm_phase | 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.

### post_configure_phase

> virtual task post_configure_phase(
> | uvm_phase | 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.

### pre_main_phase

> virtual task pre_main_phase(
> | uvm_phase | 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.

### main_phase

> virtual task main_phase(
> | uvm_phase | 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.

### post_main_phase

> virtual task post_main_phase(
> | uvm_phase | 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.

### pre_shutdown_phase

> virtual task pre_shutdown_phase(
> | uvm_phase | 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.

### shutdown_phase

> virtual task shutdown_phase(
> | uvm_phase | 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.

### post_shutdown_phase

> virtual task post_shutdown_phase(
> | uvm_phase | 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.

### extract_phase

> virtual function void extract_phase(
> | uvm_phase | phase
> )

The uvm_extract_phase phase implementation method.

This method should never be called directly.

### check_phase

> virtual function void check_phase(
> | uvm_phase | phase
> )

The uvm_check_phase phase implementation method.

This method should never be called directly.

### report_phase

> virtual function void report_phase(
> | uvm_phase | phase
> )

The uvm_report_phase phase implementation method.

This method should never be called directly.

### final_phase

> virtual function void final_phase(
> | uvm_phase | phase
> )

The uvm_final_phase phase implementation method.

This method should never be called directly.

### phase_started

> virtual function void phase_started (
> | uvm_phase | phase
> )

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.

### phase_ready_to_end

> virtual function void phase_ready_to_end (
> | uvm_phase | phase
> )

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.

### phase_ended

> virtual function void phase_ended (
> | uvm_phase | phase
> )

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.

### set_domain

> function void set_domain(
> | uvm_domain | domain, |  |
> | int | hier | = | 1
> )

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 its base class.

### get_domain

> function uvm_domain get_domain()

Return handle to the phase domain set on this component

### define_domain

> virtual protected function void define_domain(
> | uvm_domain | 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 their 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 (i.e. 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.

### set_phase_imp

> function void set_phase_imp(
> | uvm_phase | phase, |  |
> | uvm_phase | imp, |  |
> | int | hier | = | 1
> )

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.

### suspend

> virtual 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().

### resume

> virtual 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.

### resolve_bindings

> virtual function void 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.

### 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.

### check_config_usage

> function void check_config_usage (
> | bit | recurse | = | 1
> )

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

### apply_config_settings

> virtual function void apply_config_settings (
> | bit | verbose | = | 0
> )

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.

### print_config_settings

> function void print_config_settings (
> | string | field | = | "",
> | uvm_component | comp | = | null,
> | bit | recurse | = | 0
> )

Called without arguments, print_config_settings prints all configuration information for this component, as set by previous calls to uvm_config_db::set(). 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.

### print_config

> function void print_config(
> | bit | recurse | = | 0,
> | bit | audit | = | 0
> )

Print_config_settings prints all configuration information for this component, as set by previous calls to uvm_config_db::set() 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

### print_config_with_audit

> function void print_config_with_audit(
> | bit | recurse | = | 0
> )

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.

### print_config_matches

> static bit print_config_matches

Setting this static variable causes uvm_config_db::get() to print info about matching configuration settings as they are being applied.

### Objection Interface

These methods provide object level hooks into the uvm_objection mechanism.

### raised

> virtual function void raised (
> | uvm_objection | objection,
> | uvm_object | source_obj,
> | string | description,
> | int | count
> )

The raised callback is called when this or a descendant of this component instance raises the specified 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.

### dropped

> virtual function void dropped (
> | uvm_objection | objection,
> | uvm_object | source_obj,
> | string | description,
> | int | count
> )

The dropped callback is called when this or a descendant of this component instance drops the specified 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 source_obj.

### all_dropped

> virtual task all_dropped (
> | uvm_objection | objection,
> | uvm_object | source_obj,
> | string | description,
> | int | count
> )

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 source_obj.

### 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.

### create_component

> function uvm_component create_component (
> | string | requested_type_name,
> | string | name
> )

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.

### create_object

> function uvm_object create_object (
> | string | requested_type_name, |  |
> | string | name | = | ""
> )

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.

### set_type_override_by_type

> static function void set_type_override_by_type (
> | uvm_object_wrapper | original_type, |  |
> | uvm_object_wrapper | override_type, |  |
> | bit | replace | = | 1
> )

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.

### set_inst_override_by_type

> function void set_inst_override_by_type(
> | string | relative_inst_path,
> | uvm_object_wrapper | original_type,
> | uvm_object_wrapper | override_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( original_type,
>                                        override_type,
>                                        {get_full_name(),".",
>                                         relative_inst_path});

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

### set_type_override

> static function void set_type_override(
> | string | original_type_name, |  |
> | string | override_type_name, |  |
> | bit | replace | = | 1
> )

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.

### set_inst_override

> function void set_inst_override(
> | string | relative_inst_path,
> | string | original_type_name,
> | string | override_type_name
> )

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(original_type_name,
>                                       override_type_name,
>                                       {get_full_name(),".",
>                                        relative_inst_path}
>                                        );

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.

### print_override_info

> function void print_override_info(
> | string | requested_type_name, |  |
> | string | name | = | ""
> )

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.

### 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.

### set_report_id_verbosity_hier

> function void set_report_id_verbosity_hier (
> | string | id,
> | int | verbosity
> )

### set_report_severity_id_verbosity_hier

> function void set_report_severity_id_verbosity_hier(
> | uvm_severity | severity,
> | string | id,
> | int | verbosity
> )

These methods recursively associate the specified verbosity with reports of the given severity, id, or severity-id pair. A verbosity associated with a particular severity-id pair takes precedence over a verbosity associated with id, which takes precedence over a verbosity associated with a severity.

For a list of severities and their default verbosities, refer to uvm_report_handler.

### set_report_severity_action_hier

> function void set_report_severity_action_hier (
> | uvm_severity | severity,
> | uvm_action | action
> )

### set_report_id_action_hier

> function void set_report_id_action_hier (
> | string | id,
> | uvm_action | action
> )

### set_report_severity_id_action_hier

> function void set_report_severity_id_action_hier(
> | uvm_severity | severity,
> | string | id,
> | uvm_action | action
> )

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 action associated with a severity.

For a list of severities and their default actions, refer to uvm_report_handler.

### set_report_default_file_hier

> function void set_report_default_file_hier (
> | UVM_FILE | file
> )

### set_report_severity_file_hier

> function void set_report_severity_file_hier (
> | uvm_severity | severity,
> | UVM_FILE | file
> )

### set_report_id_file_hier

> function void set_report_id_file_hier (
> | string | id,
> | UVM_FILE | file
> )

### set_report_severity_id_file_hier

> function void set_report_severity_id_file_hier(
> | uvm_severity | severity,
> | string | id,
> | UVM_FILE | file
> )

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.

### set_report_verbosity_level_hier

> function void set_report_verbosity_level_hier (
> | int | verbosity
> )

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.

### pre_abort

> virtual function void 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.

### 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.

### accept_tr

> function void accept_tr (
> | uvm_transaction | tr, |  |
> | time | accept_time | = | 0
> )

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.

### do_accept_tr

> virtual protected function void do_accept_tr (
> | uvm_transaction | 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.

### begin_tr

> function integer begin_tr (
> | uvm_transaction | tr, |  |
> | string | stream_name | = | "main",
> | string | label | = | "",
> | string | desc | = | "",
> | time | begin_time | = | 0,
> | integer | parent_handle | = | 0
> )

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.

### begin_child_tr

> function integer begin_child_tr (
> | uvm_transaction | tr, |  |
> | integer | parent_handle | = | 0,
> | string | stream_name | = | "main",
> | string | label | = | "",
> | string | desc | = | "",
> | time | begin_time | = | 0
> )

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.

### do_begin_tr

> virtual protected function void do_begin_tr (
> | uvm_transaction | tr,
> | string | stream_name,
> | integer | tr_handle
> )

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.

### end_tr

> function void end_tr (
> | uvm_transaction | tr, |  |
> | time | end_time | = | 0,
> | bit | free_handle | = | 1
> )

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.

### do_end_tr

> virtual protected function void do_end_tr (
> | uvm_transaction | tr,
> | integer | tr_handle
> )

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.

### record_error_tr

> 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
> )

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.

### record_event_tr

> 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
> )

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.

### get_tr_stream

> virtual function uvm_tr_stream get_tr_stream(
> | string | name, |  |
> | string | stream_type_name | = | ""
> )

Returns a tr stream with this component’s full name as a scope.

Streams which are retrieved via this method will be stored internally, such that later calls to get_tr_stream will return the same stream reference.

The stream can be removed from the internal storage via a call to free_tr_stream.

#### Parameters

name | Name for the stream
stream_type_name | Type name for the stream (Default = “”)

### free_tr_stream

> virtual function void free_tr_stream(
> | uvm_tr_stream | stream
> )

Frees the internal references associated with stream.

The next call to get_tr_stream will result in a newly created uvm_tr_stream. If the current stream is open (or closed), then it will be freed.

### print_enabled

> bit print_enabled = 1

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.

### tr_database

> uvm_tr_database tr_database

Specifies the uvm_tr_database object to use for begin_tr and other methods in the Recording Interface. Default is uvm_coreservice_t::get_default_tr_database.

> virtual class uvm_void

The uvm_void class is the base class for all UVM classes.

> virtual class uvm_object extends uvm_void

The uvm_object class is the base class for all UVM data and hierarchical classes.

> class uvm_report_object extends uvm_object

The uvm_report_object provides an interface to the UVM reporting facility.

> virtual class uvm_component extends uvm_report_object

The uvm_component class is the root base class for UVM components.

> function new (
> | string | name,
> | uvm_component | parent
> )

Creates a new component with the given leaf instance name and handle to its parent.

> virtual function uvm_component get_parent ()

Returns a handle to this component’s parent, or null if it has no parent.

> virtual function string get_full_name ()

Returns the full hierarchical name of this object.

> function void get_children(
> | ref | uvm_component | children[$]
> )

This function populates the end of the children array with the list of this component’s children.

> function uvm_component get_child (
> | string | name
> )

> function int get_next_child (
> | ref | string | name
> )

> function int get_first_child (
> | ref | string | name
> )

These methods are used to iterate through this component’s children, if any.

> function int get_num_children ()

Returns the number of this component’s children.

> function int has_child (
> | string | name
> )

Returns 1 if this component has a child with the given name, 0 otherwise.

> function uvm_component lookup (
> | string | name
> )

Looks for a component with the given hierarchical name relative to this component.

> function int unsigned get_depth()

Returns the component’s depth from the root level.

> virtual function void build_phase(
> | uvm_phase | phase
> )

The uvm_build_phase phase implementation method.

> class uvm_build_phase extends uvm_topdown_phase

Create and configure of testbench structure

> virtual function void connect_phase(
> | uvm_phase | phase
> )

The uvm_connect_phase phase implementation method.

> class uvm_connect_phase extends uvm_bottomup_phase

Establish cross-component connections.

> virtual function void end_of_elaboration_phase(
> | uvm_phase | phase
> )

The uvm_end_of_elaboration_phase phase implementation method.

> class uvm_end_of_elaboration_phase extends uvm_bottomup_phase

Fine-tune the testbench.

> virtual function void start_of_simulation_phase(
> | uvm_phase | phase
> )

The uvm_start_of_simulation_phase phase implementation method.

> class uvm_start_of_simulation_phase extends uvm_bottomup_phase

Get ready for DUT to be simulated.

> virtual task run_phase(
> | uvm_phase | phase
> )

The uvm_run_phase phase implementation method.

> class uvm_run_phase extends uvm_task_phase

Stimulate the DUT.

> virtual task pre_reset_phase(
> | uvm_phase | phase
> )

The uvm_pre_reset_phase phase implementation method.

> class uvm_pre_reset_phase extends uvm_task_phase

Before reset is asserted.

> virtual task reset_phase(
> | uvm_phase | phase
> )

The uvm_reset_phase phase implementation method.

> class uvm_reset_phase extends uvm_task_phase

Reset is asserted.

> virtual task post_reset_phase(
> | uvm_phase | phase
> )

The uvm_post_reset_phase phase implementation method.

> class uvm_post_reset_phase extends uvm_task_phase

After reset is de-asserted.

> virtual task pre_configure_phase(
> | uvm_phase | phase
> )

The uvm_pre_configure_phase phase implementation method.

> class uvm_pre_configure_phase extends uvm_task_phase

Before the DUT is configured by the SW.

> virtual task configure_phase(
> | uvm_phase | phase
> )

The uvm_configure_phase phase implementation method.

> class uvm_configure_phase extends uvm_task_phase

The SW configures the DUT.

> virtual task post_configure_phase(
> | uvm_phase | phase
> )

The uvm_post_configure_phase phase implementation method.

> class uvm_post_configure_phase extends uvm_task_phase

After the SW has configured the DUT.

> virtual task pre_main_phase(
> | uvm_phase | phase
> )

The uvm_pre_main_phase phase implementation method.

> class uvm_pre_main_phase extends uvm_task_phase

Before the primary test stimulus starts.

> virtual task main_phase(
> | uvm_phase | phase
> )

The uvm_main_phase phase implementation method.

> class uvm_main_phase extends uvm_task_phase

Primary test stimulus.

> virtual task post_main_phase(
> | uvm_phase | phase
> )

The uvm_post_main_phase phase implementation method.

> class uvm_post_main_phase extends uvm_task_phase

After enough of the primary test stimulus.

> virtual task pre_shutdown_phase(
> | uvm_phase | phase
> )

The uvm_pre_shutdown_phase phase implementation method.

> class uvm_pre_shutdown_phase extends uvm_task_phase

Before things settle down.

> virtual task shutdown_phase(
> | uvm_phase | phase
> )

The uvm_shutdown_phase phase implementation method.

> class uvm_shutdown_phase extends uvm_task_phase

Letting things settle down.

> virtual task post_shutdown_phase(
> | uvm_phase | phase
> )

The uvm_post_shutdown_phase phase implementation method.

> class uvm_post_shutdown_phase extends uvm_task_phase

After things have settled down.

> virtual function void extract_phase(
> | uvm_phase | phase
> )

The uvm_extract_phase phase implementation method.

> class uvm_extract_phase extends uvm_bottomup_phase

Extract data from different points of the verification environment.

> virtual function void check_phase(
> | uvm_phase | phase
> )

The uvm_check_phase phase implementation method.

> class uvm_check_phase extends uvm_bottomup_phase

Check for any unexpected conditions in the verification environment.

> virtual function void report_phase(
> | uvm_phase | phase
> )

The uvm_report_phase phase implementation method.

> class uvm_report_phase extends uvm_bottomup_phase

Report results of the test.

> virtual function void final_phase(
> | uvm_phase | phase
> )

The uvm_final_phase phase implementation method.

> class uvm_final_phase extends uvm_topdown_phase

Tie up loose ends.

> virtual function void phase_started (
> | uvm_phase | phase
> )

Invoked at the start of each phase.

> virtual function void phase_ready_to_end (
> | uvm_phase | phase
> )

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.

> virtual function void phase_ended (
> | uvm_phase | phase
> )

Invoked at the end of each phase.

> function void set_domain(
> | uvm_domain | domain, |  |
> | int | hier | = | 1
> )

Apply a phase domain to this component and, if hier is set, recursively to all its children.

> function uvm_domain get_domain()

Return handle to the phase domain set on this component

> virtual protected function void define_domain(
> | uvm_domain | domain
> )

Builds custom phase schedules into the provided domain handle.

> function void set_phase_imp(
> | uvm_phase | phase, |  |
> | uvm_phase | imp, |  |
> | int | hier | = | 1
> )

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

> virtual task suspend ()

Suspend this component.

> virtual task resume ()

Resume this component.

> virtual function void resolve_bindings ()

Processes all port, export, and imp connections.

> function void check_config_usage (
> | bit | recurse | = | 1
> )

Check all configuration settings in a components configuration table to determine if the setting has been used, overridden or not used.

> virtual function void apply_config_settings (
> | bit | verbose | = | 0
> )

Searches for all config settings matching this component’s instance path.

> function void print_config_settings (
> | string | field | = | "",
> | uvm_component | comp | = | null,
> | bit | recurse | = | 0
> )

Called without arguments, print_config_settings prints all configuration information for this component, as set by previous calls to uvm_config_db::set().

> static function void set(
> | uvm_component | cntxt,
> | string | inst_name,
> | string | field_name,
> | T | value
> )

Create a new or update an existing configuration setting for field_name in inst_name from cntxt.

> function void print_config(
> | bit | recurse | = | 0,
> | bit | audit | = | 0
> )

Print_config_settings prints all configuration information for this component, as set by previous calls to uvm_config_db::set() and exports to the resources pool.

> function void print_config_with_audit(
> | bit | recurse | = | 0
> )

Operates the same as print_config except that the audit bit is forced to 1.

> static bit print_config_matches

Setting this static variable causes uvm_config_db::get() to print info about matching configuration settings as they are being applied.

> class uvm_objection extends uvm_report_object

Objections provide a facility for coordinating status information between two or more participating components, objects, and even module-based IP.

> virtual function void raised (
> | uvm_objection | objection,
> | uvm_object | source_obj,
> | string | description,
> | int | count
> )

The raised callback is called when this or a descendant of this component instance raises the specified objection.

> virtual function void dropped (
> | uvm_objection | objection,
> | uvm_object | source_obj,
> | string | description,
> | int | count
> )

The dropped callback is called when this or a descendant of this component instance drops the specified objection.

> virtual task all_dropped (
> | uvm_objection | objection,
> | uvm_object | source_obj,
> | string | description,
> | int | count
> )

The all_droppped callback is called when all objections have been dropped by this component and all its descendants.

> virtual class uvm_factory

As the name implies, uvm_factory is used to manufacture (create) UVM objects and components.

> function uvm_component create_component (
> | string | requested_type_name,
> | string | name
> )

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.

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

Creates and returns a component or object of the requested type, which may be specified by type or by name.

> function uvm_object create_object (
> | string | requested_type_name, |  |
> | string | name | = | ""
> )

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.

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

> static function void set_type_override_by_type (
> | uvm_object_wrapper | original_type, |  |
> | uvm_object_wrapper | override_type, |  |
> | bit | replace | = | 1
> )

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.

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

> function void set_inst_override_by_type(
> | string | relative_inst_path,
> | uvm_object_wrapper | original_type,
> | uvm_object_wrapper | override_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.

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

> static function void set_type_override(
> | string | original_type_name, |  |
> | string | override_type_name, |  |
> | bit | replace | = | 1
> )

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.

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

Configures the factory to create an object of the override’s type whenever a request is made to create an object of the original type, provided no instance override applies.

> function void set_inst_override(
> | string | relative_inst_path,
> | string | original_type_name,
> | string | override_type_name
> )

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.

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

Configures the factory to create an object of the override’s type whenever a request is made to create an object of the original type using a context that matches full_inst_path.

> function void print_override_info(
> | string | requested_type_name, |  |
> | string | name | = | ""
> )

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.

> function void set_report_id_verbosity_hier (
> | string | id,
> | int | verbosity
> )

> function void set_report_severity_id_verbosity_hier(
> | uvm_severity | severity,
> | string | id,
> | int | verbosity
> )

These methods recursively associate the specified verbosity with reports of the given severity, id, or severity-id pair.

> function void set_report_severity_action_hier (
> | uvm_severity | severity,
> | uvm_action | action
> )

> function void set_report_id_action_hier (
> | string | id,
> | uvm_action | action
> )

> function void set_report_severity_id_action_hier(
> | uvm_severity | severity,
> | string | id,
> | uvm_action | action
> )

These methods recursively associate the specified action with reports of the given severity, id, or severity-id pair.

> function void set_report_default_file_hier (
> | UVM_FILE | file
> )

> function void set_report_severity_file_hier (
> | uvm_severity | severity,
> | UVM_FILE | file
> )

> function void set_report_id_file_hier (
> | string | id,
> | UVM_FILE | file
> )

> function void set_report_severity_id_file_hier(
> | uvm_severity | severity,
> | string | id,
> | UVM_FILE | file
> )

These methods recursively associate the specified FILE descriptor with reports of the given severity, id, or severity-id pair.

> function void set_report_verbosity_level_hier (
> | int | verbosity
> )

This method recursively sets the maximum verbosity level for reports for this component and all those below it.

> virtual function void pre_abort

This callback is executed when the message system is executing a UVM_EXIT action.
Terminates the simulation immediately.

> function void accept_tr (
> | uvm_transaction | tr, |  |
> | time | accept_time | = | 0
> )

This function marks the acceptance of a transaction, tr, by this component.

> virtual protected function void do_accept_tr (
> | uvm_transaction | tr
> )

The accept_tr method calls this function to accommodate any user-defined post-accept action.

> function integer begin_tr (
> | uvm_transaction | tr, |  |
> | string | stream_name | = | "main",
> | string | label | = | "",
> | string | desc | = | "",
> | time | begin_time | = | 0,
> | integer | parent_handle | = | 0
> )

This function marks the start of a transaction, tr, by this component.

> function integer begin_child_tr (
> | uvm_transaction | tr, |  |
> | integer | parent_handle | = | 0,
> | string | stream_name | = | "main",
> | string | label | = | "",
> | string | desc | = | "",
> | time | begin_time | = | 0
> )

This function marks the start of a child transaction, tr, by this component.

> virtual protected function void do_begin_tr (
> | uvm_transaction | tr,
> | string | stream_name,
> | integer | tr_handle
> )

The begin_tr and begin_child_tr methods call this function to accommodate any user-defined post-begin action.

> function void end_tr (
> | uvm_transaction | tr, |  |
> | time | end_time | = | 0,
> | bit | free_handle | = | 1
> )

This function marks the end of a transaction, tr, by this component.

> virtual protected function void do_end_tr (
> | uvm_transaction | tr,
> | integer | tr_handle
> )

The end_tr method calls this function to accommodate any user-defined post-end action.

> 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
> )

This function marks an error transaction by a component.

> 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
> )

This function marks an event transaction by a component.

> virtual function uvm_tr_stream get_tr_stream(
> | string | name, |  |
> | string | stream_type_name | = | ""
> )

Returns a tr stream with this component’s full name as a scope.

> virtual function void free_tr_stream(
> | uvm_tr_stream | stream
> )

Frees the internal references associated with stream.

> bit print_enabled = 1

This bit determines if this component should automatically be printed as a child of its parent object.

> uvm_tr_database tr_database

Specifies the uvm_tr_database object to use for begin_tr and other methods in the Recording Interface.

> virtual class uvm_tr_database extends uvm_object

The uvm_tr_database class is intended to hide the underlying database implementation from the end user, as these details are often vendor or tool-specific.
These methods comprise the component-based transaction recording interface.

> class uvm_report_handler extends uvm_object

The uvm_report_handler is the class to which most methods in uvm_report_object delegate.

> function void reseed ()

Calls srandom on the object to reseed the object using the UVM seeding mechanism, which sets the seed based on type name and instance name instead of based on instance position in a thread.

> virtual function string get_name ()

Returns the name of the object, as provided by the name argument in the new constructor or set_name method.

> function void print (
> | uvm_printer | printer | = | null
> )

The print method deep-prints this object’s properties in a format and manner governed by the given printer argument; if the printer argument is not provided, the global uvm_default_printer is used.

> virtual class uvm_task_phase extends uvm_phase

Base class for all task phases.

> static function uvm_domain get_uvm_domain()

Get a handle to the singleton uvm domain

> class uvm_component_registry #(
> | type | T | = | uvm_component,
> | string | Tname | = | "<unknown>"
> ) extends uvm_object_wrapper

The uvm_component_registry serves as a lightweight proxy for a component of type T and type name Tname, a string.

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

The uvm_object_registry serves as a lightweight proxy for a uvm_object of type T and type name Tname, a string.

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

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

> function void accept_tr (
> | time | accept_time | = | 0
> )

Calling accept_tr indicates that the transaction item has been received by a consumer component.

> function integer begin_tr (
> | time | begin_time | = | 0
> )

This function indicates that the transaction has been started and is not the child of another transaction.

> function void end_tr (
> | time | end_time | = | 0,
> | bit | free_handle | = | 1
> )

This function indicates that the transaction execution has ended.

> virtual function void do_record (
> | uvm_recorder | recorder
> )

The do_record method is the user-definable hook called by the record method.

> virtual class uvm_tr_stream extends uvm_object

The uvm_tr_stream base class is a representation of a stream of records within a uvm_tr_database.

> pure virtual function uvm_tr_database get_default_tr_database()

intended to return the current default record database