Macros
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) |
Name |
Description |
|---|---|
UVM_CB_TRACE_ON |
|
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 " |
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 |
|
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 |
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, uvm export 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 |
MACRO `UVM_DEFAULT_TIMEOUT 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 |
Macro UVM_MAJOR_REV 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 |
Macro 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 |
Macro UVM_MINOR_REV 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 |
Macro 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 |
Macro UVM_NAME 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 |
Macro 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 where typedef where |
|
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) |
MACRO `UVM_TLM_B_MASK Define blocking mask onehot assignment = 'b100 |
UVM_TLM_B_TRANSPORT_IMP(imp, T, t, delay) |
Macro `UVM_TLM_B_TRANSPORT_IMP 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" |
MACRO `UVM_TLM_FUNCTION_ERROR 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) |
MACRO `UVM_TLM_NB_BW_MASK Define Non blocking backward mask onehot assignment = 'b010 |
UVM_TLM_NB_FW_MASK |
(1<<0) |
MACRO `UVM_TLM_NB_FW_MASK Define Non blocking Forward mask onehot assignment = 'b001 |
UVM_TLM_NB_TRANSPORT_BW_IMP(imp, T, P, t, p, delay) |
Macro `UVM_TLM_NB_TRANSPORT_BW_IMP 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](./index-macros.html#macros) 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("initiator_socket", 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) |
Macro `UVM_TLM_NB_TRANSPORT_FW_IMP 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](./index-macros.html#macros) 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" |
MACRO `UVM_TLM_TASK_ERROR 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 |
Macro 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) |
MACRO `uvm_analysis_imp_decl `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("ingress", this);
egress = new("egress", 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) |
MACRO `uvm_blocking_get_imp_decl `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) |
MACRO `uvm_blocking_get_peek_imp_decl `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) |
MACRO `uvm_blocking_master_imp_decl `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) |
MACRO `uvm_blocking_peek_imp_decl `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) |
MACRO `uvm_blocking_put_imp_decl `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) |
MACRO `uvm_blocking_slave_imp_decl `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) |
MACRO `uvm_blocking_transport_imp_decl `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) |
PREFIX |
|
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) |
MACRO `uvm_component_registry 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](./index-macros.html#macros) 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:
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_component_utils_begin(T) |
||
uvm_component_utils_end |
||
uvm_create(SEQ_OR_ITEM) |
MACRO `uvm_create `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) |
MACRO `uvm_create_on `uvm_create_on(SEQ_OR_ITEM, SEQR) This is the same as [`uvm_create](./index-macros.html#macros) 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) |
MACRO `uvm_declare_p_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'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) |
MACRO `uvm_do `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](./index-macros.html#macros) 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) |
MACRO `uvm_do_obj_callbacks `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](./index-macros.html#macros) 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) |
MACRO `uvm_do_obj_callbacks_exit_on `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](./index-macros.html#macros) 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) |
MACRO `uvm_do_on `uvm_do_on(SEQ_OR_ITEM, SEQR) This is the same as [`uvm_do](./index-macros.html#macros) 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) |
MACRO `uvm_do_on_pri `uvm_do_on_pri(SEQ_OR_ITEM, SEQR, PRIORITY) This is the same as [`uvm_do_pri](./index-macros.html#macros) 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) |
MACRO `uvm_do_on_pri_with `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) |
MACRO `uvm_do_on_with `uvm_do_on_with(SEQ_OR_ITEM, SEQR, CONSTRAINTS) This is the same as [`uvm_do_with](./index-macros.html#macros) 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) |
MACRO `uvm_do_pri `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) |
MACRO `uvm_do_pri_with `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) |
MACRO `uvm_do_with `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) |
MACRO `uvm_error 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) |
MACRO `uvm_error_begin `uvm_error_begin(ID, MSG, RM = __uvm_msg) |
|
uvm_error_context(ID, MSG, RO) |
MACRO `uvm_error_context `uvm_error_context(ID, MSG, RO) Operates identically to `uvm_error but requires that the
context, or |
|
uvm_error_context_begin(ID, MSG, RO, RM =__uvm_msg) |
MACRO `uvm_error_context_begin `uvm_error_context_begin(ID, MSG, RO, RM = __uvm_msg) |
|
uvm_error_context_end |
MACRO `uvm_error_context_end `uvm_error_context_end This macro pair operates identically to |
|
uvm_error_end |
MACRO `uvm_error_end This macro pair operates identically to `uvm_error_end The usage shown in [`uvm_info_end](./index-macros.html#macros) works identically for this pair. |
|
uvm_fatal(ID, MSG) |
MACRO `uvm_fatal 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) |
MACRO `uvm_fatal_begin `uvm_fatal_begin(ID, MSG, RM = __uvm_msg) |
|
uvm_fatal_context(ID, MSG, RO) |
MACRO `uvm_fatal_context `uvm_fatal_context(ID, MSG, RO) Operates identically to `uvm_fatal but requires that the
context, or |
|
uvm_fatal_context_begin(ID, MSG, RO, RM =__uvm_msg) |
MACRO `uvm_fatal_context_begin `uvm_fatal_context_begin(ID, MSG, RO, RM = __uvm_msg) |
|
uvm_fatal_context_end |
MACRO `uvm_fatal_context_end `uvm_fatal_context_end This macro pair operates identically to |
|
uvm_fatal_end |
MACRO `uvm_fatal_end This macro pair operates identically to `uvm_fatal_end The usage shown in [`uvm_info_end](./index-macros.html#macros) works identically for this pair. |
|
uvm_field_aa_int_byte(ARG, FLAG) |
MACRO `uvm_field_aa_int_byte 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 |
|
uvm_field_aa_int_byte_unsigned(ARG, FLAG) |
MACRO `uvm_field_aa_int_byte_unsigned 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 |
|
uvm_field_aa_int_enumkey(KEY, ARG, FLAG) |
MACRO `uvm_field_aa_int_enumkey 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 |
|
uvm_field_aa_int_int(ARG, FLAG) |
MACRO `uvm_field_aa_int_int 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 |
|
uvm_field_aa_int_int_unsigned(ARG, FLAG) |
MACRO `uvm_field_aa_int_int_unsigned 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 |
|
uvm_field_aa_int_integer(ARG, FLAG) |
MACRO `uvm_field_aa_int_integer 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 |
|
uvm_field_aa_int_integer_unsigned(ARG, FLAG) |
MACRO `uvm_field_aa_int_integer_unsigned 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 |
|
uvm_field_aa_int_key(KEY, ARG, FLAG) |
MACRO `uvm_field_aa_int_key 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 |
|
uvm_field_aa_int_longint(ARG, FLAG) |
MACRO `uvm_field_aa_int_longint 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 |
|
uvm_field_aa_int_longint_unsigned(ARG, FLAG) |
MACRO `uvm_field_aa_int_longint_unsigned 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 |
|
uvm_field_aa_int_shortint(ARG, FLAG) |
MACRO `uvm_field_aa_int_shortint 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 |
|
uvm_field_aa_int_shortint_unsigned(ARG, FLAG) |
MACRO `uvm_field_aa_int_shortint_unsigned 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 |
|
uvm_field_aa_int_string(ARG, FLAG) |
MACRO `uvm_field_aa_int_string 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 |
|
uvm_field_aa_object_int(ARG, FLAG) |
MACRO `uvm_field_aa_object_int Implements the data operations for an associative array of `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 |
|
uvm_field_aa_object_string(ARG, FLAG) |
MACRO `uvm_field_aa_object_string Implements the data operations for an associative array of `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 |
|
uvm_field_aa_string_string(ARG, FLAG) |
MACRO `uvm_field_aa_string_string 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 |
|
uvm_field_array_enum(T, ARG, FLAG) |
MACRO `uvm_field_array_enum 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 |
|
uvm_field_array_int(ARG, FLAG) |
MACRO `uvm_field_array_int 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
|
|
uvm_field_array_object(ARG, FLAG) |
MACRO `uvm_field_array_object Implements the data operations for a one-dimensional dynamic array
of `uvm_field_array_object(ARG,FLAG) ARG is a one-dimensional dynamic array of |
|
uvm_field_array_string(ARG, FLAG) |
MACRO `uvm_field_array_string 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 |
|
uvm_field_enum(T, ARG, FLAG) |
MACRO `uvm_field_enum 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
|
|
uvm_field_event(ARG, FLAG) |
MACRO `uvm_field_event 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 |
|
uvm_field_int(ARG, FLAG) |
MACRO `uvm_field_int 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 |
|
uvm_field_object(ARG, FLAG) |
MACRO `uvm_field_object Implements the data operations for a `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 |
|
uvm_field_queue_enum(T, ARG, FLAG) |
MACRO `uvm_field_queue_enum 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 |
|
uvm_field_queue_int(ARG, FLAG) |
MACRO `uvm_field_queue_int 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
|
|
uvm_field_queue_object(ARG, FLAG) |
MACRO `uvm_field_queue_object Implements the data operations for a queue of `uvm_field_queue_object(ARG,FLAG) ARG is a one-dimensional queue of |
|
uvm_field_queue_string(ARG, FLAG) |
MACRO `uvm_field_queue_string 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 |
|
uvm_field_real(ARG, FLAG) |
MACRO `uvm_field_real 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 |
|
uvm_field_sarray_enum(T, ARG, FLAG) |
MACRO `uvm_field_sarray_enum 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 |
|
uvm_field_sarray_int(ARG, FLAG) |
MACRO `uvm_field_sarray_int 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
|
|
uvm_field_sarray_object(ARG, FLAG) |
MACRO `uvm_field_sarray_object Implements the data operations for a one-dimensional static array of
`uvm_field_sarray_object(ARG,FLAG) ARG is a one-dimensional static array of |
|
uvm_field_sarray_string(ARG, FLAG) |
MACRO `uvm_field_sarray_string 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 |
|
uvm_field_string(ARG, FLAG) |
MACRO `uvm_field_string 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 |
|
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) |
MACRO `uvm_get_imp_decl `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) |
MACRO `uvm_get_peek_imp_decl `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) |
MACRO `uvm_info 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) |
MACRO `uvm_info_begin `uvm_info_begin(ID, MSG, VERBOSITY, RM = __uvm_msg) |
|
uvm_info_context(ID, MSG, VERBOSITY, RO) |
MACRO `uvm_info_context `uvm_info_context(ID, MSG, VERBOSITY, RO) Operates identically to `uvm_info but requires that the
context, or |
|
uvm_info_context_begin(ID, MSG, VERBOSITY, RO, RM =__uvm_msg) |
MACRO `uvm_info_context_begin `uvm_info_context_begin(ID, MSG, UVM_NONE, RO, RM = __uvm_msg) |
|
uvm_info_context_end |
MACRO `uvm_info_context_end `uvm_info_context_end This macro pair operates identically to |
|
uvm_info_end |
MACRO `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("MY_ID", "This is my message...", UVM_LOW)
`uvm_message_add_tag("my_color", "red")
`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) |
MACRO `uvm_master_imp_decl `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)) |
MACRO `uvm_message_add_int `uvm_message_add_int(VAR, RADIX, LABEL = "", ACTION=(UVM_LOG|UVM_RM_RECORD)) |
|
uvm_message_add_object(VAR, LABEL ="", ACTION =(UVM_LOG|UVM_RM_RECORD)) |
MACRO `uvm_message_add_object These macros allow the user to provide elements that are associated with
`uvm_message_add_object(VAR, LABEL = "", ACTION=(UVM_LOG|UVM_RM_RECORD)) Example usage is shown in [`uvm_info_end](./index-macros.html#macros). |
|
uvm_message_add_string(VAR, LABEL ="", ACTION =(UVM_LOG|UVM_RM_RECORD)) |
MACRO `uvm_message_add_string `uvm_message_add_string(VAR, LABEL = "", ACTION=(UVM_LOG|UVM_RM_RECORD)) |
|
uvm_message_add_tag(NAME, VALUE, ACTION =(UVM_LOG|UVM_RM_RECORD)) |
MACRO `uvm_message_add_tag `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) |
MACRO `uvm_nonblocking_get_imp_decl `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) |
MACRO `uvm_nonblocking_get_peek_imp_decl `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) |
MACRO `uvm_nonblocking_master_imp_decl `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) |
MACRO `uvm_nonblocking_peek_imp_decl `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) |
MACRO `uvm_nonblocking_put_imp_decl `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) |
MACRO `uvm_nonblocking_slave_imp_decl `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) |
MACRO `uvm_nonblocking_transport_imp_decl `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) |
MACRO `uvm_object_registry 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](./index-macros.html#macros) family of macros uses this macro. |
|
uvm_object_utils(T) |
MACRO `uvm_object_utils_end 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:
Parameterized classes must use the uvm_object_param_utils* versions. They differ from [`uvm_object_utils](./index-macros.html#macros) 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_object_utils_begin(T) |
||
uvm_object_utils_end |
||
uvm_pack_array(VAR) |
Macro `uvm_pack_array 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) |
Macro `uvm_pack_arrayN Pack a dynamic array of integrals. `uvm_pack_arrayN(VAR,SIZE) |
|
uvm_pack_enum(VAR) |
Macro `uvm_pack_enum Pack an enumeration value. Packing does not require its type be specified. `uvm_pack_enum(VAR) |
|
uvm_pack_enumN(VAR, SIZE) |
Macro `uvm_pack_enumN Pack an integral variable. `uvm_pack_enumN(VAR,SIZE) |
|
uvm_pack_int(VAR) |
Macro `uvm_pack_int Pack an integral variable without having to also specify the bit size. `uvm_pack_int(VAR) |
|
uvm_pack_intN(VAR, SIZE) |
Macro `uvm_pack_intN Pack an integral variable. `uvm_pack_intN(VAR,SIZE) |
|
uvm_pack_queue(VAR) |
Macro `uvm_pack_queue 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) |
Macro `uvm_pack_queueN Pack a queue of integrals. `uvm_pack_queueN(VAR,SIZE) |
|
uvm_pack_real(VAR) |
Macro `uvm_pack_real Pack a variable of type real. `uvm_pack_real(VAR) |
|
uvm_pack_sarray(VAR) |
Macro `uvm_pack_sarray Pack a static array without having to also specify the bit size of its elements. `uvm_pack_sarray(VAR) |
|
uvm_pack_sarrayN(VAR, SIZE) |
Macro `uvm_pack_sarrayN Pack a static array of integrals. `uvm_pack_sarray(VAR,SIZE) |
|
uvm_pack_string(VAR) |
Macro `uvm_pack_string 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) |
MACRO `uvm_peek_imp_decl `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) |
MACRO `uvm_put_imp_decl `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) |
MACRO `uvm_rand_send `uvm_rand_send(SEQ_OR_ITEM) This macro processes the item or sequence that has been already been
allocated (possibly with |
|
uvm_rand_send_pri(SEQ_OR_ITEM, PRIORITY) |
MACRO `uvm_rand_send_pri `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) |
MACRO `uvm_rand_send_pri_with `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) |
MACRO `uvm_rand_send_with `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 `uvm_record_field 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](./index-macros.html#macros) 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("%p",VALUE));
|
|
uvm_register_cb(T, CB) |
MACRO `uvm_register_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) |
MACRO `uvm_send `uvm_send(SEQ_OR_ITEM) This macro processes the item or sequence that has been created using
|
|
uvm_send_pri(SEQ_OR_ITEM, PRIORITY) |
MACRO `uvm_send_pri `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) |
MACRO `uvm_sequence_library_utils `uvm_sequence_library_utils(TYPE) Declares the infrastructure needed to define extensions to the
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="");
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(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
For parameterized sequencers, no field macros `uvm_sequencer_param_utils(SQR_TYPE_NAME) For parameterized sequencers, with field 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. This includes:
Use |
|
uvm_set_super_type(T, ST) |
MACRO `uvm_set_super_type `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) |
MACRO `uvm_slave_imp_decl `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) |
MACRO `uvm_transport_imp_decl `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) |
Macro `uvm_unpack_array 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) |
Macro `uvm_unpack_arrayN Unpack into a dynamic array of integrals. `uvm_unpack_arrayN(VAR,SIZE) |
|
uvm_unpack_enum(VAR, TYPE) |
Macro `uvm_unpack_enum Unpack an enumeration value, which requires its type be specified. `uvm_unpack_enum(VAR,TYPE) |
|
uvm_unpack_enumN(VAR, SIZE, TYPE) |
Macro `uvm_unpack_enumN Unpack enum of type TYPE into VAR . `uvm_unpack_enumN(VAR,SIZE,TYPE) |
|
uvm_unpack_int(VAR) |
Macro `uvm_unpack_int Unpack an integral variable without having to also specify the bit size. `uvm_unpack_int(VAR) |
|
uvm_unpack_intN(VAR, SIZE) |
Macro `uvm_unpack_intN Unpack into an integral variable. `uvm_unpack_intN(VAR,SIZE) |
|
uvm_unpack_queue(VAR) |
Macro `uvm_unpack_queue 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) |
Macro `uvm_unpack_queueN Unpack into a queue of integrals. `uvm_unpack_queue(VAR,SIZE) |
|
uvm_unpack_real(VAR) |
Macro `uvm_unpack_real Unpack a variable of type real. `uvm_unpack_real(VAR) |
|
uvm_unpack_sarray(VAR) |
Macro `uvm_unpack_sarray Unpack a static array without having to also specify the bit size of its elements. `uvm_unpack_sarray(VAR) |
|
uvm_unpack_sarrayN(VAR, SIZE) |
Macro `uvm_unpack_sarrayN Unpack a static (fixed) array of integrals. `uvm_unpack_sarrayN(VAR,SIZE) |
|
uvm_unpack_string(VAR) |
Macro `uvm_unpack_string 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) |
MACRO `uvm_warning 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) |
MACRO `uvm_warning_begin `uvm_warning_begin(ID, MSG, RM = __uvm_msg) |
|
uvm_warning_context(ID, MSG, RO) |
MACRO `uvm_warning_context `uvm_warning_context(ID, MSG, RO) Operates identically to `uvm_warning but requires that the
context, or |
|
uvm_warning_context_begin(ID, MSG, RO, RM =__uvm_msg) |
MACRO `uvm_warning_context_begin `uvm_warning_context_begin(ID, MSG, RO, RM = __uvm_msg) |
|
uvm_warning_context_end |
MACRO `uvm_warning_context_end `uvm_warning_context_end This macro pair operates identically to |
|
uvm_warning_end |
MACRO `uvm_warning_end This macro pair operates identically to `uvm_warning_end The usage shown in [`uvm_info_end](./index-macros.html#macros) works identically for this pair. |
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.