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", 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)
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(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()
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 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 randomize(*args, **kwargs):
"""Randomize a list of variables"""
frame = inspect.stack()[1]
fields = []
for v in args:
if hasattr(v, "get_model"):
fields.append(v.get_model())
else:
raise Exception("Parameter \"" + str(v) +
" to randomize is not a vsc object")
debug = 0
if "debug" in kwargs.keys():
debug = kwargs["debug"]
solve_fail_debug = False
if "solve_fail_debug" in kwargs:
solve_fail_debug = kwargs["solve_fail_debug"]
randstate = None
if "randstate" in kwargs:
randstate = kwargs["randstate"]
else:
randstate = RandState(random.randint(0, 0xFFFFFFFF))
Randomizer.do_randomize(randstate,
SourceInfo(frame.filename, frame.lineno),
fields,
solve_fail_debug=solve_fail_debug,
debug=debug)
def test_incr(self):
obj = FieldCompositeModel("obj")
arr = obj.add_field(
FieldArrayModel(
"arr",
None, # type_t
True, # is_scalar
None, # not an enum-type list
32,
False,
True,
False))
for i in range(10):
arr.add_field()
obj.add_constraint(
ConstraintBlockModel("XX", [
ConstraintExprModel(
ExprBinModel(ExprFieldRefModel(arr.size), BinExprType.Eq,
ExprLiteralModel(10, False, 32)))
]))
foreach = ConstraintForeachModel(ExprFieldRefModel(arr))
foreach.addConstraint(
ConstraintImpliesModel(
ExprBinModel(ExprFieldRefModel(foreach.index), BinExprType.Gt,
ExprLiteralModel(0, False, 32)),
[
ConstraintExprModel(
ExprBinModel(
ExprArraySubscriptModel(
ExprFieldRefModel(arr),
ExprFieldRefModel(foreach.index)),
BinExprType.Eq,
ExprBinModel(
ExprArraySubscriptModel(
ExprFieldRefModel(arr),
ExprBinModel(
ExprFieldRefModel(foreach.index),
BinExprType.Sub,
ExprLiteralModel(1, False, 32))),
BinExprType.Add, ExprLiteralModel(
1, False, 32))))
]))
obj.add_constraint(ConstraintBlockModel("c", [foreach]))
# print("Object: " + ModelPrettyPrinter.print(obj))
#
# constraints = ArrayConstraintBuilder.build(obj)
# for c in constraints:
# print("Constraint: " + ModelPrettyPrinter.print(c))
# print("Object(1): " + ModelPrettyPrinter.print(obj))
#
# ConstraintOverrideRollbackVisitor.rollback(obj)
# print("Object(2): " + ModelPrettyPrinter.print(obj))
randstate = RandState(0)
Randomizer.do_randomize(randstate, SourceInfo("", -1), [obj])
for f in arr.field_l:
print("" + f.name + ": " + str(int(f.get_val())))
def get_randstate(self) -> RandState:
if self.randstate is None:
# Construct state
self.randstate = RandState.mk()
# Note: this is returned by reference. The
# caller must clone as needed if saving
# a copy or mutating the state
return self.randstate
def randomize_with(*args, **kwargs):
"""Randomize a list of variables with an inline constraint"""
field_l = []
for v in args:
if not hasattr(v, "get_model"):
raise Exception("Parameter \"" + str(v) +
" to randomize is not a vsc object")
field_l.append(v.get_model())
debug = 0
if "debug" in kwargs.keys():
debug = kwargs["debug"]
solve_fail_debug = False
if "solve_fail_debug" in kwargs:
solve_fail_debug = kwargs["solve_fail_debug"]
randstate = None
if "randstate" in kwargs:
randstate = kwargs["randstate"]
else:
randstate = RandState(random.randint(0, 0xFFFFFFFF))
class inline_constraint_collector(object):
def __init__(self, randstate, field_l, solve_fail_debug):
self.randstate = randstate
self.field_l = field_l
self.solve_fail_debug = solve_fail_debug
def __enter__(self):
# Go into 'expression' mode
enter_expr_mode()
push_constraint_scope(ConstraintBlockModel("inline"))
return self
def __exit__(self, t, v, tb):
frame = inspect.stack()[1]
c = pop_constraint_scope()
leave_expr_mode()
try:
Randomizer.do_randomize(self.randstate,
SourceInfo(frame.filename,
frame.lineno),
self.field_l, [c],
debug=debug)
except SolveFailure as e:
if _solve_fail_debug or self.solve_fail_debug:
print("Solve Failure")
raise e
return inline_constraint_collector(randstate, field_l, solve_fail_debug)
def test_same_seed_str(self):
@vsc.randobj
class item_c(object):
def __init__(self):
self.a = vsc.rand_uint8_t()
self.b = vsc.rand_uint8_t()
@vsc.constraint
def ab_c(self):
self.a < self.b
ci = item_c()
v1 = []
v2 = []
print("Iteration 1")
rs1 = RandState.mkFromSeed(10, "abc")
ci.set_randstate(rs1)
for _ in range(10):
ci.randomize()
v1.append((ci.a, ci.b))
print("Iteration 2")
rs2 = RandState.mkFromSeed(10, "abc")
ci.set_randstate(rs2)
for _ in range(10):
ci.randomize()
v2.append((ci.a, ci.b))
# Check that two lists are not exactly equal
all_equal = True
for i in range(len(v1)):
print("[%d] v1=(%d,%d) v2=(%d,%d)" %
(i, v1[i][0], v1[i][1], v2[i][0], v2[i][1]))
if v1[i][0] != v2[i][0] or v1[i][1] != v2[i][1]:
all_equal = False
# break
self.assertTrue(all_equal)
def test_init_state(self):
@vsc.randobj
class item_c(object):
def __init__(self):
self.a = vsc.rand_uint8_t()
self.b = vsc.rand_uint8_t()
@vsc.constraint
def ab_c(self):
self.a < self.b
ci = item_c()
v1 = []
v2 = []
rs1 = RandState(0)
ci.set_randstate(rs1)
for _ in range(100):
ci.randomize()
v1.append((ci.a, ci.b))
rs2 = RandState(100)
ci.set_randstate(rs2)
for _ in range(100):
ci.randomize()
v2.append((ci.a, ci.b))
# Check that two lists are not exactly equal
all_equal = True
for i in range(len(v1)):
if v1[i][0] != v2[i][0] or v1[i][1] != v2[i][1]:
all_equal = False
break
self.assertFalse(all_equal)
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 test_diff_seed(self):
@vsc.randobj
class item_c(object):
def __init__(self):
self.a = vsc.rand_uint8_t()
self.b = vsc.rand_uint8_t()
@vsc.constraint
def ab_c(self):
self.a < self.b
ci = item_c()
v1 = []
v2_1 = []
v2_2 = []
print("Iteration 1")
rs1 = RandState.mkFromSeed(0)
ci.set_randstate(rs1)
for _ in range(10):
ci.randomize()
v1.append((ci.a, ci.b))
rand_s = rs1.randint(0, 1000000)
rs2_1 = RandState.mkFromSeed(rand_s)
rs2_2 = RandState.mkFromSeed(rand_s)
print("Iteration 2_1")
ci.set_randstate(rs2_1)
for _ in range(10):
ci.randomize()
v2_1.append((ci.a, ci.b))
print("Iteration 2_2")
ci.set_randstate(rs2_2)
for _ in range(10):
ci.randomize()
v2_2.append((ci.a, ci.b))
# Check that two lists are not exactly equal
all_equal = True
for i in range(len(v1)):
print("[%d] v2_1=(%d,%d) v2_2=(%d,%d)" %
(i, v2_1[i][0], v2_1[i][1], v2_2[i][0], v2_2[i][1]))
if v2_1[i][0] != v2_2[i][0] or v2_1[i][1] != v2_2[i][1]:
all_equal = False
break
self.assertTrue(all_equal)
# Check that we have differences from the first set
all_equal = True
for i in range(len(v1)):
print("[%d] v1=(%d,%d) v2_2=(%d,%d)" %
(i, v1[i][0], v1[i][1], v2_2[i][0], v2_2[i][1]))
if v1[i][0] != v2_2[i][0] or v1[i][1] != v2_2[i][1]:
all_equal = False
break
self.assertFalse(all_equal)