Macros

Defined Control Defines

Name

Description

UVM_CORESERVICE_TYPE

UVM_DEPRECATED_STARTING_PHASE

UVM_HDL_MAX_WIDTH

UVM_LINE_WIDTH

UVM_MAX_STREAMBITS

UVM_NUM_LINES

UVM_PACKER_MAX_BYTES

UVM_REG_ADDR_WIDTH

UVM_REG_BYTENABLE_WIDTH

UVM_REG_CVR_WIDTH

UVM_REG_DATA_WIDTH

uvm_record_attribute(TR_HANDLE, NAME, VALUE)

uvm_record_int(NAME, VALUE, SIZE, RADIX =UVM_NORADIX)

uvm_record_real(NAME, VALUE)

uvm_record_string(NAME, VALUE)

uvm_record_time(NAME, VALUE)
Undefined Control Defines

Name

Description

UVM_CB_TRACE_ON

The +define+UVM_CB_TRACE_ON setting will instrument the uvm library to emit messages with message id UVMCB_TRC and UVM_NONE verbosity notifing add,delete and execution of uvm callbacks. The instrumentation is off by default.

UVM_CMDLINE_NO_DPI

Import DPI functions used by the interface to generate the lists.

UVM_DEPRECATED_REPORTING

UVM_DISABLE_AUTO_ITEM_RECORDING

UVM_EMPTY_MACROS

UVM_ENABLE_FIELD_CHECKS

UVM_FIX_REV

Macro

UVM_VERSION_STRING

Provides a string-ized version of the UVM Library version number.

When there is a FIX_REV, the string is "<name>-<major>.<minor><fix>" (such as "UVM-1.1d"). When there is NO FIX_REV, the string is "<name>-<major>.<minor>" (such as "UVM-1.2").

UVM_HDL_NO_DPI

UVM_NO_DEPRECATED

Deprecation Control Macros

UVM_NO_DPI

Top-level file for DPI subroutines used by UVM.

Tool-specific distribution overlays may be required.

To use UVM without any tool-specific overlay, use +defin+UVM_NO_DPI

UVM_NO_WAIT_FOR_NBA

If included directly in a program block, can't use a non-blocking assign, but it isn't needed since program blocks are in a separate region.

UVM_OBJECT_DO_NOT_NEED_CONSTRUCTOR

UVM_REGEX_NO_DPI

UVM_REG_NO_INDIVIDUAL_FIELD_ACCESS

UVM_REPORT_DISABLE_FILE

UVM_REPORT_DISABLE_FILE_LINE

ifndef UVM_USE_FILE_LINE define UVM_REPORT_DISABLE_FILE_LINE endif

UVM_REPORT_DISABLE_LINE

UVM_USE_PROCESS_CONTAINER

UVM_USE_PROCESS_STATE

UVM_USE_RESOURCE_CONVERTER

UVM_USE_STRING_QUEUE_STREAMING_PACK

UVM_USE_SUSPEND_RESUME
Defines

Name

Value

Description

UVM_BLOCKING_GET_IMP(imp, TYPE, arg)

UVM_BLOCKING_GET_IMP_SFX(SFX, imp, TYPE, arg)

UVM_BLOCKING_GET_PEEK_IMP(imp, TYPE, arg)

UVM_BLOCKING_PEEK_IMP(imp, TYPE, arg)

UVM_BLOCKING_PEEK_IMP_SFX(SFX, imp, TYPE, arg)

UVM_BLOCKING_PUT_IMP(imp, TYPE, arg)

TLM imp implementations

UVM_BLOCKING_PUT_IMP_SFX(SFX, imp, TYPE, arg)

These imps are used in uvm_*port, uvmexport and uvm_imp, using suffixes

UVM_BLOCKING_TRANSPORT_IMP(imp, REQ, RSP, req_arg, rsp_arg)

UVM_BLOCKING_TRANSPORT_IMP_SFX(SFX, imp, REQ, RSP, req_arg, rsp_arg)

UVM_DEFAULT_TIMEOUT

9200s

The default timeout for simulation, if not overridden by <uvm_root::set_timeout> or <uvm_cmdline_processor::+UVM_TIMEOUT>

UVM_EXPORT_COMMON(MASK, TYPE_NAME)

UVM_FUNCTION_ERROR

"TLM interface function not implemented"

UVM_GET_IMP(imp, TYPE, arg)

UVM_GET_PEEK_IMP(imp, TYPE, arg)

UVM_IMP_COMMON(MASK, TYPE_NAME, IMP)

UVM_MAJOR_REV

1

Defines the MAJOR revision number.

For UVM version 1.2, the MAJOR revision number is '1'

define UVM_MAJOR_REV 1

UVM_MAJOR_REV_1

Indicates that the MAJOR version of this release is '1'.

define UVM_MAJOR_REV_1

UVM_MAJOR_VERSION_1_2

Undocumented, same thing as UVM_VERSION_1_2

UVM_MINOR_REV

2

Defines the MINOR revision number.

For UVM version 1.2, the MINOR revision number is '2'

define UVM_MINOR_REV 2

UVM_MINOR_REV_2

Indicates that the MINOR version of this release is '2'.

define UVM_MINOR_REV_2

UVM_MS_IMP_COMMON(MASK, TYPE_NAME)

UVM_NAME

UVM

The name used by the library when displaying the name of the library.

define UVM_NAME UVM

UVM_NONBLOCKING_GET_IMP(imp, TYPE, arg)

UVM_NONBLOCKING_GET_IMP_SFX(SFX, imp, TYPE, arg)

UVM_NONBLOCKING_GET_PEEK_IMP(imp, TYPE, arg)

UVM_NONBLOCKING_PEEK_IMP(imp, TYPE, arg)

UVM_NONBLOCKING_PEEK_IMP_SFX(SFX, imp, TYPE, arg)

UVM_NONBLOCKING_PUT_IMP(imp, TYPE, arg)

UVM_NONBLOCKING_PUT_IMP_SFX(SFX, imp, TYPE, arg)

UVM_NONBLOCKING_TRANSPORT_IMP(imp, REQ, RSP, req_arg, rsp_arg)

UVM_NONBLOCKING_TRANSPORT_IMP_SFX(SFX, imp, REQ, RSP, req_arg, rsp_arg)

UVM_PEEK_IMP(imp, TYPE, arg)

UVM_PH_TRACE(ID, MSG, PH, VERB)

UVM_PORT_COMMON(MASK, TYPE_NAME)

UVM_POST_VERSION_1_1

Indicates that this version of the UVM came after the 1.1 versions, including the various 1.1 fix revisions.

The first UVM version wherein this macro is defined is 1.2, and the macro will continue to be defined for all future revisions of the UVM library.

define UVM_POST_VERSION_1_1

UVM_PUT_IMP(imp, TYPE, arg)

UVM_RESOURCE_GET_FCNS(base_type)

When specicializing resources the get_by_name and get_by_type functions must be redefined. The reason is that the version of these functions in the base class (uvm_resource#(T)) returns an object of type uvm_resource#(T). In the specializations we must return an object of the type of the specialization. So, we call the base_class implementation of these functions and then downcast to the subtype.

This macro is invokved once in each where a resource specialization is a class defined as:

class &lt;resource_specialization&gt; extends uvm_resource#(T)

where <resource_specialization> is the name of the derived class. The argument to this macro is T, the type of the uvm_resource#(T) specialization. The class in which the macro is defined must supply a typedef of the specialized class of the form:

typedef &lt;resource_specialization&gt; this_subtype;

where <resource_specialization> is the same as above. The macro generates the get_by_name() and get_by_type() functions for the specialized resource (i.e. resource subtype).

UVM_SEQ_ITEM_FUNCTION_ERROR

"Sequencer interface function not implemented"

UVM_SEQ_ITEM_GET_MASK

(1<<7)

UVM_SEQ_ITEM_GET_NEXT_ITEM_MASK

(1<<0)

UVM_SEQ_ITEM_HAS_DO_AVAILABLE_MASK

(1<<3)

UVM_SEQ_ITEM_ITEM_DONE_MASK

(1<<2)

UVM_SEQ_ITEM_PEEK_MASK

(1<<8)

UVM_SEQ_ITEM_PULL_IMP(imp, REQ, RSP, req_arg, rsp_arg)

imp definitions

UVM_SEQ_ITEM_PULL_MASK

UVM_SEQ_ITEM_PUSH_MASK

(UVM_SEQ_ITEM_PUT_MASK)

UVM_SEQ_ITEM_PUT_MASK

(1<<6)

UVM_SEQ_ITEM_PUT_RESPONSE_MASK

(1<<5)

UVM_SEQ_ITEM_TASK_ERROR

"Sequencer interface task not implemented"

UVM_SEQ_ITEM_TRY_NEXT_ITEM_MASK

(1<<1)

UVM_SEQ_ITEM_UNI_PULL_MASK

UVM_SEQ_ITEM_WAIT_FOR_SEQUENCES_MASK

(1<<4)

UVM_SEQ_PORT(MASK, TYPE_NAME)

UVM_STRING_QUEUE_STREAMING_PACK(q)

uvm_pkg::m_uvm_string_queue_join(q)

UVM_TASK_ERROR

"TLM interface task not implemented"

Copyright 2007-2011 Mentor Graphics Corporation Copyright 2007-2010 Cadence Design Systems, Inc. Copyright 2010 Synopsys, Inc. All Rights Reserved Worldwide

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

UVM_TLM_ANALYSIS_MASK

(1<<8)

UVM_TLM_BLOCKING_GET_MASK

(1<<1)

UVM_TLM_BLOCKING_GET_PEEK_MASK

(UVM_TLM_BLOCKING_GET_MASK | UVM_TLM_BLOCKING_PEEK_MASK)

UVM_TLM_BLOCKING_MASTER_MASK

(UVM_TLM_BLOCKING_PUT_MASK | UVM_TLM_BLOCKING_GET_MASK | UVM_TLM_BLOCKING_PEEK_MASK | UVM_TLM_MASTER_BIT_MASK)

UVM_TLM_BLOCKING_PEEK_MASK

(1<<2)

UVM_TLM_BLOCKING_PUT_MASK

(1<<0)

primitive interfaces

UVM_TLM_BLOCKING_SLAVE_MASK

(UVM_TLM_BLOCKING_PUT_MASK | UVM_TLM_BLOCKING_GET_MASK | UVM_TLM_BLOCKING_PEEK_MASK | UVM_TLM_SLAVE_BIT_MASK)

UVM_TLM_BLOCKING_TRANSPORT_MASK

(1<<3)

UVM_TLM_B_MASK

(1<<2)

Define blocking mask onehot assignment = 'b100

UVM_TLM_B_TRANSPORT_IMP(imp, T, t, delay)

The macro wraps the function b_transport() Execute a blocking transaction. Once this method returns, the transaction is assumed to have been executed. Whether that execution is successful or not must be indicated by the transaction itself.

The callee may modify or update the transaction object, subject to any constraints imposed by the transaction class. The initiator may re-use a transaction object from one call to the next and across calls to b_transport().

The call to b_transport shall mark the first timing point of the transaction. The return from b_transport() shall mark the final timing point of the transaction. The timing annotation argument allows the timing points to be offset from the simulation times at which the task call and return are executed.

UVM_TLM_FIFO_FUNCTION_ERROR

"fifo channel function not implemented"

UVM_TLM_FIFO_TASK_ERROR

"fifo channel task not implemented"

Copyright 2007-2011 Mentor Graphics Corporation Copyright 2007-2011 Cadence Design Systems, Inc. Copyright 2010 Synopsys, Inc. All Rights Reserved Worldwide

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

UVM_TLM_FUNCTION_ERROR

"TLM-2 interface function not implemented"

Defines Not-Yet-Implemented TLM functions

UVM_TLM_GET_MASK

(UVM_TLM_BLOCKING_GET_MASK | UVM_TLM_NONBLOCKING_GET_MASK)

UVM_TLM_GET_PEEK_MASK

(UVM_TLM_GET_MASK | UVM_TLM_PEEK_MASK)

UVM_TLM_GET_TYPE_NAME(NAME)

UVM_TLM_MASTER_BIT_MASK

(1<<9)

UVM_TLM_MASTER_MASK

(UVM_TLM_BLOCKING_MASTER_MASK | UVM_TLM_NONBLOCKING_MASTER_MASK)

UVM_TLM_NB_BW_MASK

(1<<1)

Define Non blocking backward mask onehot assignment = 'b010

UVM_TLM_NB_FW_MASK

(1<<0)

Define Non blocking Forward mask onehot assignment = 'b001

UVM_TLM_NB_TRANSPORT_BW_IMP(imp, T, P, t, p, delay)

Implementation of the backward path. The macro wraps the function called nb_transport_bw(). This function MUST be implemented in the INITIATOR component class.

Every call to this method may mark a timing point, including the final timing point, in the execution of the transaction. The timing annotation argument allows the timing point to be offset from the simulation times at which the backward path is used. The final timing point of a transaction may be marked by a call to nb_transport_fw() within UVM_TLM_NB_TRANSPORT_FW_IMP or a return from this or subsequent call to nb_transport_bw().

See <TLM2 Interfaces, Ports, Exports and Transport Interfaces Subset> for more details on the semantics and rules of the nonblocking transport interface.

Example:

class master extends uvm_component;
   uvm_tlm_nb_initiator_socket
         #(trans, uvm_tlm_phase_e, this_t) initiator_socket;

   function void build_phase(uvm_phase phase);
      initiator_socket = new(&quot;initiator_socket&quot;, this, this);
   endfunction

   function uvm_tlm_sync_e nb_transport_bw(trans t,
                                  ref uvm_tlm_phase_e p,
                                  input uvm_tlm_time delay);
       transaction = t;
       state = p;
       return UVM_TLM_ACCEPTED;
   endfunction

   ...
endclass

UVM_TLM_NB_TRANSPORT_FW_IMP(imp, T, P, t, p, delay)

The macro wraps the forward path call function nb_transport_fw()

The first call to this method for a transaction marks the initial timing point. Every call to this method may mark a timing point in the execution of the transaction. The timing annotation argument allows the timing points to be offset from the simulation times at which the forward path is used. The final timing point of a transaction may be marked by a call to nb_transport_bw() within UVM_TLM_NB_TRANSPORT_BW_IMP or a return from this or subsequent call to nb_transport_fw().

See <TLM2 Interfaces, Ports, Exports and Transport Interfaces Subset> for more details on the semantics and rules of the nonblocking transport interface.

UVM_TLM_NONBLOCKING_GET_MASK

(1<<5)

UVM_TLM_NONBLOCKING_GET_PEEK_MASK

(UVM_TLM_NONBLOCKING_GET_MASK | UVM_TLM_NONBLOCKING_PEEK_MASK)

UVM_TLM_NONBLOCKING_MASTER_MASK

(UVM_TLM_NONBLOCKING_PUT_MASK | UVM_TLM_NONBLOCKING_GET_MASK | UVM_TLM_NONBLOCKING_PEEK_MASK | UVM_TLM_MASTER_BIT_MASK)

UVM_TLM_NONBLOCKING_PEEK_MASK

(1<<6)

UVM_TLM_NONBLOCKING_PUT_MASK

(1<<4)

UVM_TLM_NONBLOCKING_SLAVE_MASK

(UVM_TLM_NONBLOCKING_PUT_MASK | UVM_TLM_NONBLOCKING_GET_MASK | UVM_TLM_NONBLOCKING_PEEK_MASK | UVM_TLM_SLAVE_BIT_MASK)

UVM_TLM_NONBLOCKING_TRANSPORT_MASK

(1<<7)

UVM_TLM_PEEK_MASK

(UVM_TLM_BLOCKING_PEEK_MASK | UVM_TLM_NONBLOCKING_PEEK_MASK)

UVM_TLM_PUT_MASK

(UVM_TLM_BLOCKING_PUT_MASK | UVM_TLM_NONBLOCKING_PUT_MASK)

combination interfaces

UVM_TLM_SLAVE_BIT_MASK

(1<<10)

UVM_TLM_SLAVE_MASK

(UVM_TLM_BLOCKING_SLAVE_MASK | UVM_TLM_NONBLOCKING_SLAVE_MASK)

UVM_TLM_TASK_ERROR

"TLM-2 interface task not implemented"

Defines Not-Yet-Implemented TLM tasks

UVM_TLM_TRANSPORT_MASK

(UVM_TLM_BLOCKING_TRANSPORT_MASK | UVM_TLM_NONBLOCKING_TRANSPORT_MASK)

UVM_TRANSPORT_IMP(imp, REQ, RSP, req_arg, rsp_arg)

UVM_VERSION_1_2

Indicates that the version of this release is '1.2'.

define UVM_VERSION_1_2

UVM_VERSION_STRING

"UVM_NAME-UVM_MAJOR_REV.UVM_MINOR_REV"

uvm_add_to_seq_lib(TYPE, LIBTYPE)

uvm_analysis_imp_decl(SFX)

 
uvm_analysis_imp_decl(SFX)

Define the class uvm_analysis_impSFX for providing an analysis implementation. SFX is the suffix for the new class type. The analysis implementation is the write function. The uvm_analysis_imp_decl allows for a scoreboard (or other analysis component) to support input from many places. For example:

uvm_analysis_imp_decl(_ingress)
uvm_analysis_imp_decl(_egress)

class myscoreboard extends uvm_component;
  uvm_analysis_imp_ingress#(mydata, myscoreboard) ingress;
  uvm_analysis_imp_egress#(mydata, myscoreboard) egress;
  mydata ingress_list[$];
  ...

  function new(string name, uvm_component parent);
    super.new(name,parent);
    ingress = new(&quot;ingress&quot;, this);
    egress = new(&quot;egress&quot;, this);
  endfunction

  function void write_ingress(mydata t);
    ingress_list.push_back(t);
  endfunction

  function void write_egress(mydata t);
    find_match_in_ingress_list(t);
  endfunction

  function void find_match_in_ingress_list(mydata t);
    //implement scoreboarding for this particular dut
    ...
  endfunction
endclass

uvm_blocking_get_imp_decl(SFX)

 
uvm_blocking_get_imp_decl(SFX)

Define the class uvm_blocking_get_impSFX for providing blocking get implementations. SFX is the suffix for the new class type.

uvm_blocking_get_peek_imp_decl(SFX)

 
uvm_blocking_get_peek_imp_decl(SFX)

Define the class uvm_blocking_get_peek_impSFX for providing the blocking get_peek implementation.

uvm_blocking_master_imp_decl(SFX)

 
uvm_blocking_master_imp_decl(SFX)

Define the class uvm_blocking_master_impSFX for providing the blocking master implementation.

uvm_blocking_peek_imp_decl(SFX)

 
uvm_blocking_peek_imp_decl(SFX)

Define the class uvm_blocking_peek_impSFX for providing blocking peek implementations. SFX is the suffix for the new class type.

uvm_blocking_put_imp_decl(SFX)

 
uvm_blocking_put_imp_decl(SFX)

Define the class uvm_blocking_put_impSFX for providing blocking put implementations. SFX is the suffix for the new class type.

uvm_blocking_slave_imp_decl(SFX)

 
uvm_blocking_slave_imp_decl(SFX)

Define the class uvm_blocking_slave_impSFX for providing the blocking slave implementation.

uvm_blocking_transport_imp_decl(SFX)

 
uvm_blocking_transport_imp_decl(SFX)

Define the class uvm_blocking_transport_impSFX for providing the blocking transport implementation.

uvm_builtin_bottomup_phase(PHASE)

uvm_builtin_task_phase(PHASE)

PREFIXPHASE_phase PREFIXPHASE_ph = PREFIXPHASE_phase::get();

uvm_builtin_topdown_phase(PHASE)

uvm_cb_trace(OBJ, CB, OPER)

/* null */

uvm_cb_trace_noobj(CB, OPER)

/* null */

uvm_component_param_utils(T)

uvm_component_param_utils_begin(T)

uvm_component_registry(T, S)

Registers a uvm_component-based class with the factory

uvm_component_registry(T,S)

Registers a uvm_component-based class T and lookup string S with the factory. S typically is the name of the class in quotes. The uvm_object_utils family of macros uses this macro.

uvm_component_utils(T)

MACRO

uvm_component_end

uvm_component-based class declarations may contain one of the above forms of utility macros.

For simple components with no field macros, use

uvm_component_utils(TYPE)

For simple components with field macros, use

uvm_component_utils_begin(TYPE)
  uvm_field_* macro invocations here
uvm_component_utils_end

For parameterized components with no field macros, use

uvm_component_param_utils(TYPE)

For parameterized components with field macros, use

uvm_component_param_utils_begin(TYPE)
  uvm_field_* macro invocations here
uvm_component_utils_end

Simple (non-parameterized) components must use the uvm_components_utils* versions, which do the following:

  • Implements get_type_name, which returns TYPE as a string.

  • Implements create, which allocates a component of type TYPE using a two argument constructor. TYPE's constructor must have a name and a parent argument.

  • Registers the TYPE with the factory, using the string TYPE as the factory lookup string for the type.

  • Implements the static get_type() method which returns a factory proxy object for the type.

  • Implements the virtual get_object_type() method which works just like the static get_type() method, but operates on an already allocated object.

Parameterized classes must use the uvm_object_param_utils* versions. They differ from uvm_object_utils only in that they do not supply a type name when registering the object with the factory. As such, name-based lookup with the factory for parameterized classes is not possible.

The macros with _begin suffixes are the same as the non-suffixed versions except that they also start a block in which uvm_field_* macros can be placed. The block must be terminated by uvm_component_utils_end.

uvm_component_utils_begin(T)

uvm_component_utils_end

uvm_create(SEQ_OR_ITEM)

 
uvm_create(SEQ_OR_ITEM)

This action creates the item or sequence using the factory. It intentionally does zero processing. After this action completes, the user can manually set values, manipulate rand_mode and constraint_mode, etc.

uvm_create_on(SEQ_OR_ITEM, SEQR)

 
uvm_create_on(SEQ_OR_ITEM, SEQR)

This is the same as uvm_create except that it also sets the parent sequence to the sequence in which the macro is invoked, and it sets the sequencer to the specified SEQR argument.

uvm_create_seq(UVM_SEQ, SEQR_CONS_IF)

uvm_declare_p_sequencer(SEQUENCER)

This macro is used to declare a variable p_sequencer whose type is specified by SEQUENCER .

uvm_declare_p_sequencer(SEQUENCER)

The example below shows using the uvm_declare_p_sequencer macro along with the uvm_object_utils macros to set up the sequence but not register the sequence in the sequencer's library.

class mysequence extends uvm_sequence#(mydata);
  uvm_object_utils(mysequence)
  uvm_declare_p_sequencer(some_seqr_type)
  task body;
    //Access some variable in the user&#39;s custom sequencer
    if(p_sequencer.some_variable) begin
      ...
    end
  endtask
endclass

uvm_declare_sequence_lib

** ** DEPRECATED ** **

Group- Sequencer Registration Macros

The sequencer-specific macros perform the same function as the set of uvm_componenent_*utils macros except that they also declare the plumbing necessary for creating the sequencer's sequence library.

uvm_delay(TIME)

#(TIME);

uvm_do(SEQ_OR_ITEM)

 
uvm_do(SEQ_OR_ITEM)

This macro takes as an argument a uvm_sequence_item variable or object. The argument is created using uvm_create if necessary, then randomized. In the case of an item, it is randomized after the call to <uvm_sequence_base::start_item()> returns. This is called late-randomization. In the case of a sequence, the sub-sequence is started using <uvm_sequence_base::start()> with call_pre_post set to 0. In the case of an item, the item is sent to the driver through the associated sequencer.

For a sequence item, the following are called, in order

|

uvm_create(item)
sequencer.wait_for_grant(prior) (task)
this.pre_do(1)                  (task)
item.randomize()
this.mid_do(item)               (func)
sequencer.send_request(item)    (func)
sequencer.wait_for_item_done()  (task)
this.post_do(item)              (func)

For a sequence, the following are called, in order

|

uvm_create(sub_seq)
sub_seq.randomize()
sub_seq.pre_start()         (task)
this.pre_do(0)              (task)
this.mid_do(sub_seq)        (func)
sub_seq.body()              (task)
this.post_do(sub_seq)       (func)
sub_seq.post_start()        (task)

uvm_do_callbacks(T, CB, METHOD)

uvm_do_callbacks_exit_on(T, CB, METHOD, VAL)

uvm_do_obj_callbacks(T, CB, OBJ, METHOD)

 
uvm_do_obj_callbacks(T,CB,OBJ,METHOD)

Calls the given METHOD of all callbacks based on type CB registered with the given object, OBJ , which is or is based on type T .

This macro is identical to uvm_do_callbacks macro, but it has an additional OBJ argument to allow the specification of an external object to associate the callback with. For example, if the callbacks are being applied in a sequence, OBJ could be specified as the associated sequencer or parent sequence.

...
uvm_do_callbacks(mycb, mycomp, seqr, my_function(seqr, curr_addr, curr_data))
...

uvm_do_obj_callbacks_exit_on(T, CB, OBJ, METHOD, VAL)

 
uvm_do_obj_callbacks_exit_on(T,CB,OBJ,METHOD,VAL)

Calls the given METHOD of all callbacks of type CB registered with the given object OBJ , which must be or be based on type T , and returns upon the first callback that returns the bit value given by VAL . It is exactly the same as the uvm_do_callbacks_exit_on but has a specific object instance (instead of the implicit this instance) as the third argument.

...
 // Exit if a callback returns a 1
 uvm_do_callbacks_exit_on(mycomp, mycb, seqr, drop_trans(seqr,trans), 1)
...

Because this macro calls return , its use is restricted to implementations of functions that return a bit value, as in the above example.

uvm_do_on(SEQ_OR_ITEM, SEQR)

 
uvm_do_on(SEQ_OR_ITEM, SEQR)

This is the same as uvm_do except that it also sets the parent sequence to the sequence in which the macro is invoked, and it sets the sequencer to the specified SEQR argument.

uvm_do_on_pri(SEQ_OR_ITEM, SEQR, PRIORITY)

 
uvm_do_on_pri(SEQ_OR_ITEM, SEQR, PRIORITY)

This is the same as uvm_do_pri except that it also sets the parent sequence to the sequence in which the macro is invoked, and it sets the sequencer to the specified SEQR argument.

uvm_do_on_pri_with(SEQ_OR_ITEM, SEQR, PRIORITY, CONSTRAINTS)

 
uvm_do_on_pri_with(SEQ_OR_ITEM, SEQR, PRIORITY, CONSTRAINTS)

This is the same as uvm_do_pri_with except that it also sets the parent sequence to the sequence in which the macro is invoked, and it sets the sequencer to the specified SEQR argument.

uvm_do_on_with(SEQ_OR_ITEM, SEQR, CONSTRAINTS)

 
uvm_do_on_with(SEQ_OR_ITEM, SEQR, CONSTRAINTS)

This is the same as uvm_do_with except that it also sets the parent sequence to the sequence in which the macro is invoked, and it sets the sequencer to the specified SEQR argument. The user must supply brackets around the constraints.

uvm_do_pri(SEQ_OR_ITEM, PRIORITY)

 
uvm_do_pri(SEQ_OR_ITEM, PRIORITY)

This is the same as uvm_do except that the sequence item or sequence is executed with the priority specified in the argument

uvm_do_pri_with(SEQ_OR_ITEM, PRIORITY, CONSTRAINTS)

 
uvm_do_pri_with(SEQ_OR_ITEM, PRIORITY, CONSTRAINTS)

This is the same as uvm_do_pri except that the given constraint block is applied to the item or sequence in a randomize with statement before execution.

uvm_do_seq(UVM_SEQ, SEQR_CONS_IF)

uvm_do_seq_with(UVM_SEQ, SEQR_CONS_IF, CONSTRAINTS)

uvm_do_with(SEQ_OR_ITEM, CONSTRAINTS)

 
uvm_do_with(SEQ_OR_ITEM, CONSTRAINTS)

This is the same as uvm_do except that the constraint block in the 2nd argument is applied to the item or sequence in a randomize with statement before execution.

uvm_end_package

uvm_error(ID, MSG)

Calls uvm_report_error with a verbosity of UVM_NONE. The message cannot be turned off using the reporter's verbosity setting, but can be turned off by setting the action for the message. ID is given as the message tag and MSG is given as the message text. The file and line are also sent to the uvm_report_error call.

uvm_error(ID, MSG)

uvm_error_begin(ID, MSG, RM =__uvm_msg)

 
uvm_error_begin(ID, MSG, RM = __uvm_msg)

uvm_error_context(ID, MSG, RO)

 
uvm_error_context(ID, MSG, RO)

Operates identically to uvm_error but requires that the context, or <uvm_report_object> in which the message is printed be explicitly supplied as a macro argument.

uvm_error_context_begin(ID, MSG, RO, RM =__uvm_msg)

 
uvm_error_context_begin(ID, MSG, RO, RM = __uvm_msg)

uvm_error_context_end

 
uvm_error_context_end

This macro pair operates identically to uvm_error_begin/uvm_error_end, but requires that the context, or <uvm_report_object> in which the message is printed be explicitly supplied as a macro argument.

uvm_error_end

This macro pair operates identically to uvm_info_begin/uvm_info_end with exception that the message severity is <UVM_ERROR> and has no verbosity threshold.

uvm_error_end

The usage shown in uvm_info_end works identically for this pair.

uvm_fatal(ID, MSG)

Calls uvm_report_fatal with a verbosity of UVM_NONE. The message cannot be turned off using the reporter's verbosity setting, but can be turned off by setting the action for the message. ID is given as the message tag and MSG is given as the message text. The file and line are also sent to the uvm_report_fatal call.

uvm_fatal(ID, MSG)

uvm_fatal_begin(ID, MSG, RM =__uvm_msg)

 
uvm_fatal_begin(ID, MSG, RM = __uvm_msg)

uvm_fatal_context(ID, MSG, RO)

 
uvm_fatal_context(ID, MSG, RO)

Operates identically to uvm_fatal but requires that the context, or <uvm_report_object>, in which the message is printed be explicitly supplied as a macro argument.

uvm_fatal_context_begin(ID, MSG, RO, RM =__uvm_msg)

 
uvm_fatal_context_begin(ID, MSG, RO, RM = __uvm_msg)

uvm_fatal_context_end

 
uvm_fatal_context_end

This macro pair operates identically to uvm_fatal_begin/uvm_fatal_end, but requires that the context, or <uvm_report_object> in which the message is printed be explicitly supplied as a macro argument.

uvm_fatal_end

This macro pair operates identically to uvm_info_begin/uvm_info_end with exception that the message severity is <UVM_FATAL> and has no verbosity threshold.

uvm_fatal_end

The usage shown in uvm_info_end works identically for this pair.

uvm_field_aa_int_byte(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the byte data type.

uvm_field_aa_int_byte(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with byte key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_byte_unsigned(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the byte unsigned data type.

uvm_field_aa_int_byte_unsigned(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with byte unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_enumkey(KEY, ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by any enumeration key data type. 

uvm_field_aa_int_enumkey(KEY, ARG,FLAG)

KEY is the enumeration type of the key, ARG is the name of a property that is an associative array of integrals, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_int(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the int data type.

uvm_field_aa_int_int(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with int key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_int_unsigned(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the int unsigned data type.

uvm_field_aa_int_int_unsigned(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with int unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_integer(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the integer data type.

uvm_field_aa_int_integer(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with integer key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_integer_unsigned(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the integer unsigned data type.

uvm_field_aa_int_integer_unsigned(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with integer unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_key(KEY, ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by any integral key data type. 

uvm_field_aa_int_key(KEY,ARG,FLAG)

KEY is the data type of the integral key, ARG is the name of a property that is an associative array of integrals, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_longint(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the longint data type.

uvm_field_aa_int_longint(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with longint key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_longint_unsigned(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the longint unsigned data type.

uvm_field_aa_int_longint_unsigned(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with longint unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_shortint(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the shortint data type.

uvm_field_aa_int_shortint(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with shortint key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_shortint_unsigned(ARG, FLAG)

Implements the data operations for an associative array of integral types indexed by the shortint unsigned data type.

uvm_field_aa_int_shortint_unsigned(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with shortint unsigned key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_int_string(ARG, FLAG)

Implements the data operations for an associative array of integrals indexed by string .

uvm_field_aa_int_string(ARG,FLAG)

ARG is the name of a property that is an associative array of integrals with string key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_object_int(ARG, FLAG)

Implements the data operations for an associative array of <uvm_object>-based objects indexed by the int data type.

uvm_field_aa_object_int(ARG,FLAG)

ARG is the name of a property that is an associative array of objects with int key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_object_string(ARG, FLAG)

Implements the data operations for an associative array of <uvm_object>-based objects indexed by string .

uvm_field_aa_object_string(ARG,FLAG)

ARG is the name of a property that is an associative array of objects with string key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_aa_string_string(ARG, FLAG)

Implements the data operations for an associative array of strings indexed by string .

uvm_field_aa_string_string(ARG,FLAG)

ARG is the name of a property that is an associative array of strings with string key, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_array_enum(T, ARG, FLAG)

Implements the data operations for a one-dimensional dynamic array of enums.

uvm_field_array_enum(T,ARG,FLAG)

T is a one-dimensional dynamic array of enums type, ARG is an instance of that type, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_array_int(ARG, FLAG)

Implements the data operations for a one-dimensional dynamic array of integrals.

uvm_field_array_int(ARG,FLAG)

ARG is a one-dimensional dynamic array of integrals, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_array_object(ARG, FLAG)

Implements the data operations for a one-dimensional dynamic array of <uvm_object>-based objects.

uvm_field_array_object(ARG,FLAG)

ARG is a one-dimensional dynamic array of <uvm_object>-based objects, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_array_string(ARG, FLAG)

Implements the data operations for a one-dimensional dynamic array of strings.

uvm_field_array_string(ARG,FLAG)

ARG is a one-dimensional dynamic array of strings, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_enum(T, ARG, FLAG)

Implements the data operations for an enumerated property.

uvm_field_enum(T,ARG,FLAG)

T is an enumerated type, ARG is an instance of that type, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_event(ARG, FLAG)

Implements the data operations for an event property.

uvm_field_event(ARG,FLAG)

ARG is an event property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_int(ARG, FLAG)

Implements the data operations for any packed integral property.

uvm_field_int(ARG,FLAG)

ARG is an integral property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_object(ARG, FLAG)

Implements the data operations for a <uvm_object>-based property.

uvm_field_object(ARG,FLAG)

ARG is an object property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_queue_enum(T, ARG, FLAG)

Implements the data operations for a one-dimensional queue of enums.

uvm_field_queue_enum(T,ARG,FLAG)

T is a queue of enums type, ARG is an instance of that type, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_queue_int(ARG, FLAG)

Implements the data operations for a queue of integrals.

uvm_field_queue_int(ARG,FLAG)

ARG is a one-dimensional queue of integrals, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_queue_object(ARG, FLAG)

Implements the data operations for a queue of <uvm_object>-based objects.

uvm_field_queue_object(ARG,FLAG)

ARG is a one-dimensional queue of <uvm_object>-based objects, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_queue_string(ARG, FLAG)

Implements the data operations for a queue of strings.

uvm_field_queue_string(ARG,FLAG)

ARG is a one-dimensional queue of strings, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_real(ARG, FLAG)

Implements the data operations for any real property.

uvm_field_real(ARG,FLAG)

ARG is an real property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_sarray_enum(T, ARG, FLAG)

Implements the data operations for a one-dimensional static array of enums.

uvm_field_sarray_enum(T,ARG,FLAG)

T is a one-dimensional dynamic array of enums type, ARG is an instance of that type, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_sarray_int(ARG, FLAG)

Implements the data operations for a one-dimensional static array of integrals.

uvm_field_sarray_int(ARG,FLAG)

ARG is a one-dimensional static array of integrals, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_sarray_object(ARG, FLAG)

Implements the data operations for a one-dimensional static array of <uvm_object>-based objects.

uvm_field_sarray_object(ARG,FLAG)

ARG is a one-dimensional static array of <uvm_object>-based objects, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_sarray_string(ARG, FLAG)

Implements the data operations for a one-dimensional static array of strings.

uvm_field_sarray_string(ARG,FLAG)

ARG is a one-dimensional static array of strings, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_string(ARG, FLAG)

Implements the data operations for a string property.

uvm_field_string(ARG,FLAG)

ARG is a string property of the class, and FLAG is a bitwise OR of one or more flag settings as described in <Field Macros> above.

uvm_field_utils_begin(T)

MACRO

uvm_field_utils_end

These macros form a block in which uvm_field_* macros can be placed. Used as

uvm_field_utils_begin(TYPE)
  uvm_field_* macros here
uvm_field_utils_end

These macros do not perform factory registration nor implement the get_type_name and create methods. Use this form when you need custom implementations of these two methods, or when you are setting up field macros for an abstract class (i.e. virtual class).

uvm_field_utils_end

uvm_file

__FILE__

uvm_get_imp_decl(SFX)

 
uvm_get_imp_decl(SFX)

Define the class uvm_get_impSFX for providing both blocking and non-blocking get implementations. SFX is the suffix for the new class type.

uvm_get_peek_imp_decl(SFX)

 
uvm_get_peek_imp_decl(SFX)

Define the class uvm_get_peek_impSFX for providing both blocking and non-blocking get_peek implementations. SFX is the suffix for the new class type.

uvm_info(ID, MSG, VERBOSITY)

Calls uvm_report_info if VERBOSITY is lower than the configured verbosity of the associated reporter. ID is given as the message tag and MSG is given as the message text. The file and line are also sent to the uvm_report_info call.

uvm_info(ID, MSG, VERBOSITY)

uvm_info_begin(ID, MSG, VERBOSITY, RM =__uvm_msg)

 
uvm_info_begin(ID, MSG, VERBOSITY, RM = __uvm_msg)

uvm_info_context(ID, MSG, VERBOSITY, RO)

 
uvm_info_context(ID, MSG, VERBOSITY, RO)

Operates identically to uvm_info but requires that the context, or <uvm_report_object>, in which the message is printed be explicitly supplied as a macro argument.

uvm_info_context_begin(ID, MSG, VERBOSITY, RO, RM =__uvm_msg)

 
uvm_info_context_begin(ID, MSG, UVM_NONE, RO, RM = __uvm_msg)

uvm_info_context_end

 
uvm_info_context_end

This macro pair operates identically to uvm_info_begin/uvm_info_end, but requires that the context, or <uvm_report_object> in which the message is printed be explicitly supplied as a macro argument.

uvm_info_end

This macro pair provides the ability to add elements to messages.

uvm_info_end

Example usage is shown here.

...
task my_task();
   ...
   uvm_info_begin(&quot;MY_ID&quot;, &quot;This is my message...&quot;, UVM_LOW)
     uvm_message_add_tag(&quot;my_color&quot;, &quot;red&quot;)
     uvm_message_add_int(my_int, UVM_DEC)
     uvm_message_add_string(my_string)
     uvm_message_add_object(my_obj)
   uvm_info_end
   ...
endtask

uvm_line

__LINE__

uvm_master_imp_decl(SFX)

 
uvm_master_imp_decl(SFX)

Define the class uvm_master_impSFX for providing both blocking and non-blocking master implementations. SFX is the suffix for the new class type.

uvm_message_add_int(VAR, RADIX, LABEL ="", ACTION =(UVM_LOG|UVM_RM_RECORD))

 
uvm_message_add_int(VAR, RADIX, LABEL = &quot;&quot;, ACTION=(UVM_LOG|UVM_RM_RECORD))

uvm_message_add_object(VAR, LABEL ="", ACTION =(UVM_LOG|UVM_RM_RECORD))

These macros allow the user to provide elements that are associated with <uvm_report_message>s. Separate macros are provided such that the user can supply arbitrary string/string pairs using uvm_message_add_tag, integral types along with a radix using uvm_message_add_int, string using uvm_message_add_string and <uvm_object>s using uvm_message_add_object.

uvm_message_add_object(VAR, LABEL = &quot;&quot;, ACTION=(UVM_LOG|UVM_RM_RECORD))

Example usage is shown in uvm_info_end.

uvm_message_add_string(VAR, LABEL ="", ACTION =(UVM_LOG|UVM_RM_RECORD))

 
uvm_message_add_string(VAR, LABEL = &quot;&quot;, ACTION=(UVM_LOG|UVM_RM_RECORD))

uvm_message_add_tag(NAME, VALUE, ACTION =(UVM_LOG|UVM_RM_RECORD))

 
uvm_message_add_tag(NAME, VALUE, ACTION=(UVM_LOG|UVM_RM_RECORD))

uvm_message_begin(SEVERITY, ID, MSG, VERBOSITY, FILE, LINE, RM)

MACRO- uvm_message_begin

Undocumented. Library internal use.

uvm_message_context_begin(SEVERITY, ID, MSG, VERBOSITY, FILE, LINE, RO, RM)

MACRO- uvm_message_context_begin

Undocumented. Library internal use.

uvm_message_context_end

MACRO- uvm_message_context_end

Undocumented. Library internal use.

uvm_message_end

MACRO- uvm_message_end

Undocumented. Library internal use.

uvm_new_func

uvm_new_func

uvm_non_blocking_transport_imp_decl(SFX)

uvm_nonblocking_get_imp_decl(SFX)

 
uvm_nonblocking_get_imp_decl(SFX)

Define the class uvm_nonblocking_get_impSFX for providing non-blocking get implementations. SFX is the suffix for the new class type.

uvm_nonblocking_get_peek_imp_decl(SFX)

 
uvm_nonblocking_get_peek_imp_decl(SFX)

Define the class uvm_nonblocking_get_peek_impSFX for providing non-blocking get_peek implementation.

uvm_nonblocking_master_imp_decl(SFX)

 
uvm_nonblocking_master_imp_decl(SFX)

Define the class uvm_nonblocking_master_impSFX for providing the non-blocking master implementation.

uvm_nonblocking_peek_imp_decl(SFX)

 
uvm_nonblocking_peek_imp_decl(SFX)

Define the class uvm_nonblocking_peek_impSFX for providing non-blocking peek implementations. SFX is the suffix for the new class type.

uvm_nonblocking_put_imp_decl(SFX)

 
uvm_nonblocking_put_imp_decl(SFX)

Define the class uvm_nonblocking_put_impSFX for providing non-blocking put implementations. SFX is the suffix for the new class type.

uvm_nonblocking_slave_imp_decl(SFX)

 
uvm_nonblocking_slave_imp_decl(SFX)

Define the class uvm_nonblocking_slave_impSFX for providing the non-blocking slave implementation.

uvm_nonblocking_transport_imp_decl(SFX)

 
uvm_nonblocking_transport_imp_decl(SFX)

Define the class uvm_nonblocking_transport_impSFX for providing the non-blocking transport implementation.

uvm_object_param_utils(T)

uvm_object_param_utils_begin(T)

uvm_object_registry(T, S)

Register a uvm_object-based class with the factory

uvm_object_registry(T,S)

Registers a uvm_object-based class T and lookup string S with the factory. S typically is the name of the class in quotes. The uvm_object_utils family of macros uses this macro.

uvm_object_utils(T)

MACRO

uvm_object_utils_end

<uvm_object>-based class declarations may contain one of the above forms of utility macros.

For simple objects with no field macros, use

uvm_object_utils(TYPE)

For simple objects with field macros, use

uvm_object_utils_begin(TYPE)
  uvm_field_* macro invocations here
uvm_object_utils_end

For parameterized objects with no field macros, use

uvm_object_param_utils(TYPE)

For parameterized objects, with field macros, use

uvm_object_param_utils_begin(TYPE)
  uvm_field_* macro invocations here
uvm_object_utils_end

Simple (non-parameterized) objects use the uvm_object_utils* versions, which do the following:

  • Implements get_type_name, which returns TYPE as a string

  • Implements create, which allocates an object of type TYPE by calling its constructor with no arguments. TYPE's constructor, if defined, must have default values on all it arguments.

  • Registers the TYPE with the factory, using the string TYPE as the factory lookup string for the type.

  • Implements the static get_type() method which returns a factory proxy object for the type.

  • Implements the virtual get_object_type() method which works just like the static get_type() method, but operates on an already allocated object.

Parameterized classes must use the uvm_object_param_utils* versions. They differ from uvm_object_utils only in that they do not supply a type name when registering the object with the factory. As such, name-based lookup with the factory for parameterized classes is not possible.

The macros with _begin suffixes are the same as the non-suffixed versions except that they also start a block in which uvm_field_* macros can be placed. The block must be terminated by uvm_object_utils_end.

uvm_object_utils_begin(T)

uvm_object_utils_end

uvm_pack_array(VAR)

Pack a dynamic array without having to also specify the bit size of its elements. Array size must be non-zero.

uvm_pack_array(VAR)

uvm_pack_arrayN(VAR, SIZE)

Pack a dynamic array of integrals.

uvm_pack_arrayN(VAR,SIZE)

uvm_pack_enum(VAR)

Pack an enumeration value. Packing does not require its type be specified.

uvm_pack_enum(VAR)

uvm_pack_enumN(VAR, SIZE)

Pack an integral variable.

uvm_pack_enumN(VAR,SIZE)

uvm_pack_int(VAR)

Pack an integral variable without having to also specify the bit size.

uvm_pack_int(VAR)

uvm_pack_intN(VAR, SIZE)

Pack an integral variable.

uvm_pack_intN(VAR,SIZE)

uvm_pack_queue(VAR)

Pack a queue without having to also specify the bit size of its elements. Queue must not be empty.

uvm_pack_queue(VAR)

uvm_pack_queueN(VAR, SIZE)

Pack a queue of integrals.

uvm_pack_queueN(VAR,SIZE)

uvm_pack_real(VAR)

Pack a variable of type real.

uvm_pack_real(VAR)

uvm_pack_sarray(VAR)

Pack a static array without having to also specify the bit size of its elements.

uvm_pack_sarray(VAR)

uvm_pack_sarrayN(VAR, SIZE)

Pack a static array of integrals.

uvm_pack_sarray(VAR,SIZE)

uvm_pack_string(VAR)

Pack a string variable.

uvm_pack_string(VAR)

uvm_package(PKG)

MACRO- uvm_package

Use uvm_package to define the SV package and to create a bogus type to help automate triggering the static initializers of the package. Use uvm_end_package to endpackage.

uvm_peek_imp_decl(SFX)

 
uvm_peek_imp_decl(SFX)

Define the class uvm_peek_impSFX for providing both blocking and non-blocking peek implementations. SFX is the suffix for the new class type.

uvm_print_aa_int_key4(KEY, F, R, P)

uvm_print_aa_int_object(F, FLAG)

uvm_print_aa_int_object3(F, P, FLAG)

uvm_print_aa_string_int(F)

Associative array printing methods

uvm_print_aa_string_int3(F, R, P)

uvm_print_aa_string_object(F, FLAG)

uvm_print_aa_string_object3(F, P, FLAG)

uvm_print_aa_string_string(F)

uvm_print_aa_string_string2(F, P)

uvm_print_array_int(F, R)

uvm_print_array*

uvm_print_array_int3(F, R, P)

uvm_print_array_object(F, FLAG)

uvm_print_array_object3(F, P, FLAG)

uvm_print_array_string(F)

uvm_print_array_string2(F, P)

uvm_print_enum(T, F, NM, P)

uvm_print_enum

uvm_print_int(F, R)

uvm_print_int*

uvm_print_int3(F, R, P)

uvm_print_int4(F, R, NM, P)

uvm_print_object(F)

uvm_print_object*

uvm_print_object2(F, P)

uvm_print_object_qda4(F, P, T, FLAG)

uvm_print_object_queue(F, FLAG)

uvm_print_object_queue3(F, P, FLAG)

uvm_print_qda_enum(F, P, T, ET)

uvm_print_qda_int4(F, R, P, T)

uvm_print_queue_int(F, R)

uvm_print_queue_int3(F, R, P)

uvm_print_sarray_int3(F, R, P)

uvm_print_sarray*

uvm_print_sarray_object(F, FLAG)

uvm_print_sarray_object3(F, P, FLAG)

uvm_print_sarray_string2(F, P)

uvm_print_string(F)

uvm_print_string*

uvm_print_string2(F, P)

uvm_print_string_qda3(F, P, T)

uvm_print_string_queue(F)

uvm_print_string_queue2(F, P)

uvm_put_imp_decl(SFX)

 
uvm_put_imp_decl(SFX)

Define the class uvm_put_impSFX for providing both blocking and non-blocking put implementations. SFX is the suffix for the new class type.

uvm_rand_send(SEQ_OR_ITEM)

 
uvm_rand_send(SEQ_OR_ITEM)

This macro processes the item or sequence that has been already been allocated (possibly with uvm_create). The processing is done with randomization. Essentially, an uvm_do without the create.

uvm_rand_send_pri(SEQ_OR_ITEM, PRIORITY)

 
uvm_rand_send_pri(SEQ_OR_ITEM, PRIORITY)

This is the same as uvm_rand_send except that the sequence item or sequence is executed with the priority specified in the argument.

uvm_rand_send_pri_with(SEQ_OR_ITEM, PRIORITY, CONSTRAINTS)

 
uvm_rand_send_pri_with(SEQ_OR_ITEM, PRIORITY, CONSTRAINTS)

This is the same as uvm_rand_send_pri except that the given constraint block is applied to the item or sequence in a randomize with statement before execution.

uvm_rand_send_with(SEQ_OR_ITEM, CONSTRAINTS)

 
uvm_rand_send_with(SEQ_OR_ITEM, CONSTRAINTS)

This is the same as uvm_rand_send except that the given constraint block is applied to the item or sequence in a randomize with statement before execution.

uvm_record_field(NAME, VALUE)

Macro for recording arbitrary name-value pairs into a transaction recording database. Requires a valid transaction handle, as provided by the <uvm_transaction::begin_tr> and <uvm_component::begin_tr> methods. 

uvm_record_field(NAME, VALUE)

The default implementation will pass the name/value pair to uvm_record_attribute if enabled, otherwise the information will be passed to <uvm_recorder::record_generic>, with the VALUE being converted to a string using "%p" notation.

recorder.record_generic(NAME,$sformatf(&quot;%p&quot;,VALUE));

uvm_register_cb(T, CB)

 
uvm_register_cb(T,CB)

Registers the given CB callback type with the given T object type. If a type-callback pair is not registered then a warning is issued if an attempt is made to use the pair (add, delete, etc.).

The registration will typically occur in the component that executes the given type of callback. For instance:

virtual class mycb extends uvm_callback;
  virtual function void doit();
endclass

class my_comp extends uvm_component;
  uvm_register_cb(my_comp,mycb)
  ...
  task run_phase(uvm_phase phase);
    ...
    uvm_do_callbacks(my_comp, mycb, doit())
  endtask
endclass

uvm_send(SEQ_OR_ITEM)

 
uvm_send(SEQ_OR_ITEM)

This macro processes the item or sequence that has been created using uvm_create. The processing is done without randomization. Essentially, an uvm_do without the create or randomization.

uvm_send_pri(SEQ_OR_ITEM, PRIORITY)

 
uvm_send_pri(SEQ_OR_ITEM, PRIORITY)

This is the same as uvm_send except that the sequence item or sequence is executed with the priority specified in the argument.

uvm_sequence_library_package(PKG_NAME)

MACRO- uvm_sequence_library_package

This macro is used to trigger static initializers in packages. uvm_package creates a bogus type which gets referred to by uvm_sequence_library_package to make a package-based variable of the bogus type.

uvm_sequence_library_utils(TYPE)

 
uvm_sequence_library_utils(TYPE)

Declares the infrastructure needed to define extensions to the <uvm_sequence_library> class. You define new sequence library subtypes to statically specify sequence membership from within sequence definitions. See also <uvm_add_to_sequence_library> for more information.

typedef simple_seq_lib uvm_sequence_library #(simple_item);

class simple_seq_lib_RST extends simple_seq_lib;

  uvm_object_utils(simple_seq_lib_RST)

  uvm_sequence_library_utils(simple_seq_lib_RST)

  function new(string name=&quot;&quot;);
    super.new(name);
  endfunction

endclass

Each library, itself a sequence, can then be started independently on different sequencers or in different phases of the same sequencer. See <uvm_sequencer_base::start_phase_sequence> for information on starting default sequences.

uvm_sequence_utils(TYPE_NAME, SEQUENCER)

MACRO- uvm_sequence_utils

The sequence macros can be used in non-parameterized <uvm_sequence #(REQ,RSP)> extensions to pre-register the sequence with a given <uvm_sequencer #(REQ,RSP)> type.

For sequences that do not use any uvm_field macros:

uvm_sequence_utils(TYPE_NAME,SQR_TYPE_NAME)

For sequences employing with field macros:

uvm_sequence_utils_begin(TYPE_NAME,SQR_TYPE_NAME)
  uvm_field_* macro invocations here
uvm_sequence_utils_end

The sequence-specific macros perform the same function as the set of uvm_object_*_utils macros except that they also register the sequence's type, TYPE_NAME, with the given sequencer type, SQR_TYPE_NAME, and define the p_sequencer variable and m_set_p_sequencer method.

Use uvm_sequence_utils[begin] for non-parameterized classes and uvm_sequenceparam_utils[_begin] for parameterized classes.

uvm_sequence_utils_begin(TYPE_NAME, SEQUENCER)

MACRO- uvm_sequence_utils_begin

uvm_sequence_utils_end

MACRO- uvm_sequence_utils_end

uvm_sequencer_param_utils(TYPE_NAME)

MACRO- uvm_sequencer_param_utils

uvm_sequencer_param_utils_begin(TYPE_NAME)

MACRO- uvm_sequencer_param_utils_begin

uvm_sequencer_utils(TYPE_NAME)

MACRO- uvm_sequencer_utils

uvm_sequencer_utils_begin(TYPE_NAME)

MACRO- uvm_sequencer_utils_begin

uvm_sequencer_utils_end

MACRO- uvm_sequencer_utils_end

The sequencer macros are used in uvm_sequencer-based class declarations in one of four ways.

For simple sequencers, no field macros

uvm_sequencer_utils(SQR_TYPE_NAME)

For simple sequencers, with field macros

uvm_sequencer_utils_begin(SQR_TYPE_NAME) uvm_field_* macros here uvm_sequencer_utils_end

For parameterized sequencers, no field macros

uvm_sequencer_param_utils(SQR_TYPE_NAME)

For parameterized sequencers, with field macros

uvm_sequencer_param_utils_begin(SQR_TYPE_NAME) uvm_field_* macros here uvm_sequencer_utils_end

The sequencer-specific macros perform the same function as the set of uvm_componenent_*utils macros except that they also declare the plumbing necessary for creating the sequencer's sequence library. This includes:

  1. Declaring the type-based static queue of strings registered on the sequencer type.

  2. Declaring the static function to add strings to item #1 above.

  3. Declaring the static function to remove strings to item #1 above.

  4. Declaring the function to populate the instance specific sequence library for a sequencer.

Use uvm_sequencer_utils[begin] for non-parameterized classes and uvm_sequencerparam_utils[_begin] for parameterized classes.

uvm_set_super_type(T, ST)

 
uvm_set_super_type(T,ST)

Defines the super type of T to be ST . This allows for derived class objects to inherit typewide callbacks that are registered with the base class.

The registration will typically occur in the component that executes the given type of callback. For instance:

virtual class mycb extend uvm_callback;
  virtual function void doit();
endclass

class my_comp extends uvm_component;
  uvm_register_cb(my_comp,mycb)
  ...
  task run_phase(uvm_phase phase);
    ...
    uvm_do_callbacks(my_comp, mycb, doit())
  endtask
endclass

class my_derived_comp extends my_comp;
  uvm_set_super_type(my_derived_comp,my_comp)
  ...
  task run_phase(uvm_phase phase);
    ...
    uvm_do_callbacks(my_comp, mycb, doit())
  endtask
endclass

uvm_slave_imp_decl(SFX)

 
uvm_slave_imp_decl(SFX)

Define the class uvm_slave_impSFX for providing both blocking and non-blocking slave implementations. SFX is the suffix for the new class type.

uvm_transport_imp_decl(SFX)

 
uvm_transport_imp_decl(SFX)

Define the class uvm_transport_impSFX for providing both blocking and non-blocking transport implementations. SFX is the suffix for the new class type.

uvm_typename(X)

$typename(X)

uvm_unpack_array(VAR)

Unpack a dynamic array without having to also specify the bit size of its elements. Array size must be non-zero.

uvm_unpack_array(VAR)

uvm_unpack_arrayN(VAR, SIZE)

Unpack into a dynamic array of integrals.

uvm_unpack_arrayN(VAR,SIZE)

uvm_unpack_enum(VAR, TYPE)

Unpack an enumeration value, which requires its type be specified.

uvm_unpack_enum(VAR,TYPE)

uvm_unpack_enumN(VAR, SIZE, TYPE)

Unpack enum of type TYPE into VAR .

uvm_unpack_enumN(VAR,SIZE,TYPE)

uvm_unpack_int(VAR)

Unpack an integral variable without having to also specify the bit size.

uvm_unpack_int(VAR)

uvm_unpack_intN(VAR, SIZE)

Unpack into an integral variable.

uvm_unpack_intN(VAR,SIZE)

uvm_unpack_queue(VAR)

Unpack a queue without having to also specify the bit size of its elements. Queue must not be empty.

uvm_unpack_queue(VAR)

uvm_unpack_queueN(VAR, SIZE)

Unpack into a queue of integrals.

uvm_unpack_queue(VAR,SIZE)

uvm_unpack_real(VAR)

Unpack a variable of type real.

uvm_unpack_real(VAR)

uvm_unpack_sarray(VAR)

Unpack a static array without having to also specify the bit size of its elements.

uvm_unpack_sarray(VAR)

uvm_unpack_sarrayN(VAR, SIZE)

Unpack a static (fixed) array of integrals.

uvm_unpack_sarrayN(VAR,SIZE)

uvm_unpack_string(VAR)

Unpack a string variable.

uvm_unpack_string(VAR)

uvm_update_sequence_lib

MACRO- uvm_update_sequence_lib

This macro populates the instance-specific sequence library for a sequencer. It should be invoked inside the sequencer��s constructor.

uvm_update_sequence_lib_and_item(USER_ITEM)

MACRO- uvm_update_sequence_lib_and_item

This macro populates the instance specific sequence library for a sequencer, and it registers the given USER_ITEM as an instance override for the simple sequence's item variable.

The macro should be invoked inside the sequencer's constructor.

uvm_user_bottomup_phase(PHASE, COMP, PREFIX)

uvm_user_task_phase(PHASE, COMP, PREFIX)

uvm_user_topdown_phase(PHASE, COMP, PREFIX)

uvm_warning(ID, MSG)

Calls uvm_report_warning with a verbosity of UVM_NONE. The message cannot be turned off using the reporter's verbosity setting, but can be turned off by setting the action for the message. ID is given as the message tag and MSG is given as the message text. The file and line are also sent to the uvm_report_warning call.

uvm_warning(ID, MSG)

uvm_warning_begin(ID, MSG, RM =__uvm_msg)

 
uvm_warning_begin(ID, MSG, RM = __uvm_msg)

uvm_warning_context(ID, MSG, RO)

 
uvm_warning_context(ID, MSG, RO)

Operates identically to uvm_warning but requires that the context, or <uvm_report_object>, in which the message is printed be explicitly supplied as a macro argument.

uvm_warning_context_begin(ID, MSG, RO, RM =__uvm_msg)

 
uvm_warning_context_begin(ID, MSG, RO, RM = __uvm_msg)

uvm_warning_context_end

 
uvm_warning_context_end

This macro pair operates identically to uvm_warning_begin/uvm_warning_end, but requires that the context, or <uvm_report_object> in which the message is printed be explicitly supplied as a macro argument.

uvm_warning_end

This macro pair operates identically to uvm_info_begin/uvm_info_end with exception that the message severity is <UVM_WARNING> and has no verbosity threshold.

uvm_warning_end

The usage shown in uvm_info_end works identically for this pair.