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