uvm_mem

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.

Summary
uvm_mem
Memory abstraction base class
Class Hierarchy
Class Declaration
class uvm_mem extends uvm_object
Initialization
newCreate a new instance and type-specific configuration
configureInstance-specific configuration
set_offsetModify the offset of the memory
Modifying the offset of a memory will make the abstract modeldiverge from the specification that was used to create it.
mamMemory allocation manager
Introspection
get_nameGet the simple name
get_full_nameGet the hierarchical name
get_parentGet the parent block
get_n_mapsReturns the number of address maps this memory is mapped in
is_in_mapReturn TRUE if this memory is in the specified address map
get_mapsReturns all of the address maps where this memory is mapped
get_rightsReturns the access rights of this memory.
get_accessReturns the access policy of the memory when written and read via an address map.
get_sizeReturns the number of unique memory locations in this memory.
get_n_bytesReturn the width, in number of bytes, of each memory location
get_n_bitsReturns the width, in number of bits, of each memory location
get_max_sizeReturns the maximum width, in number of bits, of all memories
get_virtual_registersReturn the virtual registers in this memory
get_virtual_fieldsReturn the virtual fields in the memory
get_vreg_by_nameFind the named virtual register
get_vfield_by_nameFind the named virtual field
get_vreg_by_offsetFind the virtual register implemented at the specified offset
get_offsetReturns the base offset of a memory location
get_addressReturns the base external physical address of a memory location
get_addressesIdentifies the external physical address(es) of a memory location
HDL Access
writeWrite the specified value in a memory location
readRead the current value from a memory location
burst_writeWrite the specified values in memory locations
burst_readRead values from memory locations
pokeDeposit the specified value in a memory location
peekRead the current value from a memory location
Frontdoor
set_frontdoorSet a user-defined frontdoor for this memory
get_frontdoorReturns the user-defined frontdoor for this memory
Backdoor
set_backdoorSet a user-defined backdoor for this memory
get_backdoorReturns the user-defined backdoor for this memory
clear_hdl_pathDelete HDL paths
add_hdl_pathAdd an HDL path
add_hdl_path_sliceAdd the specified HDL slice to the HDL path for the specified design abstraction.
has_hdl_pathCheck if a HDL path is specified
get_hdl_pathGet the incremental HDL path(s)
get_full_hdl_pathGet the full hierarchical HDL path(s)
get_hdl_path_kindsGet design abstractions for which HDL paths have been defined
backdoor_readUser-define backdoor read access
backdoor_writeUser-defined backdoor read access
backdoor_read_funcUser-defined backdoor read access
Callbacks
pre_writeCalled before memory write.
post_writeCalled after memory write.
pre_readCalled before memory read.
post_readCalled after memory read.
Coverage
build_coverageCheck if all of the specified coverage model must be built.
add_coverageSpecify that additional coverage models are available.
has_coverageCheck if memory has coverage model(s)
set_coverageTurns on coverage measurement.
get_coverageCheck if coverage measurement is on.
sampleFunctional coverage measurement method

new

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.

configure

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, its 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.

set_offset

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.

Modifying the offset of a memory will make the abstract model

diverge from the specification that was used to create it.

mam

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_name

Get the simple name

Return the simple object name of this memory.

get_full_name

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.

get_parent

virtual function uvm_reg_block get_parent ()

Get the parent block

get_n_maps

virtual function int get_n_maps ()

Returns the number of address maps this memory is mapped in

is_in_map

function bit is_in_map (
    uvm_reg_map  map
)

Return TRUE if this memory is in the specified address map

get_maps

virtual function void get_maps (
    ref  uvm_reg_map  maps[$]
)

Returns all of the address maps where this memory is mapped

get_rights

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.

get_access

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”.

get_size

function longint unsigned get_size()

Returns the number of unique memory locations in this memory.

get_n_bytes

function int unsigned get_n_bytes()

Return the width, in number of bytes, of each memory location

get_n_bits

function int unsigned get_n_bits()

Returns the width, in number of bits, of each memory location

get_max_size

static function int unsigned get_max_size()

Returns the maximum width, in number of bits, of all memories

get_virtual_registers

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.

get_virtual_fields

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.

get_vreg_by_name

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.

get_vfield_by_name

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.

get_vreg_by_offset

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.

get_offset

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.

get_address

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.

get_addresses

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 transferred 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.

write

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.

read

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).

burst_write

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.

burst_read

virtual task burst_read(
    output  uvm_status_e  status,   
    input  uvm_reg_addr_t  offset,   
    ref  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.

poke

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 specified offset, as-is, using a back-door access.

Uses the HDL path for the design abstraction specified by kind.

peek

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 abstraction 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.

set_frontdoor

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, memories are mapped linearly into the address space of the address maps that instantiate them.  If memories 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.

get_frontdoor

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.

set_backdoor

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

get_backdoor

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.

clear_hdl_path

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.

add_hdl_path

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

add_hdl_path_slice

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.

has_hdl_path

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.

get_hdl_path

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 abstraction is specified, the default design abstraction for the parent block is used.

get_full_hdl_path

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 abstraction is specified, the default design abstraction for each ancestor block is used to get each incremental path.

get_hdl_path_kinds

function void get_hdl_path_kinds (
    ref  string  kinds[$]
)

Get design abstractions for which HDL paths have been defined

backdoor_read

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().

backdoor_write

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.

backdoor_read_func

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.

pre_write

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.

post_write

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.

pre_read

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.

post_read

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.

build_coverage

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.

add_coverage

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.

has_coverage

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.

set_coverage

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 identifiers.  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.

get_coverage

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.

sample

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 successfully 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.

virtual class uvm_void
The uvm_void class is the base class for all UVM classes.
virtual class uvm_object extends uvm_void
The uvm_object class is the base class for all UVM data and hierarchical classes.
class uvm_mem extends uvm_object
Memory abstraction base class
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
function void configure (
    uvm_reg_block  parent,   
    string  hdl_path  =  ""
)
Instance-specific configuration
uvm_mem_mam mam
Memory allocation manager
virtual function string get_full_name()
Get the hierarchical name
virtual function uvm_reg_block get_parent ()
Get the parent 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.
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.
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
virtual function void get_virtual_fields(
    ref  uvm_vreg_field  fields[$]
)
Return the virtual fields in the memory
virtual function uvm_vreg get_vreg_by_name(
    string  name
)
Find the named virtual register
virtual function uvm_vreg_field get_vfield_by_name(
    string  name
)
Find the named virtual field
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
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
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
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
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
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
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
virtual task burst_read(
    output  uvm_status_e  status,   
    input  uvm_reg_addr_t  offset,   
    ref  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 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
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
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
function uvm_reg_frontdoor get_frontdoor(
    uvm_reg_map  map  =  null
)
Returns the user-defined frontdoor for this memory
function void set_backdoor (
    uvm_reg_backdoor  bkdr,   
    string  fname  =  "",
    int  lineno  =  0
)
Set a user-defined backdoor for this memory
function uvm_reg_backdoor get_backdoor(
    bit  inherited  =  1
)
Returns the user-defined backdoor for this memory
function void clear_hdl_path (
    string  kind  =  "RTL"
)
Delete HDL paths
function void add_hdl_path (
    uvm_hdl_path_slice  slices[],   
    string  kind  =  "RTL"
)
Add an HDL path
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.
function bit has_hdl_path (
    string  kind  =  ""
)
Check if a HDL path is specified
function void get_hdl_path (
    ref  uvm_hdl_path_concat  paths[$],   
    input  string  kind  =  ""
)
Get the incremental HDL path(s)
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)
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
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
)
User-defined backdoor read access
virtual task pre_write(
    uvm_reg_item  rw
)
Called before memory write.
virtual task post_write(
    uvm_reg_item  rw
)
Called after memory write.
virtual task pre_read(
    uvm_reg_item  rw
)
Called before memory read.
virtual task post_read(
    uvm_reg_item  rw
)
Called after memory read.
protected function uvm_reg_cvr_t build_coverage(
    uvm_reg_cvr_t  models
)
Check if all of the specified coverage model must be built.
virtual protected function void add_coverage(
    uvm_reg_cvr_t  models
)
Specify that additional coverage models are available.
virtual function bit has_coverage(
    uvm_reg_cvr_t  models
)
Check if memory has coverage model(s)
virtual function uvm_reg_cvr_t set_coverage(
    uvm_reg_cvr_t  is_on
)
Turns on coverage measurement.
virtual function bit get_coverage(
    uvm_reg_cvr_t  is_on
)
Check if coverage measurement is on.
protected virtual function void sample(
    uvm_reg_addr_t  offset,
    bit  is_read,
    uvm_reg_map  map
)
Functional coverage measurement method
Coverage models available or desired.
virtual function void add_mem (
    uvm_mem  mem,   
    uvm_reg_addr_t  offset,   
    string  rights  =  "RW",
    bit  unmapped  =  0,
    uvm_reg_frontdoor  frontdoor  =  null
)
Add a memory
function void set_backdoor(
    uvm_reg_backdoor  bkdr,   
    string  fname  =  "",
    int  lineno  =  0
)
Set a user-defined backdoor for this register
Operation completed successfully
static function void include_coverage(
    string  scope,   
    uvm_reg_cvr_t  models,   
    uvm_object  accessor  =  null
)
Specify which coverage model that must be included in various block, register or memory abstraction class instances.