def test_create_object_by_name(self):
factory = UVMFactory.get()
class MyObj(UVMObject):
def __init__(self, name):
UVMObject.__init__(self, name)
uvm_object_utils(MyObj)
new_obj = factory.create_object_by_name('MyObj', "", "my_obj_name")
self.assertEqual(new_obj.get_name(), 'my_obj_name')
def test_object_utils(self):
class Obj(UVMObject):
def __init__(self, name):
UVMObject.__init__(self, name)
self.misc = 'misc field'
self.assertEqual(hasattr(Obj, 'type_name'), False)
uvm_object_utils(Obj)
self.assertEqual(Obj.type_name, 'Obj')
o = Obj("my_obj")
type_obj = o.get_type()
self.assertEqual(type_obj is not None, True)
def test_override(self):
cs = UVMCoreService.get()
fact = UVMDefaultFactory()
cs.set_factory(fact)
class XXX(UVMObject):
pass
uvm_object_utils(XXX)
class YYY(UVMObject):
pass
uvm_object_utils(YYY)
fact.set_type_override_by_name('XXX', 'YYY')
ovrd = fact.find_override_by_type(requested_type=XXX.get_type(),
full_inst_path='')
self.assertIsNotNone(ovrd, 'Override XXX->YYY should exist')
self.assertEqual(ovrd.get_type_name(), 'YYY')
# endclass
#
# //--------------------------------------------------------------------
# // mydata
# //--------------------------------------------------------------------
class mydata(UVMObject):
# `uvm_object_utils(mydata)
#
def __init__(self, name="mydata"):
UVMObject.__init__(self, name)
uvm_object_utils(UVMObject)
# //--------------------------------------------------------------------
# // mydata_wrapper
# //--------------------------------------------------------------------
# class mydata_wrapper extends uvm_object_wrapper
#
# function uvm_object create_object(string name="")
# mydata u
# u = new
# if(name !="") u.set_name(name)
# return u
# endfunction
#
# function string get_type_name()
self.min_addr = 0
self.max_addr = 0
def set_address_map(self, min_addr, max_addr):
self.min_addr = min_addr
self.max_addr = max_addr
def get_min_add(self):
return self.min_addr
def get_max_add(self):
return self.max_addr
#endclass : slave_address_map_info
uvm_object_utils(slave_address_map_info)
# `uvm_object_utils_begin(slave_address_map_info)
# `uvm_field_int(min_addr, UVM_DEFAULT)
# `uvm_field_int(max_addr, UVM_DEFAULT)
# `uvm_object_utils_end
#// Enumerated for ubus bus state
#typedef enum {RST_START, RST_STOP, NO_OP, ARBI, ADDR_PH, ADDR_PH_ERROR,
# DATA_PH} ubus_bus_state
RST_START = 0
RST_STOP = 1
NO_OP = 2
ARBI = 3
ADDR_PH = 4
self.read_byte_seq0.start_addr = self.addr_check
await uvm_do_with(self, self.read_byte_seq0,
lambda start_addr: start_addr == self.addr_check)
if self.m_data0_check != int(self.read_byte_seq0.rsp.data[0]):
uvm_error(
self.get_type_name(),
sv.sformatf(
"%s Read Modify Write Read error!\n\tADDR: %h, EXP: %h, ACT: %h",
self.get_sequence_path(), self.addr_check,
self.m_data0_check, int(self.read_byte_seq0.rsp.data[0])))
else:
self.test_pass = True
uvm_object_utils(read_modify_write_seq)
#//------------------------------------------------------------------------------
#//
#// SEQUENCE: loop_read_modify_write_seq
#//
#//------------------------------------------------------------------------------
#
#class loop_read_modify_write_seq extends ubus_base_sequence;
#
# int itr;
#
# function new(string name="loop_read_modify_write_seq");
# super.new(name);
# endfunction : new
#
def createLastOverride():
class LastOverride(UVMObject):
pass
uvm_object_utils(LastOverride)
return LastOverride
def createYYY():
class YYY(UVMObject):
pass
uvm_object_utils(YYY)
return YYY
self.irq_en = DVRegField.type_id.create("irq_en")
self.irq_en.configure(
parent=self,
size=1,
lsb_pos=1,
access="RW",
volatile=0,
reset=0,
has_reset=1,
is_rand=1,
individually_accessible=1
)
self.add_hdl_path_slice("u_reg.u_control_irq_en.q", 1, 1, 0, "BkdrRegPathRtl");
uvm_object_utils(example_reg_control)
# Class: example_reg_status
class example_reg_status(DVReg):
def __init__(self, name="example_reg_status"):
super().__init__(name, 32)
# fields
self.active = None
self.irq = None
def build(self):
# create fields
self.active = DVRegField.type_id.create("active")
self.active.configure(
parent=self,
size=1,
def __init__(self, name="slave_ID"):
super().__init__(name, 32, UVM_NO_COVERAGE)
self.REVISION_ID = None
self.CHIP_ID = None
self.PRODUCT_ID = None
def build(self):
self.REVISION_ID = UVMRegField.type_id.create("REVISION_ID")
self.CHIP_ID = UVMRegField.type_id.create("CHIP_ID")
self.PRODUCT_ID = UVMRegField.type_id.create("PRODUCT_ID")
self.REVISION_ID.configure(self, 8, 0, "RO", 0, 0x03, 1, 0, 1)
self.CHIP_ID.configure(self, 8, 8, "RO", 0, 0x5A, 1, 0, 1)
self.PRODUCT_ID.configure(self, 10, 16, "RO", 0, 0x176, 1, 0, 1)
uvm_object_utils(reg_slave_ID)
class reg_slave_INDEX(UVMReg):
def __init__(self, name="slave_INDEX"):
super().__init__(name, 8, UVM_NO_COVERAGE)
def build(self):
self.value = UVMRegField.type_id.create("value")
self.value.configure(self, 8, 0, "RW", 0, 0x0, 1, 0, 1)
uvm_object_utils(reg_slave_INDEX)
class reg_slave_DATA(UVMRegIndirectData):
#// 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.
#//----------------------------------------------------------------------
from uvm.base import UVMTransaction
from uvm.macros import uvm_object_utils
class packet(UVMTransaction):
#`ifndef NO_RAND
# rand
#`endif
# int addr;
# constraint c { addr >= 0 && addr < 'h100; }
def __init__(self, name):
UVMTransaction.__init__(self, name)
self.addr = 0
uvm_object_utils(packet)
#uvm_field_int(addr, UVM_ALL_ON)
#//
from uvm.reg.uvm_reg_fifo import UVMRegFIFO
from uvm.macros import uvm_object_utils
from uvm.reg.uvm_reg_block import UVMRegBlock
from uvm.reg.uvm_reg_model import UVM_NO_COVERAGE, UVM_LITTLE_ENDIAN
FIFO_SIZE = 8
class fifo_reg(UVMRegFIFO):
def __init__(self, name="fifo_reg"):
super().__init__(name, FIFO_SIZE, 32, UVM_NO_COVERAGE)
uvm_object_utils(fifo_reg)
class reg_block_B(UVMRegBlock):
# rand fifo_reg FIFO
def __init__(self, name="B"):
super().__init__(name, UVM_NO_COVERAGE)
def build(self):
self.FIFO = fifo_reg.type_id.create("FIFO")
self.FIFO.configure(self, None)
self.FIFO.build()
self.default_map = self.create_map("default_map_fifo", 0x0, 4,
self.m_is_read = is_read
self.sample_bits_cg(data, byte_en, is_read, self.m_current)
@CgBits
def sample_bits_cg(self, data, byte_en, is_read, m_current):
pass
def sample_fields_cg(self):
pass
def sample_values(self):
super().sample_values()
if self.get_coverage(UVM_CVR_FIELD_VALS):
self.sample_fields_cg()
uvm_object_utils(reg_R)
class mem_M(UVMMem):
CgAddr = coverage_section(
CoverPoint(
'top.cg_addr.MIN_MID_MAX',
# *Note that lambda args must match sample() args (omit self)
xf=lambda offset, is_read, _map: offset,
bins=[(0), (1,126), (127)],
bins_labels=['MIN', 'MID', 'MAX']
),
CoverPoint(
def __init__(self, name="dut_ID"):
super().__init__(name, 32, UVM_NO_COVERAGE)
self.REVISION_ID = None
self.CHIP_ID = None
self.PRODUCT_ID = None
def build(self):
self.REVISION_ID = UVMRegField.type_id.create("REVISION_ID")
self.CHIP_ID = UVMRegField.type_id.create("CHIP_ID")
self.PRODUCT_ID = UVMRegField.type_id.create("PRODUCT_ID")
self.REVISION_ID.configure(self, 8, 0, "RO", 0, 0x03, 1, 0, 1)
self.CHIP_ID.configure(self, 8, 8, "RO", 0, 0x5A, 1, 0, 1)
self.PRODUCT_ID.configure(self, 10, 16, "RO", 0, 0x176, 1, 0, 1)
uvm_object_utils(dut_ID)
class dut_DATA(UVMReg):
def __init__(self, name="dut_DATA"):
super().__init__(name, 32, UVM_NO_COVERAGE)
self.value = None
def build(self):
self.value = UVMRegField.type_id.create("value")
self.value.configure(self, 32, 0, "RW", 1, 0x0, 1, 0, 1)
uvm_object_utils(dut_DATA)
# Predict the value that will be in the register
m_data = rg.get() + 1
# If a backdoor write is used, replace the value written
# with the incremented value to emulate the front-door
if (rw.path == UVM_BACKDOOR):
rw.value[0] = m_data
await Timer(5, "NS")
# endtask: pre_write
#
#endclass : user_acp_reg
uvm_object_utils(user_acp_reg)
class block_B(UVMRegBlock):
# user_acp_reg user_acp;
def __init__(self, name="B"):
UVMRegBlock.__init__(self, name, UVM_NO_COVERAGE)
def build(self):
self.default_map = self.create_map("", 0, 1, UVM_BIG_ENDIAN)
self.user_acp = user_acp_reg.type_id.create("user_acp", None,
self.get_full_name())
self.user_acp.configure(self, None, "acp")
self.user_acp.build()
The registered callback methods are invoked before the invocation
of self method.
Args:
rw:
"""
await uvm_zero_delay()
#`ifdef UVM_USE_PROCESS_CONTAINER
# local process_container_c m_update_thread[uvm_object]
#`else
# local process m_update_thread[uvm_object]
#`endif
uvm_object_utils(UVMRegBackdoor)
#TODO `uvm_register_cb(UVMRegBackdoor, uvm_reg_cbs)
#//------------------------------------------------------------------------------
#// IMPLEMENTATION
#//------------------------------------------------------------------------------
#
#// start_update_thread
#
#def void UVMRegBackdoor::start_update_thread(self,uvm_object element):
# uvm_reg rg
# if (self.m_update_thread.exists(element)):
# self.kill_update_thread(element)
# end
# uvm_error("WRONG_TYPE", {"do_compare: rhs argument is not of type '",get_type_name(),"'"})
# return 0
# end
# return first.compare(rhs_.first) and second.compare(rhs_.second)
# endfunction
# def do_copy(self,uvm_object rhs):
# this_type rhs_
# if(!sv.cast(rhs_,rhs))
# uvm_fatal("WRONG_TYPE", {"do_copy: rhs argument is not of type '",get_type_name(),"'"})
# first.copy(rhs_.first)
# second.copy(rhs_.second)
# endfunction
uvm_object_utils(UVMClassPair)
#//-----------------------------------------------------------------------------
#// CLASS: UVMBuiltInPair #(T1,T2)
#//
#// Container holding two variables of built-in types (int, string, etc.). The
#// types are specified by the type parameters, T1 and T2.
#//-----------------------------------------------------------------------------
class UVMBuiltInPair(UVMObject):
type_name = "UVMBuiltInPair"
#// Variable: T1 first
def createXXX():
class XXX(UVMObject):
pass
uvm_object_utils(XXX)
return XXX
