| // |
| //------------------------------------------------------------------------------ |
| // 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. |
| //------------------------------------------------------------------------------ |
| |
| //This bit marks where filtering should occur to remove uvm stuff from a |
| //scope |
| bit uvm_start_uvm_declarations = 1; |
| |
| //------------------------------------------------------------------------------ |
| // |
| // Section: Types and Enumerations |
| // |
| //------------------------------------------------------------------------------ |
| |
| //------------------------ |
| // Group: Field automation |
| //------------------------ |
| |
| // Macro: `UVM_MAX_STREAMBITS |
| // |
| // Defines the maximum bit vector size for integral types. |
| |
| `ifndef UVM_MAX_STREAMBITS |
| `define UVM_MAX_STREAMBITS 4096 |
| `endif |
| |
| |
| // Macro: `UVM_PACKER_MAX_BYTES |
| // |
| // Defines the maximum bytes to allocate for packing an object using |
| // the <uvm_packer>. Default is <`UVM_MAX_STREAMBITS>, in ~bytes~. |
| |
| `ifndef UVM_PACKER_MAX_BYTES |
| `define UVM_PACKER_MAX_BYTES UVM_STREAMBITS |
| `endif |
| |
| parameter UVM_STREAMBITS = `UVM_MAX_STREAMBITS; |
| |
| |
| // Macro: `UVM_DEFAULT_TIMEOUT |
| // |
| // The default timeout for simulation, if not overridden by |
| // <uvm_root::set_timeout> or <+UVM_TIMEOUT> |
| // |
| |
| `define UVM_DEFAULT_TIMEOUT 9200s |
| |
| // Type: uvm_bitstream_t |
| // |
| // The bitstream type is used as a argument type for passing integral values |
| // in such methods as set_int_local, get_int_local, get_config_int, report, |
| // pack and unpack. |
| |
| typedef logic signed [UVM_STREAMBITS-1:0] uvm_bitstream_t; |
| |
| |
| |
| // Enum: uvm_radix_enum |
| // |
| // Specifies the radix to print or record in. |
| // |
| // UVM_BIN - Selects binary (%b) format |
| // UVM_DEC - Selects decimal (%d) format |
| // UVM_UNSIGNED - Selects unsigned decimal (%u) format |
| // UVM_OCT - Selects octal (%o) format |
| // UVM_HEX - Selects hexidecimal (%h) format |
| // UVM_STRING - Selects string (%s) format |
| // UVM_TIME - Selects time (%t) format |
| // UVM_ENUM - Selects enumeration value (name) format |
| |
| typedef enum { |
| UVM_BIN = 'h1000000, |
| UVM_DEC = 'h2000000, |
| UVM_UNSIGNED = 'h3000000, |
| UVM_UNFORMAT2 = 'h4000000, |
| UVM_UNFORMAT4 = 'h5000000, |
| UVM_OCT = 'h6000000, |
| UVM_HEX = 'h7000000, |
| UVM_STRING = 'h8000000, |
| UVM_TIME = 'h9000000, |
| UVM_ENUM = 'ha000000, |
| UVM_REAL = 'hb000000, |
| UVM_REAL_DEC = 'hc000000, |
| UVM_REAL_EXP = 'hd000000, |
| UVM_NORADIX = 0 |
| } uvm_radix_enum; |
| |
| parameter UVM_RADIX = 'hf000000; //4 bits setting the radix |
| |
| |
| // Function- uvm_radix_to_string |
| |
| function string uvm_radix_to_string(uvm_radix_enum radix); |
| case(radix) |
| UVM_BIN: return "b"; |
| UVM_OCT: return "o"; |
| UVM_DEC: return "d"; |
| UVM_HEX: return "h"; |
| UVM_UNSIGNED: return "u"; |
| UVM_UNFORMAT2: return "u"; |
| UVM_UNFORMAT4: return "z"; |
| UVM_STRING: return "s"; |
| UVM_TIME: return "t"; |
| UVM_ENUM: return "s"; |
| UVM_REAL: return "g"; |
| UVM_REAL_DEC: return "f"; |
| UVM_REAL_EXP: return "e"; |
| default: return "x"; //hex |
| endcase |
| endfunction |
| |
| |
| // Enum: uvm_recursion_policy_enum |
| // |
| // Specifies the policy for copying objects. |
| // |
| // UVM_DEEP - Objects are deep copied (object must implement copy method) |
| // UVM_SHALLOW - Objects are shallow copied using default SV copy. |
| // UVM_REFERENCE - Only object handles are copied. |
| |
| typedef enum { |
| UVM_DEFAULT_POLICY = 0, |
| UVM_DEEP = 'h400, |
| UVM_SHALLOW = 'h800, |
| UVM_REFERENCE = 'h1000 |
| } uvm_recursion_policy_enum; |
| |
| |
| // Enum: uvm_active_passive_enum |
| // |
| // Convenience value to define whether a component, usually an agent, |
| // is in "active" mode or "passive" mode. |
| |
| typedef enum bit { UVM_PASSIVE=0, UVM_ACTIVE=1 } uvm_active_passive_enum; |
| |
| |
| // Parameter: `uvm_field_* macro flags |
| // |
| // Defines what operations a given field should be involved in. |
| // Bitwise OR all that apply. |
| // |
| // UVM_DEFAULT - All field operations turned on |
| // UVM_COPY - Field will participate in <uvm_object::copy> |
| // UVM_COMPARE - Field will participate in <uvm_object::compare> |
| // UVM_PRINT - Field will participate in <uvm_object::print> |
| // UVM_RECORD - Field will participate in <uvm_object::record> |
| // UVM_PACK - Field will participate in <uvm_object::pack> |
| // |
| // UVM_NOCOPY - Field will not participate in <uvm_object::copy> |
| // UVM_NOCOMPARE - Field will not participate in <uvm_object::compare> |
| // UVM_NOPRINT - Field will not participate in <uvm_object::print> |
| // UVM_NORECORD - Field will not participate in <uvm_object::record> |
| // UVM_NOPACK - Field will not participate in <uvm_object::pack> |
| // |
| // UVM_DEEP - Object field will be deep copied |
| // UVM_SHALLOW - Object field will be shallow copied |
| // UVM_REFERENCE - Object field will copied by reference |
| // |
| // UVM_READONLY - Object field will NOT be automatically configured. |
| |
| |
| parameter UVM_MACRO_NUMFLAGS = 17; |
| //A=ABSTRACT Y=PHYSICAL |
| //F=REFERENCE, S=SHALLOW, D=DEEP |
| //K=PACK, R=RECORD, P=PRINT, M=COMPARE, C=COPY |
| //--------------------------- AYFSD K R P M C |
| parameter UVM_DEFAULT = 'b000010101010101; |
| parameter UVM_ALL_ON = 'b000000101010101; |
| parameter UVM_FLAGS_ON = 'b000000101010101; |
| parameter UVM_FLAGS_OFF = 0; |
| |
| //Values are or'ed into a 32 bit value |
| //and externally |
| parameter UVM_COPY = (1<<0); |
| parameter UVM_NOCOPY = (1<<1); |
| parameter UVM_COMPARE = (1<<2); |
| parameter UVM_NOCOMPARE = (1<<3); |
| parameter UVM_PRINT = (1<<4); |
| parameter UVM_NOPRINT = (1<<5); |
| parameter UVM_RECORD = (1<<6); |
| parameter UVM_NORECORD = (1<<7); |
| parameter UVM_PACK = (1<<8); |
| parameter UVM_NOPACK = (1<<9); |
| //parameter UVM_DEEP = (1<<10); |
| //parameter UVM_SHALLOW = (1<<11); |
| //parameter UVM_REFERENCE = (1<<12); |
| parameter UVM_PHYSICAL = (1<<13); |
| parameter UVM_ABSTRACT = (1<<14); |
| parameter UVM_READONLY = (1<<15); |
| parameter UVM_NODEFPRINT = (1<<16); |
| |
| //Extra values that are used for extra methods |
| parameter UVM_MACRO_EXTRAS = (1<<UVM_MACRO_NUMFLAGS); |
| parameter UVM_FLAGS = UVM_MACRO_EXTRAS+1; |
| parameter UVM_UNPACK = UVM_MACRO_EXTRAS+2; |
| parameter UVM_CHECK_FIELDS = UVM_MACRO_EXTRAS+3; |
| parameter UVM_END_DATA_EXTRA = UVM_MACRO_EXTRAS+4; |
| |
| |
| //Get and set methods (in uvm_object). Used by the set/get* functions |
| //to tell the object what operation to perform on the fields. |
| parameter UVM_START_FUNCS = UVM_END_DATA_EXTRA+1; |
| parameter UVM_SET = UVM_START_FUNCS+1; |
| parameter UVM_SETINT = UVM_SET; |
| parameter UVM_SETOBJ = UVM_START_FUNCS+2; |
| parameter UVM_SETSTR = UVM_START_FUNCS+3; |
| parameter UVM_END_FUNCS = UVM_SETSTR; |
| |
| //Global string variables |
| string uvm_aa_string_key; |
| |
| |
| |
| //----------------- |
| // Group: Reporting |
| //----------------- |
| |
| // Enum: uvm_severity |
| // |
| // Defines all possible values for report severity. |
| // |
| // UVM_INFO - Informative messsage. |
| // UVM_WARNING - Indicates a potential problem. |
| // UVM_ERROR - Indicates a real problem. Simulation continues subject |
| // to the configured message action. |
| // UVM_FATAL - Indicates a problem from which simulation can not |
| // recover. Simulation exits via $finish after a #0 delay. |
| |
| typedef bit [1:0] uvm_severity; |
| |
| typedef enum uvm_severity |
| { |
| UVM_INFO, |
| UVM_WARNING, |
| UVM_ERROR, |
| UVM_FATAL |
| } uvm_severity_type; |
| |
| |
| // Enum: uvm_action |
| // |
| // Defines all possible values for report actions. Each report is configured |
| // to execute one or more actions, determined by the bitwise OR of any or all |
| // of the following enumeration constants. |
| // |
| // UVM_NO_ACTION - No action is taken |
| // UVM_DISPLAY - Sends the report to the standard output |
| // UVM_LOG - Sends the report to the file(s) for this (severity,id) pair |
| // UVM_COUNT - Counts the number of reports with the COUNT attribute. |
| // When this value reaches max_quit_count, the simulation terminates |
| // UVM_EXIT - Terminates the simulation immediately. |
| // UVM_CALL_HOOK - Callback the report hook methods |
| // UVM_STOP - Causes ~$stop~ to be executed, putting the simulation into |
| // interactive mode. |
| |
| |
| typedef int uvm_action; |
| |
| typedef enum |
| { |
| UVM_NO_ACTION = 'b000000, |
| UVM_DISPLAY = 'b000001, |
| UVM_LOG = 'b000010, |
| UVM_COUNT = 'b000100, |
| UVM_EXIT = 'b001000, |
| UVM_CALL_HOOK = 'b010000, |
| UVM_STOP = 'b100000 |
| } uvm_action_type; |
| |
| |
| // Enum: uvm_verbosity |
| // |
| // Defines standard verbosity levels for reports. |
| // |
| // UVM_NONE - Report is always printed. Verbosity level setting can not |
| // disable it. |
| // UVM_LOW - Report is issued if configured verbosity is set to UVM_LOW |
| // or above. |
| // UVM_MEDIUM - Report is issued if configured verbosity is set to UVM_MEDIUM |
| // or above. |
| // UVM_HIGH - Report is issued if configured verbosity is set to UVM_HIGH |
| // or above. |
| // UVM_FULL - Report is issued if configured verbosity is set to UVM_FULL |
| // or above. |
| |
| typedef enum |
| { |
| UVM_NONE = 0, |
| UVM_LOW = 100, |
| UVM_MEDIUM = 200, |
| UVM_HIGH = 300, |
| UVM_FULL = 400, |
| UVM_DEBUG = 500 |
| } uvm_verbosity; |
| |
| |
| typedef int UVM_FILE; |
| |
| |
| //----------------- |
| // Group: Port Type |
| //----------------- |
| |
| // Enum: uvm_port_type_e |
| // |
| // Specifies the type of port |
| // |
| // UVM_PORT - The port requires the interface that is its type |
| // parameter. |
| // UVM_EXPORT - The port provides the interface that is its type |
| // parameter via a connection to some other export or |
| // implementation. |
| // UVM_IMPLEMENTATION - The port provides the interface that is its type |
| // parameter, and it is bound to the component that |
| // implements the interface. |
| |
| typedef enum |
| { |
| UVM_PORT , |
| UVM_EXPORT , |
| UVM_IMPLEMENTATION |
| } uvm_port_type_e; |
| |
| |
| //----------------- |
| // Group: Sequences |
| //----------------- |
| |
| // Enum: uvm_sequencer_arb_mode |
| // |
| // Specifies a sequencer's arbitration mode |
| // |
| // SEQ_ARB_FIFO - Requests are granted in FIFO order (default) |
| // SEQ_ARB_WEIGHTED - Requests are granted randomly by weight |
| // SEQ_ARB_RANDOM - Requests are granted randomly |
| // SEQ_ARB_STRICT_FIFO - Requests at highest priority granted in fifo order |
| // SEQ_ARB_STRICT_RANDOM - Requests at highest priority granted in randomly |
| // SEQ_ARB_USER - Arbitration is delegated to the user-defined |
| // function, user_priority_arbitration. That function |
| // will specify the next sequence to grant. |
| |
| |
| typedef enum |
| { |
| SEQ_ARB_FIFO, |
| SEQ_ARB_WEIGHTED, |
| SEQ_ARB_RANDOM, |
| SEQ_ARB_STRICT_FIFO, |
| SEQ_ARB_STRICT_RANDOM, |
| SEQ_ARB_USER |
| } uvm_sequencer_arb_mode; |
| |
| |
| typedef uvm_sequencer_arb_mode SEQ_ARB_TYPE; // backward compat |
| |
| |
| // Enum: uvm_sequence_state_enum |
| // |
| // Defines current sequence state |
| // |
| // CREATED - The sequence has been allocated. |
| // PRE_START - The sequence is started and the |
| // <uvm_sequence_base::pre_start()> task is |
| // being executed. |
| // PRE_BODY - The sequence is started and the |
| // <uvm_sequence_base::pre_body()> task is |
| // being executed. |
| // BODY - The sequence is started and the |
| // <uvm_sequence_base::body()> task is |
| // being executed. |
| // ENDED - The sequence has completed the execution of the |
| // <uvm_sequence_base::body()> task. |
| // POST_BODY - The sequence is started and the |
| // <uvm_sequence_base::post_body()> task is |
| // being executed. |
| // POST_START - The sequence is started and the |
| // <uvm_sequence_base::post_start()> task is |
| // being executed. |
| // STOPPED - The sequence has been forcibly ended by issuing a |
| // <uvm_sequence_base::kill()> on the sequence. |
| // FINISHED - The sequence is completely finished executing. |
| |
| typedef enum |
| { |
| CREATED = 1, |
| PRE_START = 2, |
| PRE_BODY = 4, |
| BODY = 8, |
| POST_BODY = 16, |
| POST_START= 32, |
| ENDED = 64, |
| STOPPED = 128, |
| FINISHED = 256 |
| } uvm_sequence_state; |
| |
| typedef uvm_sequence_state uvm_sequence_state_enum; // backward compat |
| |
| |
| // Enum: uvm_sequence_lib_mode |
| // |
| // Specifies the random selection mode of a sequence library |
| // |
| // UVM_SEQ_LIB_RAND - Random sequence selection |
| // UVM_SEQ_LIB_RANDC - Random cyclic sequence selection |
| // UVM_SEQ_LIB_ITEM - Emit only items, no sequence execution |
| // UVM_SEQ_LIB_USER - Apply a user-defined random-selection algorithm |
| |
| typedef enum |
| { |
| UVM_SEQ_LIB_RAND, |
| UVM_SEQ_LIB_RANDC, |
| UVM_SEQ_LIB_ITEM, |
| UVM_SEQ_LIB_USER |
| } uvm_sequence_lib_mode; |
| |
| |
| |
| //--------------- |
| // Group: Phasing |
| //--------------- |
| |
| // Enum: uvm_phase_type |
| // |
| // This is an attribute of a <uvm_phase> object which defines the phase |
| // type. |
| // |
| // UVM_PHASE_IMP - The phase object is used to traverse the component |
| // hierarchy and call the component phase method as |
| // well as the ~phase_started~ and ~phase_ended~ callbacks. |
| // These nodes are created by the phase macros, |
| // `uvm_builtin_task_phase, `uvm_builtin_topdown_phase, |
| // and `uvm_builtin_bottomup_phase. These nodes represent |
| // the phase type, i.e. uvm_run_phase, uvm_main_phase. |
| // |
| // UVM_PHASE_NODE - The object represents a simple node instance in |
| // the graph. These nodes will contain a reference to |
| // their corresponding IMP object. |
| // |
| // UVM_PHASE_SCHEDULE - The object represents a portion of the phasing graph, |
| // typically consisting of several NODE types, in series, |
| // parallel, or both. |
| // |
| // UVM_PHASE_TERMINAL - This internal object serves as the termination NODE |
| // for a SCHEDULE phase object. |
| // |
| // UVM_PHASE_DOMAIN - This object represents an entire graph segment that |
| // executes in parallel with the 'run' phase. |
| // Domains may define any network of NODEs and |
| // SCHEDULEs. The built-in domain, ~uvm~, consists |
| // of a single schedule of all the run-time phases, |
| // starting with ~pre_reset~ and ending with |
| // ~post_shutdown~. |
| // |
| typedef enum { UVM_PHASE_IMP, |
| UVM_PHASE_NODE, |
| UVM_PHASE_TERMINAL, |
| UVM_PHASE_SCHEDULE, |
| UVM_PHASE_DOMAIN, |
| UVM_PHASE_GLOBAL |
| } uvm_phase_type; |
| |
| |
| // Enum: uvm_phase_state |
| // --------------------- |
| // |
| // The set of possible states of a phase. This is an attribute of a schedule |
| // node in the graph, not of a phase, to maintain independent per-domain state |
| // |
| // UVM_PHASE_DORMANT - Nothing has happened with the phase in this domain. |
| // |
| // UVM_PHASE_SCHEDULED - At least one immediate predecessor has completed. |
| // Scheduled phases block until all predecessors complete or |
| // until a jump is executed. |
| // |
| // UVM_PHASE_SYNCING - All predecessors complete, checking that all synced |
| // phases (e.g. across domains) are at or beyond this point |
| // |
| // UVM_PHASE_STARTED - phase ready to execute, running phase_started() callback |
| // |
| // UVM_PHASE_EXECUTING - An executing phase is one where the phase callbacks are |
| // being executed. It's process is tracked by the phaser. |
| // |
| // UVM_PHASE_READY_TO_END - no objections remain in this phase or in any |
| // predecessors of its successors or in any sync'd phases. This |
| // state indicates an opportunity for any phase that needs extra |
| // time for a clean exit to raise an objection, thereby causing a |
| // return to UVM_PHASE_EXECUTING. If no objection is raised, state |
| // will transition to UVM_PHASE_ENDED after a delta cycle. |
| // (An example of predecessors of successors: The successor to |
| // phase 'run' is 'extract', whose predecessors are 'run' and |
| // 'post_shutdown'. Therefore, 'run' will go to this state when |
| // both its objections and those of 'post_shutdown' are all dropped. |
| // |
| // UVM_PHASE_ENDED - phase completed execution, now running phase_ended() callback |
| // |
| // UVM_PHASE_CLEANUP - all processes related to phase are being killed |
| // |
| // UVM_PHASE_DONE - A phase is done after it terminated execution. Becoming |
| // done may enable a waiting successor phase to execute. |
| // |
| // The state transitions occur as follows: |
| // |
| //| DORMANT -> SCHED -> SYNC -> START -> EXEC -> READY -> END -> CLEAN -> DONE |
| //| ^ | |
| //| | <-- jump_to v |
| //| +------------------------------------------------------------+ |
| |
| typedef enum { UVM_PHASE_DORMANT = 1, |
| UVM_PHASE_SCHEDULED = 2, |
| UVM_PHASE_SYNCING = 4, |
| UVM_PHASE_STARTED = 8, |
| UVM_PHASE_EXECUTING = 16, |
| UVM_PHASE_READY_TO_END = 32, |
| UVM_PHASE_ENDED = 64, |
| UVM_PHASE_CLEANUP = 128, |
| UVM_PHASE_DONE = 256, |
| UVM_PHASE_JUMPING = 512 |
| } uvm_phase_state; |
| |
| |
| |
| // Enum: uvm_phase_transition |
| // |
| // These are the phase state transition for callbacks which provide |
| // additional information that may be useful during callbacks |
| // |
| // UVM_COMPLETED - the phase completed normally |
| // UVM_FORCED_STOP - the phase was forced to terminate prematurely |
| // UVM_SKIPPED - the phase was in the path of a forward jump |
| // UVM_RERUN - the phase was in the path of a backwards jump |
| // |
| typedef enum { UVM_COMPLETED = 'h01, |
| UVM_FORCED_STOP = 'h02, |
| UVM_SKIPPED = 'h04, |
| UVM_RERUN = 'h08 |
| } uvm_phase_transition; |
| |
| |
| |
| // Enum: uvm_wait_op |
| // |
| // Specifies the operand when using methods like <uvm_phase::wait_for_state>. |
| // |
| // UVM_EQ - equal |
| // UVM_NE - not equal |
| // UVM_LT - less than |
| // UVM_LTE - less than or equal to |
| // UVM_GT - greater than |
| // UVM_GTE - greater than or equal to |
| // |
| typedef enum { UVM_LT, |
| UVM_LTE, |
| UVM_NE, |
| UVM_EQ, |
| UVM_GT, |
| UVM_GTE |
| } uvm_wait_op; |
| |
| |
| //------------------ |
| // Group: Objections |
| //------------------ |
| |
| // Enum: uvm_objection_event |
| // |
| // Enumerated the possible objection events one could wait on. See |
| // <uvm_objection::wait_for>. |
| // |
| // UVM_RAISED - an objection was raised |
| // UVM_DROPPED - an objection was raised |
| // UVM_ALL_DROPPED - all objections have been dropped |
| // |
| typedef enum { UVM_RAISED = 'h01, |
| UVM_DROPPED = 'h02, |
| UVM_ALL_DROPPED = 'h04 |
| } uvm_objection_event; |
| |
| |
| |
| //------------------------------ |
| // Group: Default Policy Classes |
| //------------------------------ |
| // |
| // Policy classes copying, comparing, packing, unpacking, and recording |
| // <uvm_object>-based objects. |
| |
| |
| typedef class uvm_printer; |
| typedef class uvm_table_printer; |
| typedef class uvm_tree_printer; |
| typedef class uvm_line_printer; |
| typedef class uvm_comparer; |
| typedef class uvm_packer; |
| typedef class uvm_recorder; |
| |
| // Variable: uvm_default_table_printer |
| // |
| // The table printer is a global object that can be used with |
| // <uvm_object::do_print> to get tabular style printing. |
| |
| uvm_table_printer uvm_default_table_printer = new(); |
| |
| |
| // Variable: uvm_default_tree_printer |
| // |
| // The tree printer is a global object that can be used with |
| // <uvm_object::do_print> to get multi-line tree style printing. |
| |
| uvm_tree_printer uvm_default_tree_printer = new(); |
| |
| |
| // Variable: uvm_default_line_printer |
| // |
| // The line printer is a global object that can be used with |
| // <uvm_object::do_print> to get single-line style printing. |
| |
| uvm_line_printer uvm_default_line_printer = new(); |
| |
| |
| // Variable: uvm_default_printer |
| // |
| // The default printer policy. Used when calls to <uvm_object::print> |
| // or <uvm_object::sprint> do not specify a printer policy. |
| // |
| // The default printer may be set to any legal <uvm_printer> derived type, |
| // including the global line, tree, and table printers described above. |
| |
| uvm_printer uvm_default_printer = uvm_default_table_printer; |
| |
| |
| // Variable: uvm_default_packer |
| // |
| // The default packer policy. Used when calls to <uvm_object::pack> |
| // and <uvm_object::unpack> do not specify a packer policy. |
| |
| uvm_packer uvm_default_packer = new(); |
| |
| |
| // Variable: uvm_default_comparer |
| // |
| // |
| // The default compare policy. Used when calls to <uvm_object::compare> |
| // do not specify a comparer policy. |
| |
| uvm_comparer uvm_default_comparer = new(); // uvm_comparer::init(); |
| |
| |
| // Variable: uvm_default_recorder |
| // |
| // The default recording policy. Used when calls to <uvm_object::record> |
| // do not specify a recorder policy. |
| |
| uvm_recorder uvm_default_recorder = new(); |
| |
| |
| |
| |
| |
