def test_cross(self): stim = FieldCompositeModel("stim", True) f = FieldScalarModel("a", 16, False, True) stim.add_field(f) f2 = FieldScalarModel("b", 16, False, True) stim.add_field(f2) cg = CovergroupModel("cg") cp = CoverpointModel(ExprFieldRefModel(f), "cp1", CoverageOptionsModel()) cg.add_coverpoint(cp) bn = CoverpointBinArrayModel("cp", 0, 1, 16) cp.add_bin_model(bn) cp2 = CoverpointModel(ExprFieldRefModel(f2), "cp2", CoverageOptionsModel()) cg.add_coverpoint(cp2) bn = CoverpointBinArrayModel("cp", 0, 1, 16) cp2.add_bin_model(bn) cr = CoverpointCrossModel("aXb", CoverageOptionsModel()) cr.add_coverpoint(cp) cr.add_coverpoint(cp2) cg.add_coverpoint(cr) gen = GeneratorModel("top") gen.add_field(stim) gen.add_covergroup(cg) gen.finalize() # Need a special randomizer to deal with generators r = Randomizer() count = 0 for i in range(1000): r.do_randomize([gen]) cg.sample() count += 1 cov = cg.get_coverage() print("Coverage: (" + str(i) + ") " + str(cov)) if cov == 100: break self.assertEqual(cg.get_coverage(), 100) # Ensure that we converge relatively quickly self.assertLessEqual(count, (256+16+16))
def __init__(self, name, type_t, is_scalar, enums, width, is_signed, is_rand, is_rand_sz): super().__init__(name, is_rand) # width and is_signed only needed for scalar fields self.type_t = type_t self.is_enum = (enums is not None) self.enums = enums self.is_scalar = is_scalar self.width = width self.is_signed = is_signed self.is_rand_sz = is_rand_sz # Holds a cached version of the sum constraint self.sum_expr_btor = None self.sum_expr = None # Holds a cached version of the sum constraint self.product_expr_btor = None self.product_expr = None self.size = FieldScalarModel( "size", 32, False, is_rand_sz) self._set_size(0)
def test_smoke(self): obj = FieldCompositeModel("obj") a = obj.add_field(FieldScalarModel("a", 8, False, True)) b = obj.add_field(FieldScalarModel("a", 8, False, True)) obj.add_constraint( ConstraintBlockModel("c", [ ConstraintExprModel( ExprBinModel(a.expr(), BinExprType.Lt, b.expr())) ])) rand = Randomizer(RandState(0)) randstate = RandState(0) rand.do_randomize(randstate, SourceInfo("", -1), [obj]) self.assertLess(a.val, b.val)
def test_coverpoint_bins(self): stim = FieldCompositeModel("stim", True) f = FieldScalarModel("a", 16, False, True) stim.add_field(f) f2 = FieldScalarModel("b", 16, False, True) stim.add_field(f2) cg = CovergroupModel("cg") cp = CoverpointModel(ExprFieldRefModel(f), "cp1", CoverageOptionsModel()) cg.add_coverpoint(cp) cp.add_bin_model(CoverpointBinArrayModel("bn1", 0, 1, 16)) cp.add_bin_model(CoverpointBinCollectionModel.mk_collection("bn2", RangelistModel([ [17,65535-16-1] ]), 16)) cp.add_bin_model(CoverpointBinArrayModel("bn3", 0, 65535-16, 65535)) cp2 = CoverpointModel(ExprFieldRefModel(f2), "cp2", CoverageOptionsModel()) cg.add_coverpoint(cp2) bn = CoverpointBinArrayModel("cp", 0, 1, 16) cp2.add_bin_model(bn) gen = GeneratorModel("top") gen.add_field(stim) gen.add_covergroup(cg) gen.finalize() # Need a special randomizer to deal with generators r = Randomizer() count = 0 for i in range(1000): r.do_randomize([gen]) cg.sample() count += 1 cov = cg.get_coverage() if cov == 100: break self.assertEqual(cg.get_coverage(), 100) # Ensure that we converge relatively quickly self.assertLessEqual(count, 64)
def test_simple(self): a = FieldScalarModel("a", 16, False, True) b = FieldScalarModel("b", 16, False, True) c = FieldScalarModel("c", 16, False, True) l = ExprLiteralModel(10, False, 8) ab_c = ConstraintBlockModel("ab_c", [ ConstraintImpliesModel( ExprBinModel(ExprFieldRefModel(a), BinExprType.Lt, ExprFieldRefModel(b)), [ ConstraintExprModel( ExprBinModel(ExprFieldRefModel(c), BinExprType.Eq, l)) ]) ]) copy = ConstraintCopyBuilder.copy(ab_c) self.assertEquals(1, len(copy)) self.assertIsNot(ab_c, copy[0])
def test_smoke(self): stim = FieldCompositeModel("stim", True) f = FieldScalarModel("a", 16, False, True) stim.add_field(f) f2 = FieldScalarModel("b", 16, False, True) stim.add_field(f2) cg = CovergroupModel("cg") cp = CoverpointModel(ExprFieldRefModel(f), "cp1", CoverageOptionsModel()) cg.add_coverpoint(cp) bn = CoverpointBinArrayModel("cp", 1, 16) cp.add_bin_model(bn) cp2 = CoverpointModel(ExprFieldRefModel(f2), "cp2", CoverageOptionsModel()) cg.add_coverpoint(cp2) bn = CoverpointBinArrayModel("cp", 1, 16) cp2.add_bin_model(bn) gen = GeneratorModel("top") gen.add_field(stim) gen.add_covergroup(cg) gen.finalize() # Need a special randomizer to deal with generators r = Randomizer(RandState(0)) randstate = RandState(0) count = 0 for i in range(1000): r.do_randomize(randstate, SourceInfo("", -1), [gen]) cg.sample() count += 1 cov = cg.get_coverage() if cov == 100: break self.assertEqual(cg.get_coverage(), 100) # Ensure that we converge relatively quickly self.assertLessEqual(count, 32)
def build_field_model(self, name): self._int_field_info.name = name if self._int_field_info.model is None: self._int_field_info.model = FieldScalarModel( name, self.width, self.is_signed, self._int_field_info.is_rand) self.set_val(self._init_val) else: # Ensure the name matches superstructure self._int_field_info.model.name = name return self._int_field_info.model
def __init__(self, name, is_scalar, width, is_signed, is_rand, is_rand_sz): super().__init__(name, is_rand) # width and is_signed only needed for scalar fields self.is_scalar = is_scalar self.width = width self.is_signed = is_signed self.is_rand_sz = is_rand_sz # Holds a cached version of the sum constraint self.sum_expr_btor = None self.sum_expr = None self.size = FieldScalarModel("size", 32, False, is_rand_sz)
def add_field(self) -> FieldScalarModel: fid = len(self.field_l) if self.is_enum: ret = super().add_field( EnumFieldModel(self.name + "[" + str(fid) + "]", self.enums, self.is_declared_rand)) else: ret = super().add_field( FieldScalarModel(self.name + "[" + str(fid) + "]", self.width, self.is_signed, self.is_declared_rand)) # Update the size self._set_size(len(self.field_l)) return ret
def test_wide_var(self): obj = FieldCompositeModel("obj") a = obj.add_field(FieldScalarModel("a", 1024, False, True)) obj.add_constraint( ConstraintBlockModel("c", [ ConstraintExprModel( ExprBinModel( a.expr(), BinExprType.Gt, ExprLiteralModel(0x80000000000000000, False, 72))) ])) randstate = RandState(0) rand = Randomizer(randstate) rand.do_randomize(randstate, SourceInfo("", -1), [obj]) print("a=" + hex(int(a.val))) self.assertGreater(a.val, ValueScalar(0x80000000000000000))
def add_field(self) -> FieldScalarModel: fid = len(self.field_l) return super().add_field( FieldScalarModel(self.name + "[" + str(fid) + "]", self.width, self.is_signed, self.is_declared_rand))
def __init__(self, lhs: 'FieldArrayModel'): super().__init__() self.lhs = lhs self.index = FieldScalarModel("index", 32, False, False) self.iterator = FieldScalarModel("iterator", 32, False, False)
def build_field_model(self, name): self._int_field_info.name = name self._int_field_info.model = FieldScalarModel( name, self.width, self.is_signed, self._int_field_info.is_rand, self) return self._int_field_info.model