Memory abstraction base class
A memory is a collection of contiguous locations. A memory may be accessible via more than one address map.
Unlike registers, memories are not mirrored because of the potentially large data space: tests that walk the entire memory space would negate any benefit from sparse memory modelling techniques. Rather than relying on a mirror, it is recommended that backdoor access be used instead.
| uvm_mem | ||||
| Memory abstraction base class | ||||
| Class Hierarchy | ||||
| ||||
| Class Declaration | ||||
| ||||
| Initialization | ||||
| new | Create a new instance and type-specific configuration | |||
| configure | Instance-specific configuration | |||
| set_offset | Modify the offset of the memory | |||
| Modifying the offset of a memory will make the abstract model | diverge from the specification that was used to create it. | |||
| mam | Memory allocation manager | |||
| Introspection | ||||
| get_name | Get the simple name | |||
| get_full_name | Get the hierarchical name | |||
| get_parent | Get the parent block | |||
| get_n_maps | Returns the number of address maps this memory is mapped in | |||
| is_in_map | Return TRUE if this memory is in the specified address map | |||
| get_maps | Returns all of the address maps where this memory is mapped | |||
| get_rights | Returns the access rights of this memory. | |||
| get_access | Returns the access policy of the memory when written and read via an address map. | |||
| get_size | Returns the number of unique memory locations in this memory. | |||
| get_n_bytes | Return the width, in number of bytes, of each memory location | |||
| get_n_bits | Returns the width, in number of bits, of each memory location | |||
| get_max_size | Returns the maximum width, in number of bits, of all memories | |||
| get_virtual_registers | Return the virtual registers in this memory | |||
| get_virtual_fields | Return the virtual fields in the memory | |||
| get_vreg_by_name | Find the named virtual register | |||
| get_vfield_by_name | Find the named virtual field | |||
| get_vreg_by_offset | Find the virtual register implemented at the specified offset | |||
| get_offset | Returns the base offset of a memory location | |||
| get_address | Returns the base external physical address of a memory location | |||
| get_addresses | Identifies the external physical address(es) of a memory location | |||
| HDL Access | ||||
| write | Write the specified value in a memory location | |||
| read | Read the current value from a memory location | |||
| burst_write | Write the specified values in memory locations | |||
| burst_read | Read values from memory locations | |||
| poke | Deposit the specified value in a memory location | |||
| peek | Read the current value from a memory location | |||
| Frontdoor | ||||
| set_frontdoor | Set a user-defined frontdoor for this memory | |||
| get_frontdoor | Returns the user-defined frontdoor for this memory | |||
| Backdoor | ||||
| set_backdoor | Set a user-defined backdoor for this memory | |||
| get_backdoor | Returns the user-defined backdoor for this memory | |||
| clear_hdl_path | Delete HDL paths | |||
| add_hdl_path | Add an HDL path | |||
| add_hdl_path_slice | Add the specified HDL slice to the HDL path for the specified design abstraction. | |||
| has_hdl_path | Check if a HDL path is specified | |||
| get_hdl_path | Get the incremental HDL path(s) | |||
| get_full_hdl_path | Get the full hierarchical HDL path(s) | |||
| get_hdl_path_kinds | Get design abstractions for which HDL paths have been defined | |||
| backdoor_read | User-define backdoor read access | |||
| backdoor_write | User-defined backdoor read access | |||
| backdoor_read_func | User-defined backdoor read access | |||
| Callbacks | ||||
| pre_write | Called before memory write. | |||
| post_write | Called after memory write. | |||
| pre_read | Called before memory read. | |||
| post_read | Called after memory read. | |||
| Coverage | ||||
| build_coverage | Check if all of the specified coverage model must be built. | |||
| add_coverage | Specify that additional coverage models are available. | |||
| has_coverage | Check if memory has coverage model(s) | |||
| set_coverage | Turns on coverage measurement. | |||
| get_coverage | Check if coverage measurement is on. | |||
| sample | Functional coverage measurement method | |||
function new ( string name, longint unsigned size, int unsigned n_bits, string access = "RW", int has_coverage = UVM_NO_COVERAGE )
Create a new instance and type-specific configuration
Creates an instance of a memory abstraction class with the specified name.
size specifies the total number of memory locations. n_bits specifies the total number of bits in each memory location. access specifies the access policy of this memory and may be one of “RW for RAMs and “RO” for ROMs.
has_coverage specifies which functional coverage models are present in the extension of the register abstraction class. Multiple functional coverage models may be specified by adding their symbolic names, as defined by the uvm_coverage_model_e type.
function void configure ( uvm_reg_block parent, string hdl_path = "" )
Instance-specific configuration
Specify the parent block of this memory.
If this memory is implemented in a single HDL variable, it’s name is specified as the hdl_path. Otherwise, if the memory is implemented as a concatenation of variables (usually one per bank), then the HDL path must be specified using the add_hdl_path() or add_hdl_path_slice() method.
Modify the offset of the memory
The offset of a memory within an address map is set using the uvm_reg_map::add_mem() method. This method is used to modify that offset dynamically.
diverge from the specification that was used to create it.
uvm_mem_mam mam
Memory allocation manager
Memory allocation manager for the memory corresponding to this abstraction class instance. Can be used to allocate regions of consecutive addresses of specific sizes, such as DMA buffers, or to locate virtual register array.
Get the simple name
Return the simple object name of this memory.
virtual function string get_full_name()
Get the hierarchical name
Return the hierarchal name of this memory. The base of the hierarchical name is the root block.
virtual function int get_n_maps ()
Returns the number of address maps this memory is mapped in
function bit is_in_map ( uvm_reg_map map )
Return TRUE if this memory is in the specified address map
virtual function void get_maps ( ref uvm_reg_map maps[$] )
Returns all of the address maps where this memory is mapped
virtual function string get_rights ( uvm_reg_map map = null )
Returns the access rights of this memory.
Returns “RW”, “RO” or “WO”. The access rights of a memory is always “RW”, unless it is a shared memory with access restriction in a particular address map.
If no address map is specified and the memory is mapped in only one address map, that address map is used. If the memory is mapped in more than one address map, the default address map of the parent block is used.
If an address map is specified and the memory is not mapped in the specified address map, an error message is issued and “RW” is returned.
virtual function string get_access( uvm_reg_map map = null )
Returns the access policy of the memory when written and read via an address map.
If the memory is mapped in more than one address map, an address map must be specified. If access restrictions are present when accessing a memory through the specified address map, the access mode returned takes the access restrictions into account. For example, a read-write memory accessed through a domain with read-only restrictions would return “RO”.
function longint unsigned get_size()
Returns the number of unique memory locations in this memory.
function int unsigned get_n_bytes()
Return the width, in number of bytes, of each memory location
function int unsigned get_n_bits()
Returns the width, in number of bits, of each memory location
static function int unsigned get_max_size()
Returns the maximum width, in number of bits, of all memories
virtual function void get_virtual_registers( ref uvm_vreg regs[$] )
Return the virtual registers in this memory
Fills the specified array with the abstraction class for all of the virtual registers implemented in this memory. The order in which the virtual registers are located in the array is not specified.
virtual function void get_virtual_fields( ref uvm_vreg_field fields[$] )
Return the virtual fields in the memory
Fills the specified dynamic array with the abstraction class for all of the virtual fields implemented in this memory. The order in which the virtual fields are located in the array is not specified.
virtual function uvm_vreg get_vreg_by_name( string name )
Find the named virtual register
Finds a virtual register with the specified name implemented in this memory and returns its abstraction class instance. If no virtual register with the specified name is found, returns null.
virtual function uvm_vreg_field get_vfield_by_name( string name )
Find the named virtual field
Finds a virtual field with the specified name implemented in this memory and returns its abstraction class instance. If no virtual field with the specified name is found, returns null.
virtual function uvm_vreg get_vreg_by_offset( uvm_reg_addr_t offset, uvm_reg_map map = null )
Find the virtual register implemented at the specified offset
Finds the virtual register implemented in this memory at the specified offset in the specified address map and returns its abstraction class instance. If no virtual register at the offset is found, returns null.
virtual function uvm_reg_addr_t get_offset ( uvm_reg_addr_t offset = 0, uvm_reg_map map = null )
Returns the base offset of a memory location
Returns the base offset of the specified location in this memory in an address map.
If no address map is specified and the memory is mapped in only one address map, that address map is used. If the memory is mapped in more than one address map, the default address map of the parent block is used.
If an address map is specified and the memory is not mapped in the specified address map, an error message is issued.
virtual function uvm_reg_addr_t get_address( uvm_reg_addr_t offset = 0, uvm_reg_map map = null )
Returns the base external physical address of a memory location
Returns the base external physical address of the specified location in this memory if accessed through the specified address map.
If no address map is specified and the memory is mapped in only one address map, that address map is used. If the memory is mapped in more than one address map, the default address map of the parent block is used.
If an address map is specified and the memory is not mapped in the specified address map, an error message is issued.
virtual function int get_addresses( uvm_reg_addr_t offset = 0, uvm_reg_map map = null, ref uvm_reg_addr_t addr[] )
Identifies the external physical address(es) of a memory location
Computes all of the external physical addresses that must be accessed to completely read or write the specified location in this memory. The addressed are specified in little endian order. Returns the number of bytes transfered on each access.
If no address map is specified and the memory is mapped in only one address map, that address map is used. If the memory is mapped in more than one address map, the default address map of the parent block is used.
If an address map is specified and the memory is not mapped in the specified address map, an error message is issued.
virtual task write( output uvm_status_e status, input uvm_reg_addr_t offset, input uvm_reg_data_t value, input uvm_path_e path = UVM_DEFAULT_PATH, input uvm_reg_map map = null, input uvm_sequence_base parent = null, input int prior = -1, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Write the specified value in a memory location
Write value in the memory location that corresponds to this abstraction class instance at the specified offset using the specified access path. If the memory is mapped in more than one address map, an address map must be specified if a physical access is used (front-door access). If a back-door access path is used, the effect of writing the register through a physical access is mimicked. For example, a read-only memory will not be written.
virtual task read( output uvm_status_e status, input uvm_reg_addr_t offset, output uvm_reg_data_t value, input uvm_path_e path = UVM_DEFAULT_PATH, input uvm_reg_map map = null, input uvm_sequence_base parent = null, input int prior = -1, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Read the current value from a memory location
Read and return value from the memory location that corresponds to this abstraction class instance at the specified offset using the specified access path. If the register is mapped in more than one address map, an address map must be specified if a physical access is used (front-door access).
virtual task burst_write( output uvm_status_e status, input uvm_reg_addr_t offset, input uvm_reg_data_t value[], input uvm_path_e path = UVM_DEFAULT_PATH, input uvm_reg_map map = null, input uvm_sequence_base parent = null, input int prior = -1, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Write the specified values in memory locations
Burst-write the specified values in the memory locations beginning at the specified offset. If the memory is mapped in more than one address map, an address map must be specified if not using the backdoor. If a back-door access path is used, the effect of writing the register through a physical access is mimicked. For example, a read-only memory will not be written.
virtual task burst_read( output uvm_status_e status, input uvm_reg_addr_t offset, output uvm_reg_data_t value[], input uvm_path_e path = UVM_DEFAULT_PATH, input uvm_reg_map map = null, input uvm_sequence_base parent = null, input int prior = -1, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Read values from memory locations
Burst-read into values the data the memory locations beginning at the specified offset. If the memory is mapped in more than one address map, an address map must be specified if not using the backdoor. If a back-door access path is used, the effect of writing the register through a physical access is mimicked. For example, a read-only memory will not be written.
virtual task poke( output uvm_status_e status, input uvm_reg_addr_t offset, input uvm_reg_data_t value, input string kind = "", input uvm_sequence_base parent = null, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Deposit the specified value in a memory location
Deposit the value in the DUT memory location corresponding to this abstraction class instance at the secified offset, as-is, using a back-door access.
Uses the HDL path for the design abstraction specified by kind.
virtual task peek( output uvm_status_e status, input uvm_reg_addr_t offset, output uvm_reg_data_t value, input string kind = "", input uvm_sequence_base parent = null, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Read the current value from a memory location
Sample the value in the DUT memory location corresponding to this absraction class instance at the specified offset using a back-door access. The memory location value is sampled, not modified.
Uses the HDL path for the design abstraction specified by kind.
function void set_frontdoor( uvm_reg_frontdoor ftdr, uvm_reg_map map = null, string fname = "", int lineno = 0 )
Set a user-defined frontdoor for this memory
By default, memorys are mapped linearly into the address space of the address maps that instantiate them. If memorys are accessed using a different mechanism, a user-defined access mechanism must be defined and associated with the corresponding memory abstraction class
If the memory is mapped in multiple address maps, an address map must be specified.
function uvm_reg_frontdoor get_frontdoor( uvm_reg_map map = null )
Returns the user-defined frontdoor for this memory
If null, no user-defined frontdoor has been defined. A user-defined frontdoor is defined by using the uvm_mem::set_frontdoor() method.
If the memory is mapped in multiple address maps, an address map must be specified.
function void set_backdoor ( uvm_reg_backdoor bkdr, string fname = "", int lineno = 0 )
Set a user-defined backdoor for this memory
By default, memories are accessed via the built-in string-based DPI routines if an HDL path has been specified using the uvm_mem::configure() or uvm_mem::add_hdl_path() method. If this default mechanism is not suitable (e.g. because the memory is not implemented in pure SystemVerilog) a user-defined access mechanism must be defined and associated with the corresponding memory abstraction class
function uvm_reg_backdoor get_backdoor( bit inherited = 1 )
Returns the user-defined backdoor for this memory
If null, no user-defined backdoor has been defined. A user-defined backdoor is defined by using the uvm_reg::set_backdoor() method.
If inherit is TRUE, returns the backdoor of the parent block if none have been specified for this memory.
function void clear_hdl_path ( string kind = "RTL" )
Delete HDL paths
Remove any previously specified HDL path to the memory instance for the specified design abstraction.
function void add_hdl_path ( uvm_hdl_path_slice slices[], string kind = "RTL" )
Add an HDL path
Add the specified HDL path to the memory instance for the specified design abstraction. This method may be called more than once for the same design abstraction if the memory is physically duplicated in the design abstraction
function void add_hdl_path_slice( string name, int offset, int size, bit first = 0, string kind = "RTL" )
Add the specified HDL slice to the HDL path for the specified design abstraction. If first is TRUE, starts the specification of a duplicate HDL implementation of the memory.
function bit has_hdl_path ( string kind = "" )
Check if a HDL path is specified
Returns TRUE if the memory instance has a HDL path defined for the specified design abstraction. If no design abstraction is specified, uses the default design abstraction specified for the parent block.
function void get_hdl_path ( ref uvm_hdl_path_concat paths[$], input string kind = "" )
Get the incremental HDL path(s)
Returns the HDL path(s) defined for the specified design abstraction in the memory instance. Returns only the component of the HDL paths that corresponds to the memory, not a full hierarchical path
If no design asbtraction is specified, the default design abstraction for the parent block is used.
function void get_full_hdl_path ( ref uvm_hdl_path_concat paths[$], input string kind = "", input string separator = "." )
Get the full hierarchical HDL path(s)
Returns the full hierarchical HDL path(s) defined for the specified design abstraction in the memory instance. There may be more than one path returned even if only one path was defined for the memory instance, if any of the parent components have more than one path defined for the same design abstraction
If no design asbtraction is specified, the default design abstraction for each ancestor block is used to get each incremental path.
function void get_hdl_path_kinds ( ref string kinds[$] )
Get design abstractions for which HDL paths have been defined
virtual protected task backdoor_read( uvm_reg_item rw )
User-define backdoor read access
Override the default string-based DPI backdoor access read for this memory type. By default calls uvm_mem::backdoor_read_func().
virtual task backdoor_write( uvm_reg_item rw )
User-defined backdoor read access
Override the default string-based DPI backdoor access write for this memory type.
virtual function uvm_status_e backdoor_read_func( uvm_reg_item rw )
User-defined backdoor read access
Override the default string-based DPI backdoor access read for this memory type.
virtual task pre_write( uvm_reg_item rw )
Called before memory write.
If the offset, value, access path, or address map are modified, the updated offset, data value, access path or address map will be used to perform the memory operation. If the status is modified to anything other than UVM_IS_OK, the operation is aborted.
The registered callback methods are invoked after the invocation of this method.
virtual task post_write( uvm_reg_item rw )
Called after memory write.
If the status is modified, the updated status will be returned by the memory operation.
The registered callback methods are invoked before the invocation of this method.
virtual task pre_read( uvm_reg_item rw )
Called before memory read.
If the offset, access path or address map are modified, the updated offset, access path or address map will be used to perform the memory operation. If the status is modified to anything other than UVM_IS_OK, the operation is aborted.
The registered callback methods are invoked after the invocation of this method.
virtual task post_read( uvm_reg_item rw )
Called after memory read.
If the readback data or status is modified, the updated readback //data or status will be returned by the memory operation.
The registered callback methods are invoked before the invocation of this method.
protected function uvm_reg_cvr_t build_coverage( uvm_reg_cvr_t models )
Check if all of the specified coverage model must be built.
Check which of the specified coverage model must be built in this instance of the memory abstraction class, as specified by calls to uvm_reg::include_coverage().
Models are specified by adding the symbolic value of individual coverage model as defined in uvm_coverage_model_e. Returns the sum of all coverage models to be built in the memory model.
virtual protected function void add_coverage( uvm_reg_cvr_t models )
Specify that additional coverage models are available.
Add the specified coverage model to the coverage models available in this class. Models are specified by adding the symbolic value of individual coverage model as defined in uvm_coverage_model_e.
This method shall be called only in the constructor of subsequently derived classes.
virtual function bit has_coverage( uvm_reg_cvr_t models )
Check if memory has coverage model(s)
Returns TRUE if the memory abstraction class contains a coverage model for all of the models specified. Models are specified by adding the symbolic value of individual coverage model as defined in uvm_coverage_model_e.
virtual function uvm_reg_cvr_t set_coverage( uvm_reg_cvr_t is_on )
Turns on coverage measurement.
Turns the collection of functional coverage measurements on or off for this memory. The functional coverage measurement is turned on for every coverage model specified using uvm_coverage_model_e symbolic identifers. Multiple functional coverage models can be specified by adding the functional coverage model identifiers. All other functional coverage models are turned off. Returns the sum of all functional coverage models whose measurements were previously on.
This method can only control the measurement of functional coverage models that are present in the memory abstraction classes, then enabled during construction. See the uvm_mem::has_coverage() method to identify the available functional coverage models.
virtual function bit get_coverage( uvm_reg_cvr_t is_on )
Check if coverage measurement is on.
Returns TRUE if measurement for all of the specified functional coverage models are currently on. Multiple functional coverage models can be specified by adding the functional coverage model identifiers.
See uvm_mem::set_coverage() for more details.
protected virtual function void sample( uvm_reg_addr_t offset, bit is_read, uvm_reg_map map )
Functional coverage measurement method
This method is invoked by the memory abstraction class whenever an address within one of its address map is succesfully read or written. The specified offset is the offset within the memory, not an absolute address.
Empty by default, this method may be extended by the abstraction class generator to perform the required sampling in any provided functional coverage model.
The uvm_object class is the base class for all UVM data and hierarchical classes.
virtual class uvm_object extends uvm_void
Memory abstraction base class
class uvm_mem extends uvm_object
Create a new instance and type-specific configuration
function new ( string name, longint unsigned size, int unsigned n_bits, string access = "RW", int has_coverage = UVM_NO_COVERAGE )
Instance-specific configuration
function void configure ( uvm_reg_block parent, string hdl_path = "" )
Memory allocation manager
uvm_mem_mam mam
Get the hierarchical name
virtual function string get_full_name()
Get the parent block
virtual function uvm_reg_block get_parent ()
Returns the number of address maps this memory is mapped in
virtual function int get_n_maps ()
Return TRUE if this memory is in the specified address map
function bit is_in_map ( uvm_reg_map map )
Returns all of the address maps where this memory is mapped
virtual function void get_maps ( ref uvm_reg_map maps[$] )
Returns the access rights of this memory.
virtual function string get_rights ( uvm_reg_map map = null )
Returns the access policy of the memory when written and read via an address map.
virtual function string get_access( uvm_reg_map map = null )
Returns the number of unique memory locations in this memory.
function longint unsigned get_size()
Return the width, in number of bytes, of each memory location
function int unsigned get_n_bytes()
Returns the width, in number of bits, of each memory location
function int unsigned get_n_bits()
Returns the maximum width, in number of bits, of all memories
static function int unsigned get_max_size()
Return the virtual registers in this memory
virtual function void get_virtual_registers( ref uvm_vreg regs[$] )
Return the virtual fields in the memory
virtual function void get_virtual_fields( ref uvm_vreg_field fields[$] )
Find the named virtual register
virtual function uvm_vreg get_vreg_by_name( string name )
Find the named virtual field
virtual function uvm_vreg_field get_vfield_by_name( string name )
Find the virtual register implemented at the specified offset
virtual function uvm_vreg get_vreg_by_offset( uvm_reg_addr_t offset, uvm_reg_map map = null )
Returns the base offset of a memory location
virtual function uvm_reg_addr_t get_offset ( uvm_reg_addr_t offset = 0, uvm_reg_map map = null )
Returns the base external physical address of a memory location
virtual function uvm_reg_addr_t get_address( uvm_reg_addr_t offset = 0, uvm_reg_map map = null )
Identifies the external physical address(es) of a memory location
virtual function int get_addresses( uvm_reg_addr_t offset = 0, uvm_reg_map map = null, ref uvm_reg_addr_t addr[] )
Write the specified value in a memory location
virtual task write( output uvm_status_e status, input uvm_reg_addr_t offset, input uvm_reg_data_t value, input uvm_path_e path = UVM_DEFAULT_PATH, input uvm_reg_map map = null, input uvm_sequence_base parent = null, input int prior = -1, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Read the current value from a memory location
virtual task read( output uvm_status_e status, input uvm_reg_addr_t offset, output uvm_reg_data_t value, input uvm_path_e path = UVM_DEFAULT_PATH, input uvm_reg_map map = null, input uvm_sequence_base parent = null, input int prior = -1, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Write the specified values in memory locations
virtual task burst_write( output uvm_status_e status, input uvm_reg_addr_t offset, input uvm_reg_data_t value[], input uvm_path_e path = UVM_DEFAULT_PATH, input uvm_reg_map map = null, input uvm_sequence_base parent = null, input int prior = -1, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Read values from memory locations
virtual task burst_read( output uvm_status_e status, input uvm_reg_addr_t offset, output uvm_reg_data_t value[], input uvm_path_e path = UVM_DEFAULT_PATH, input uvm_reg_map map = null, input uvm_sequence_base parent = null, input int prior = -1, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Deposit the specified value in a memory location
virtual task poke( output uvm_status_e status, input uvm_reg_addr_t offset, input uvm_reg_data_t value, input string kind = "", input uvm_sequence_base parent = null, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Read the current value from a memory location
virtual task peek( output uvm_status_e status, input uvm_reg_addr_t offset, output uvm_reg_data_t value, input string kind = "", input uvm_sequence_base parent = null, input uvm_object extension = null, input string fname = "", input int lineno = 0 )
Set a user-defined frontdoor for this memory
function void set_frontdoor( uvm_reg_frontdoor ftdr, uvm_reg_map map = null, string fname = "", int lineno = 0 )
Returns the user-defined frontdoor for this memory
function uvm_reg_frontdoor get_frontdoor( uvm_reg_map map = null )
Set a user-defined backdoor for this memory
function void set_backdoor ( uvm_reg_backdoor bkdr, string fname = "", int lineno = 0 )
Returns the user-defined backdoor for this memory
function uvm_reg_backdoor get_backdoor( bit inherited = 1 )
Delete HDL paths
function void clear_hdl_path ( string kind = "RTL" )
Add an HDL path
function void add_hdl_path ( uvm_hdl_path_slice slices[], string kind = "RTL" )
Add the specified HDL slice to the HDL path for the specified design abstraction.
function void add_hdl_path_slice( string name, int offset, int size, bit first = 0, string kind = "RTL" )
Check if a HDL path is specified
function bit has_hdl_path ( string kind = "" )
Get the incremental HDL path(s)
function void get_hdl_path ( ref uvm_hdl_path_concat paths[$], input string kind = "" )
Get the full hierarchical HDL path(s)
function void get_full_hdl_path ( ref uvm_hdl_path_concat paths[$], input string kind = "", input string separator = "." )
Get design abstractions for which HDL paths have been defined
function void get_hdl_path_kinds ( ref string kinds[$] )
User-define backdoor read access
virtual protected task backdoor_read( uvm_reg_item rw )
User-defined backdoor read access
virtual task backdoor_write( uvm_reg_item rw )
User-defined backdoor read access
virtual function uvm_status_e backdoor_read_func( uvm_reg_item rw )
Called before memory write.
virtual task pre_write( uvm_reg_item rw )
Called after memory write.
virtual task post_write( uvm_reg_item rw )
Called before memory read.
virtual task pre_read( uvm_reg_item rw )
Called after memory read.
virtual task post_read( uvm_reg_item rw )
Check if all of the specified coverage model must be built.
protected function uvm_reg_cvr_t build_coverage( uvm_reg_cvr_t models )
Specify that additional coverage models are available.
virtual protected function void add_coverage( uvm_reg_cvr_t models )
Check if memory has coverage model(s)
virtual function bit has_coverage( uvm_reg_cvr_t models )
Turns on coverage measurement.
virtual function uvm_reg_cvr_t set_coverage( uvm_reg_cvr_t is_on )
Check if coverage measurement is on.
virtual function bit get_coverage( uvm_reg_cvr_t is_on )
Functional coverage measurement method
protected virtual function void sample( uvm_reg_addr_t offset, bit is_read, uvm_reg_map map )
Add a memory
virtual function void add_mem ( uvm_mem mem, uvm_reg_addr_t offset, string rights = "RW", bit unmapped = 0, uvm_reg_frontdoor frontdoor = null )
Set a user-defined backdoor for this register
function void set_backdoor( uvm_reg_backdoor bkdr, string fname = "", int lineno = 0 )
Specify which coverage model that must be included in various block, register or memory abstraction class instances.
static function void include_coverage( string scope, uvm_reg_cvr_t models, uvm_object accessor = null )