Macros
Name |
Type |
Value |
Description |
|---|---|---|---|
UVM_BLOCKING_GET_IMP(imp, TYPE, arg) |
defined |
||
UVM_BLOCKING_GET_IMP_SFX(SFX, imp, TYPE, arg) |
defined |
||
UVM_BLOCKING_GET_PEEK_IMP(imp, TYPE, arg) |
defined |
||
UVM_BLOCKING_PEEK_IMP(imp, TYPE, arg) |
defined |
||
UVM_BLOCKING_PEEK_IMP_SFX(SFX, imp, TYPE, arg) |
defined |
||
UVM_BLOCKING_PUT_IMP(imp, TYPE, arg) |
defined |
||
UVM_BLOCKING_PUT_IMP_SFX(SFX, imp, TYPE, arg) |
defined |
These imps are used in uvm_*port, uvmexport and uvm_imp, using suffixes |
|
UVM_BLOCKING_TRANSPORT_IMP(imp, REQ, RSP, req_arg, rsp_arg) |
defined |
||
UVM_BLOCKING_TRANSPORT_IMP_SFX(SFX, imp, REQ, RSP, req_arg, rsp_arg) |
defined |
||
UVM_CB_TRACE_ON |
ifdef |
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 |
ifdef |
Import DPI functions used by the interface to generate the lists. |
|
UVM_CORESERVICE_TYPE |
ifdef |
||
UVM_DEFAULT_TIMEOUT |
defined |
9200s |
The default timeout for simulation, if not overridden by <uvm_root::set_timeout> or <uvm_cmdline_processor::+UVM_TIMEOUT> |
UVM_DEPRECATED_REPORTING |
ifdef |
||
UVM_DEPRECATED_STARTING_PHASE |
ifdef |
||
UVM_DISABLE_AUTO_ITEM_RECORDING |
ifdef |
||
UVM_EMPTY_MACROS |
ifdef |
||
UVM_ENABLE_FIELD_CHECKS |
ifdef |
||
UVM_EXPORT_COMMON(MASK, TYPE_NAME) |
defined |
||
UVM_FIX_REV |
ifdef |
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_FUNCTION_ERROR |
defined |
"TLM interface function not implemented" |
|
UVM_GET_IMP(imp, TYPE, arg) |
defined |
||
UVM_GET_PEEK_IMP(imp, TYPE, arg) |
defined |
||
UVM_HDL_MAX_WIDTH |
ifdef |
||
UVM_HDL_NO_DPI |
ifdef |
||
UVM_IMP_COMMON(MASK, TYPE_NAME, IMP) |
defined |
||
UVM_LINE_WIDTH |
ifdef |
||
UVM_MAJOR_REV |
defined |
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 |
defined |
Indicates that the MAJOR version of this release is '1'. define UVM_MAJOR_REV_1
|
|
UVM_MAJOR_VERSION_1_2 |
defined |
Undocumented, same thing as UVM_VERSION_1_2 |
|
UVM_MAX_STREAMBITS |
ifdef |
||
UVM_MINOR_REV |
defined |
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 |
defined |
Indicates that the MINOR version of this release is '2'. define UVM_MINOR_REV_2
|
|
UVM_MS_IMP_COMMON(MASK, TYPE_NAME) |
defined |
||
UVM_NAME |
defined |
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) |
defined |
||
UVM_NONBLOCKING_GET_IMP_SFX(SFX, imp, TYPE, arg) |
defined |
||
UVM_NONBLOCKING_GET_PEEK_IMP(imp, TYPE, arg) |
defined |
||
UVM_NONBLOCKING_PEEK_IMP(imp, TYPE, arg) |
defined |
||
UVM_NONBLOCKING_PEEK_IMP_SFX(SFX, imp, TYPE, arg) |
defined |
||
UVM_NONBLOCKING_PUT_IMP(imp, TYPE, arg) |
defined |
||
UVM_NONBLOCKING_PUT_IMP_SFX(SFX, imp, TYPE, arg) |
defined |
||
UVM_NONBLOCKING_TRANSPORT_IMP(imp, REQ, RSP, req_arg, rsp_arg) |
defined |
||
UVM_NONBLOCKING_TRANSPORT_IMP_SFX(SFX, imp, REQ, RSP, req_arg, rsp_arg) |
defined |
||
UVM_NO_DEPRECATED |
ifdef |
Deprecation Control Macros |
|
UVM_NO_DPI |
ifdef |
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 |
ifdef |
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_NUM_LINES |
ifdef |
||
UVM_OBJECT_DO_NOT_NEED_CONSTRUCTOR |
ifdef |
||
UVM_PACKER_MAX_BYTES |
ifdef |
||
UVM_PEEK_IMP(imp, TYPE, arg) |
defined |
||
UVM_PH_TRACE(ID, MSG, PH, VERB) |
defined |
||
UVM_PORT_COMMON(MASK, TYPE_NAME) |
defined |
||
UVM_POST_VERSION_1_1 |
defined |
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) |
defined |
||
UVM_REGEX_NO_DPI |
ifdef |
||
UVM_REG_ADDR_WIDTH |
ifdef |
||
UVM_REG_BYTENABLE_WIDTH |
ifdef |
||
UVM_REG_CVR_WIDTH |
ifdef |
||
UVM_REG_DATA_WIDTH |
ifdef |
||
UVM_REG_NO_INDIVIDUAL_FIELD_ACCESS |
ifdef |
||
UVM_REPORT_DISABLE_FILE |
ifdef |
||
UVM_REPORT_DISABLE_FILE_LINE |
ifdef |
ifndef UVM_USE_FILE_LINE define UVM_REPORT_DISABLE_FILE_LINE endif |
|
UVM_REPORT_DISABLE_LINE |
ifdef |
||
UVM_RESOURCE_GET_FCNS(base_type) |
defined |
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 <resource_specialization> 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 <resource_specialization> 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 |
defined |
"Sequencer interface function not implemented" |
|
UVM_SEQ_ITEM_GET_MASK |
defined |
(1<<7) |
|
UVM_SEQ_ITEM_GET_NEXT_ITEM_MASK |
defined |
(1<<0) |
|
UVM_SEQ_ITEM_HAS_DO_AVAILABLE_MASK |
defined |
(1<<3) |
|
UVM_SEQ_ITEM_ITEM_DONE_MASK |
defined |
(1<<2) |
|
UVM_SEQ_ITEM_PEEK_MASK |
defined |
(1<<8) |
|
UVM_SEQ_ITEM_PULL_IMP(imp, REQ, RSP, req_arg, rsp_arg) |
defined |
imp definitions |
|
UVM_SEQ_ITEM_PULL_MASK |
defined |
||
UVM_SEQ_ITEM_PUSH_MASK |
defined |
(UVM_SEQ_ITEM_PUT_MASK) |
|
UVM_SEQ_ITEM_PUT_MASK |
defined |
(1<<6) |
|
UVM_SEQ_ITEM_PUT_RESPONSE_MASK |
defined |
(1<<5) |
|
UVM_SEQ_ITEM_TASK_ERROR |
defined |
"Sequencer interface task not implemented" |
|
UVM_SEQ_ITEM_TRY_NEXT_ITEM_MASK |
defined |
(1<<1) |
|
UVM_SEQ_ITEM_UNI_PULL_MASK |
defined |
||
UVM_SEQ_ITEM_WAIT_FOR_SEQUENCES_MASK |
defined |
(1<<4) |
|
UVM_SEQ_PORT(MASK, TYPE_NAME) |
defined |
||
UVM_STRING_QUEUE_STREAMING_PACK(q) |
defined |
uvm_pkg::m_uvm_string_queue_join(q) |
|
UVM_TASK_ERROR |
defined |
"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 |
defined |
(1<<8) |
|
UVM_TLM_BLOCKING_GET_MASK |
defined |
(1<<1) |
|
UVM_TLM_BLOCKING_GET_PEEK_MASK |
defined |
(UVM_TLM_BLOCKING_GET_MASK | UVM_TLM_BLOCKING_PEEK_MASK) |
|
UVM_TLM_BLOCKING_MASTER_MASK |
defined |
(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 |
defined |
(1<<2) |
|
UVM_TLM_BLOCKING_PUT_MASK |
defined |
(1<<0) |
primitive interfaces |
UVM_TLM_BLOCKING_SLAVE_MASK |
defined |
(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 |
defined |
(1<<3) |
|
UVM_TLM_B_MASK |
defined |
(1<<2) |
Define blocking mask onehot assignment = 'b100 |
UVM_TLM_B_TRANSPORT_IMP(imp, T, t, delay) |
defined |
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 |
defined |
"fifo channel function not implemented" |
|
UVM_TLM_FIFO_TASK_ERROR |
defined |
"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 |
defined |
"TLM-2 interface function not implemented" |
Defines Not-Yet-Implemented TLM functions |
UVM_TLM_GET_MASK |
defined |
(UVM_TLM_BLOCKING_GET_MASK | UVM_TLM_NONBLOCKING_GET_MASK) |
|
UVM_TLM_GET_PEEK_MASK |
defined |
(UVM_TLM_GET_MASK | UVM_TLM_PEEK_MASK) |
|
UVM_TLM_GET_TYPE_NAME(NAME) |
defined |
||
UVM_TLM_MASTER_BIT_MASK |
defined |
(1<<9) |
|
UVM_TLM_MASTER_MASK |
defined |
(UVM_TLM_BLOCKING_MASTER_MASK | UVM_TLM_NONBLOCKING_MASTER_MASK) |
|
UVM_TLM_NB_BW_MASK |
defined |
(1<<1) |
Define Non blocking backward mask onehot assignment = 'b010 |
UVM_TLM_NB_FW_MASK |
defined |
(1<<0) |
Define Non blocking Forward mask onehot assignment = 'b001 |
UVM_TLM_NB_TRANSPORT_BW_IMP(imp, T, P, t, p, delay) |
defined |
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("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) |
defined |
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 |
defined |
(1<<5) |
|
UVM_TLM_NONBLOCKING_GET_PEEK_MASK |
defined |
(UVM_TLM_NONBLOCKING_GET_MASK | UVM_TLM_NONBLOCKING_PEEK_MASK) |
|
UVM_TLM_NONBLOCKING_MASTER_MASK |
defined |
(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 |
defined |
(1<<6) |
|
UVM_TLM_NONBLOCKING_PUT_MASK |
defined |
(1<<4) |
|
UVM_TLM_NONBLOCKING_SLAVE_MASK |
defined |
(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 |
defined |
(1<<7) |
|
UVM_TLM_PEEK_MASK |
defined |
(UVM_TLM_BLOCKING_PEEK_MASK | UVM_TLM_NONBLOCKING_PEEK_MASK) |
|
UVM_TLM_PUT_MASK |
defined |
(UVM_TLM_BLOCKING_PUT_MASK | UVM_TLM_NONBLOCKING_PUT_MASK) |
combination interfaces |
UVM_TLM_SLAVE_BIT_MASK |
defined |
(1<<10) |
|
UVM_TLM_SLAVE_MASK |
defined |
(UVM_TLM_BLOCKING_SLAVE_MASK | UVM_TLM_NONBLOCKING_SLAVE_MASK) |
|
UVM_TLM_TASK_ERROR |
defined |
"TLM-2 interface task not implemented" |
Defines Not-Yet-Implemented TLM tasks |
UVM_TLM_TRANSPORT_MASK |
defined |
(UVM_TLM_BLOCKING_TRANSPORT_MASK | UVM_TLM_NONBLOCKING_TRANSPORT_MASK) |
|
UVM_TRANSPORT_IMP(imp, REQ, RSP, req_arg, rsp_arg) |
defined |
||
UVM_USE_PROCESS_CONTAINER |
ifdef |
||
UVM_USE_PROCESS_STATE |
ifdef |
||
UVM_USE_RESOURCE_CONVERTER |
ifdef |
||
UVM_USE_STRING_QUEUE_STREAMING_PACK |
ifdef |
||
UVM_USE_SUSPEND_RESUME |
ifdef |
||
UVM_VERSION_1_2 |
defined |
Indicates that the version of this release is '1.2'. define UVM_VERSION_1_2
|
|
UVM_VERSION_STRING |
defined |
"UVM_NAME-UVM_MAJOR_REV.UVM_MINOR_REV" |
|
uvm_add_to_seq_lib(TYPE, LIBTYPE) |
defined |
||
uvm_analysis_imp_decl(SFX) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
uvm_blocking_transport_imp_decl(SFX)
Define the class uvm_blocking_transport_impSFX for providing the blocking transport implementation. |
|
uvm_builtin_bottomup_phase(PHASE) |
defined |
||
uvm_builtin_task_phase(PHASE) |
defined |
PREFIXPHASE_phase PREFIXPHASE_ph = PREFIXPHASE_phase::get(); |
|
uvm_builtin_topdown_phase(PHASE) |
defined |
||
uvm_cb_trace(OBJ, CB, OPER) |
defined |
/* null */ |
|
uvm_cb_trace_noobj(CB, OPER) |
defined |
/* null */ |
|
uvm_component_param_utils(T) |
defined |
||
uvm_component_param_utils_begin(T) |
defined |
||
uvm_component_registry(T, S) |
defined |
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) |
defined |
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_field_* macros can be placed. The block must be terminated by uvm_component_utils_end. |
|
uvm_component_utils_begin(T) |
defined |
||
uvm_component_utils_end |
defined |
||
uvm_create(SEQ_OR_ITEM) |
defined |
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) |
defined |
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) |
defined |
||
uvm_declare_p_sequencer(SEQUENCER) |
defined |
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 |
defined |
** ** 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) |
defined |
#(TIME); |
|
uvm_do(SEQ_OR_ITEM) |
defined |
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) |
defined |
||
uvm_do_callbacks_exit_on(T, CB, METHOD, VAL) |
defined |
||
uvm_do_obj_callbacks(T, CB, OBJ, METHOD) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
||
uvm_do_seq_with(UVM_SEQ, SEQR_CONS_IF, CONSTRAINTS) |
defined |
||
uvm_do_with(SEQ_OR_ITEM, CONSTRAINTS) |
defined |
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 |
defined |
||
uvm_error(ID, MSG) |
defined |
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) |
defined |
uvm_error_begin(ID, MSG, RM = __uvm_msg)
|
|
uvm_error_context(ID, MSG, RO) |
defined |
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) |
defined |
uvm_error_context_begin(ID, MSG, RO, RM = __uvm_msg)
|
|
uvm_error_context_end |
defined |
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 |
defined |
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) |
defined |
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) |
defined |
uvm_fatal_begin(ID, MSG, RM = __uvm_msg)
|
|
uvm_fatal_context(ID, MSG, RO) |
defined |
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) |
defined |
uvm_fatal_context_begin(ID, MSG, RO, RM = __uvm_msg)
|
|
uvm_fatal_context_end |
defined |
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 |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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 |
defined |
||
uvm_file |
defined |
__FILE__ |
|
uvm_get_imp_decl(SFX) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
uvm_info_begin(ID, MSG, VERBOSITY, RM = __uvm_msg)
|
|
uvm_info_context(ID, MSG, VERBOSITY, RO) |
defined |
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) |
defined |
uvm_info_context_begin(ID, MSG, UVM_NONE, RO, RM = __uvm_msg)
|
|
uvm_info_context_end |
defined |
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 |
defined |
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 |
defined |
__LINE__ |
|
uvm_master_imp_decl(SFX) |
defined |
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)) |
defined |
uvm_message_add_int(VAR, RADIX, LABEL = "", ACTION=(UVM_LOGUVM_RM_RECORD))
|
|
uvm_message_add_object(VAR, LABEL =””, ACTION =(UVM_LOG|UVM_RM_RECORD)) |
defined |
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 = "", ACTION=(UVM_LOGUVM_RM_RECORD))
Example usage is shown in uvm_info_end. |
|
uvm_message_add_string(VAR, LABEL =””, ACTION =(UVM_LOG|UVM_RM_RECORD)) |
defined |
uvm_message_add_string(VAR, LABEL = "", ACTION=(UVM_LOGUVM_RM_RECORD))
|
|
uvm_message_add_tag(NAME, VALUE, ACTION =(UVM_LOG|UVM_RM_RECORD)) |
defined |
uvm_message_add_tag(NAME, VALUE, ACTION=(UVM_LOGUVM_RM_RECORD))
|
|
uvm_message_begin(SEVERITY, ID, MSG, VERBOSITY, FILE, LINE, RM) |
defined |
MACRO- uvm_message_begin Undocumented. Library internal use. |
|
uvm_message_context_begin(SEVERITY, ID, MSG, VERBOSITY, FILE, LINE, RO, RM) |
defined |
MACRO- uvm_message_context_begin Undocumented. Library internal use. |
|
uvm_message_context_end |
defined |
MACRO- uvm_message_context_end Undocumented. Library internal use. |
|
uvm_message_end |
defined |
MACRO- uvm_message_end Undocumented. Library internal use. |
|
uvm_new_func |
defined |
uvm_new_func |
|
uvm_non_blocking_transport_imp_decl(SFX) |
defined |
||
uvm_nonblocking_get_imp_decl(SFX) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
||
uvm_object_param_utils_begin(T) |
defined |
||
uvm_object_registry(T, S) |
defined |
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) |
defined |
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:
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) |
defined |
||
uvm_object_utils_end |
defined |
||
uvm_pack_array(VAR) |
defined |
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) |
defined |
Pack a dynamic array of integrals. uvm_pack_arrayN(VAR,SIZE)
|
|
uvm_pack_enum(VAR) |
defined |
Pack an enumeration value. Packing does not require its type be specified. uvm_pack_enum(VAR)
|
|
uvm_pack_enumN(VAR, SIZE) |
defined |
Pack an integral variable. uvm_pack_enumN(VAR,SIZE)
|
|
uvm_pack_int(VAR) |
defined |
Pack an integral variable without having to also specify the bit size. uvm_pack_int(VAR)
|
|
uvm_pack_intN(VAR, SIZE) |
defined |
Pack an integral variable. uvm_pack_intN(VAR,SIZE)
|
|
uvm_pack_queue(VAR) |
defined |
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) |
defined |
Pack a queue of integrals. uvm_pack_queueN(VAR,SIZE)
|
|
uvm_pack_real(VAR) |
defined |
Pack a variable of type real. uvm_pack_real(VAR)
|
|
uvm_pack_sarray(VAR) |
defined |
Pack a static array without having to also specify the bit size of its elements. uvm_pack_sarray(VAR)
|
|
uvm_pack_sarrayN(VAR, SIZE) |
defined |
Pack a static array of integrals. uvm_pack_sarray(VAR,SIZE)
|
|
uvm_pack_string(VAR) |
defined |
Pack a string variable. uvm_pack_string(VAR)
|
|
uvm_package(PKG) |
defined |
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) |
defined |
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) |
defined |
||
uvm_print_aa_int_object(F, FLAG) |
defined |
||
uvm_print_aa_int_object3(F, P, FLAG) |
defined |
||
uvm_print_aa_string_int(F) |
defined |
Associative array printing methods |
|
uvm_print_aa_string_int3(F, R, P) |
defined |
||
uvm_print_aa_string_object(F, FLAG) |
defined |
||
uvm_print_aa_string_object3(F, P, FLAG) |
defined |
||
uvm_print_aa_string_string(F) |
defined |
||
uvm_print_aa_string_string2(F, P) |
defined |
||
uvm_print_array_int(F, R) |
defined |
uvm_print_array* |
|
uvm_print_array_int3(F, R, P) |
defined |
||
uvm_print_array_object(F, FLAG) |
defined |
||
uvm_print_array_object3(F, P, FLAG) |
defined |
||
uvm_print_array_string(F) |
defined |
||
uvm_print_array_string2(F, P) |
defined |
||
uvm_print_enum(T, F, NM, P) |
defined |
uvm_print_enum |
|
uvm_print_int(F, R) |
defined |
uvm_print_int* |
|
uvm_print_int3(F, R, P) |
defined |
||
uvm_print_int4(F, R, NM, P) |
defined |
||
uvm_print_object(F) |
defined |
uvm_print_object* |
|
uvm_print_object2(F, P) |
defined |
||
uvm_print_object_qda4(F, P, T, FLAG) |
defined |
||
uvm_print_object_queue(F, FLAG) |
defined |
||
uvm_print_object_queue3(F, P, FLAG) |
defined |
||
uvm_print_qda_enum(F, P, T, ET) |
defined |
||
uvm_print_qda_int4(F, R, P, T) |
defined |
||
uvm_print_queue_int(F, R) |
defined |
||
uvm_print_queue_int3(F, R, P) |
defined |
||
uvm_print_sarray_int3(F, R, P) |
defined |
uvm_print_sarray* |
|
uvm_print_sarray_object(F, FLAG) |
defined |
||
uvm_print_sarray_object3(F, P, FLAG) |
defined |
||
uvm_print_sarray_string2(F, P) |
defined |
||
uvm_print_string(F) |
defined |
uvm_print_string* |
|
uvm_print_string2(F, P) |
defined |
||
uvm_print_string_qda3(F, P, T) |
defined |
||
uvm_print_string_queue(F) |
defined |
||
uvm_print_string_queue2(F, P) |
defined |
||
uvm_put_imp_decl(SFX) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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_attribute(TR_HANDLE, NAME, VALUE) |
ifdef |
||
uvm_record_field(NAME, VALUE) |
defined |
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("%p",VALUE));
|
|
uvm_record_int(NAME, VALUE, SIZE, RADIX =UVM_NORADIX) |
ifdef |
||
uvm_record_real(NAME, VALUE) |
ifdef |
||
uvm_record_string(NAME, VALUE) |
ifdef |
||
uvm_record_time(NAME, VALUE) |
ifdef |
||
uvm_register_cb(T, CB) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
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="");
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) |
defined |
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) |
defined |
MACRO- uvm_sequence_utils_begin |
|
uvm_sequence_utils_end |
defined |
MACRO- uvm_sequence_utils_end |
|
uvm_sequencer_param_utils(TYPE_NAME) |
defined |
MACRO- uvm_sequencer_param_utils |
|
uvm_sequencer_param_utils_begin(TYPE_NAME) |
defined |
MACRO- uvm_sequencer_param_utils_begin |
|
uvm_sequencer_utils(TYPE_NAME) |
defined |
MACRO- uvm_sequencer_utils |
|
uvm_sequencer_utils_begin(TYPE_NAME) |
defined |
MACRO- uvm_sequencer_utils_begin |
|
uvm_sequencer_utils_end |
defined |
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:
Use uvm_sequencer_utils[begin] for non-parameterized classes and uvm_sequencerparam_utils[_begin] for parameterized classes. |
|
uvm_set_super_type(T, ST) |
defined |
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) |
defined |
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) |
defined |
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) |
defined |
$typename(X) |
|
uvm_unpack_array(VAR) |
defined |
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) |
defined |
Unpack into a dynamic array of integrals. uvm_unpack_arrayN(VAR,SIZE)
|
|
uvm_unpack_enum(VAR, TYPE) |
defined |
Unpack an enumeration value, which requires its type be specified. uvm_unpack_enum(VAR,TYPE)
|
|
uvm_unpack_enumN(VAR, SIZE, TYPE) |
defined |
Unpack enum of type TYPE into VAR . uvm_unpack_enumN(VAR,SIZE,TYPE) |
|
uvm_unpack_int(VAR) |
defined |
Unpack an integral variable without having to also specify the bit size. uvm_unpack_int(VAR)
|
|
uvm_unpack_intN(VAR, SIZE) |
defined |
Unpack into an integral variable. uvm_unpack_intN(VAR,SIZE)
|
|
uvm_unpack_queue(VAR) |
defined |
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) |
defined |
Unpack into a queue of integrals. uvm_unpack_queue(VAR,SIZE)
|
|
uvm_unpack_real(VAR) |
defined |
Unpack a variable of type real. uvm_unpack_real(VAR)
|
|
uvm_unpack_sarray(VAR) |
defined |
Unpack a static array without having to also specify the bit size of its elements. uvm_unpack_sarray(VAR)
|
|
uvm_unpack_sarrayN(VAR, SIZE) |
defined |
Unpack a static (fixed) array of integrals. uvm_unpack_sarrayN(VAR,SIZE)
|
|
uvm_unpack_string(VAR) |
defined |
Unpack a string variable. uvm_unpack_string(VAR)
|
|
uvm_update_sequence_lib |
defined |
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) |
defined |
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) |
defined |
||
uvm_user_task_phase(PHASE, COMP, PREFIX) |
defined |
||
uvm_user_topdown_phase(PHASE, COMP, PREFIX) |
defined |
||
uvm_warning(ID, MSG) |
defined |
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) |
defined |
uvm_warning_begin(ID, MSG, RM = __uvm_msg)
|
|
uvm_warning_context(ID, MSG, RO) |
defined |
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) |
defined |
uvm_warning_context_begin(ID, MSG, RO, RM = __uvm_msg)
|
|
uvm_warning_context_end |
defined |
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 |
defined |
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. |
TLM imp implementations