def test_coverpoint_weight(self):
@vsc.covergroup
class cg(object):
def __init__(self):
self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t()))
self.cp1 = vsc.coverpoint(self.a,
bins={
"a": vsc.bin_array([], 1, 2, 4,
8),
},
options=dict(weight=1))
self.cp2 = vsc.coverpoint(
self.b,
bins={"b": vsc.bin_array([], 1, 2, 4, 8)},
options=dict(weight=0))
cg_i = cg()
cg_i.sample(1, 1)
cg_i.sample(2, 2)
cg_i.sample(4, 1)
cg_i.sample(8, 2)
vsc.report_coverage(details=True)
report = vsc.get_coverage_report_model()
self.assertEqual(report.covergroups[0].covergroups[0].coverage, 100.0)
self.assertEqual(
report.covergroups[0].covergroups[0].coverpoints[0].coverage,
100.0)
self.assertEqual(
report.covergroups[0].covergroups[0].coverpoints[1].coverage, 50.0)
def test_sample_nonvsc_object_local_lambda(self):
class my_e(IntEnum):
A = auto()
B = auto()
class my_c:
def __init__(self):
self.a = 5
self.b = my_e.A
@vsc.covergroup
class my_cg(object):
def __init__(self, input):
super().__init__()
# self.cp1 = vsc.coverpoint(lambda : input.a,
# bins=dict(
# a=vsc.bin_array([], [1, 15])
# ))
self.cp2 = vsc.coverpoint(lambda: input.b,
cp_t=vsc.enum_t(my_e))
inst = my_c()
cg = my_cg(inst)
inst.b = my_e.A
cg.sample()
inst.b = my_e.B
cg.sample()
vsc.report_coverage(details=True)
self.assertEquals(cg.cp2.get_coverage(), 100)
def test_covergroup_atleast(self):
@vsc.covergroup
class cg(object):
def __init__(self):
self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t()))
self.options.at_least = 2
self.cp1 = vsc.coverpoint(self.a,
bins={
"a": vsc.bin_array([], 1, 2, 4,
8),
})
self.cp2 = vsc.coverpoint(
self.b, bins={"b": vsc.bin_array([], 1, 2, 4, 8)})
cg_i = cg()
cg_i.sample(1, 1)
cg_i.sample(1, 2)
cg_i.sample(2, 4)
cg_i.sample(2, 8)
vsc.report_coverage(details=True)
report = vsc.get_coverage_report_model()
self.assertEqual(
report.covergroups[0].covergroups[0].coverpoints[0].coverage, 50.0)
self.assertEqual(
report.covergroups[0].covergroups[0].coverpoints[1].coverage, 0.0)
def test_sample_vsc_object_with_sample(self):
@vsc.randobj
class my_c:
def __init__(self):
self.a = vsc.uint32_t(i=0)
self.b = vsc.uint32_t(i=0)
@vsc.covergroup
class my_cg(object):
def __init__(self):
super().__init__()
self.with_sample(dict(input=my_c()))
self.cp1 = vsc.coverpoint(
self.input.a, bins=dict(a=vsc.bin_array([], [1, 15])))
self.cp2 = vsc.coverpoint(
self.input.b, bins=dict(b=vsc.bin_array([], [1, 15])))
inst = my_c()
cg = my_cg()
inst.a = 1
inst.b = 1
cg.sample(inst)
inst.a = 2
inst.b = 2
cg.sample(inst)
vsc.report_coverage(details=True)
report = vsc.get_coverage_report_model()
self.assertEqual(len(report.covergroups), 1)
self.assertEqual(len(report.covergroups[0].coverpoints), 2)
self.assertEqual(report.covergroups[0].coverpoints[0].coverage, 13.33)
self.assertEqual(report.covergroups[0].coverpoints[1].coverage, 13.33)
def test_enum_lambda(self):
class my_e(IntEnum):
A = auto()
B = auto()
@vsc.covergroup
class my_covergroup(object):
def __init__(self, a,
b): # Need to use lambda for non-reference values
super().__init__()
self.cp1 = vsc.coverpoint(
a,
options=dict(auto_bin_max=64),
bins=dict(a=vsc.bin_array([], [1, 15])))
self.cp2 = vsc.coverpoint(b, cp_t=vsc.enum_t(my_e))
a = 1
b = my_e.A
cg = my_covergroup(lambda: a, lambda: b)
cg.sample()
cg.dump()
vsc.report_coverage(details=True)
def test_smoke(self):
@vsc.covergroup
class my_cg(object):
def __init__(self):
self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t()))
self.a_cp = vsc.coverpoint(self.a,
bins={"a": bin_array(4, [1, 15])})
my_cg_1 = my_cg()
my_cg_2 = my_cg()
for i in range(8):
my_cg_1.sample(i, 0)
for i in range(16):
my_cg_2.sample(i, 0)
report = vsc.get_coverage_report_model()
self.assertEqual(1, len(report.covergroups))
self.assertEqual(2, len(report.covergroups[0].covergroups))
self.assertEqual(1,
len(report.covergroups[0].covergroups[0].coverpoints))
self.assertEqual(1,
len(report.covergroups[0].covergroups[1].coverpoints))
vsc.report_coverage(details=True)
def test_smoke(self):
import vsc
@vsc.randobj
class ignore_bins_test(object):
def __init__(self):
self.a = vsc.rand_int32_t()
self.value = vsc.rand_bit_t(32)
@vsc.covergroup
class val_cg(object):
def __init__(self):
self.instr = None
self.cp_val = vsc.coverpoint(
lambda: self.instr.value[7:5],
cp_t=vsc.bit_t(3),
ignore_bins=dict(invalid_value=vsc.bin(0b101, 0b110)))
self.cp_a = vsc.coverpoint(
lambda: self.instr.a,
cp_t=vsc.bit_t(32),
ignore_bins=dict(invalid_a=vsc.bin(5, 3, 100, 124, 1110)))
test_obj = ignore_bins_test()
val_cg_i = val_cg()
for i in range(5):
test_obj.randomize()
print("a = {}, value = {}".format(test_obj.a, test_obj.value))
val_cg_i.instr = test_obj
val_cg_i.sample()
vsc.report_coverage(details=True)
def test_cov_2(self):
@vsc.randobj
class my_item_c(object):
def __init__(self):
self.a = vsc.rand_bit_t(8)
self.b = vsc.rand_bit_t(8)
@vsc.constraint
def ab_c(self):
self.a != 0
self.a <= self.b
self.b in vsc.rangelist(1,2,4,8)
@vsc.covergroup
class my_cg(object):
def __init__(self):
# Define the parameters accepted by the sample function
self.with_sample({
'a' : vsc.bit_t(8),
'b' : vsc.bit_t(8)
})
self.a_cp = vsc.coverpoint( self.a, bins={
# Create 4 bins across the space 0..255
'a_bins': vsc.bin_array([4], [0,255])
})
self.b_cp = vsc.coverpoint(self.b, bins={
# Create one bin for each value (1,2,4,8)
'b_bins': vsc.bin_array([], 1, 2, 4, 8)
})
self.ab_cross = vsc.cross([self.a_cp, self.b_cp])
it = my_item_c()
it.a = 4
it.b = 1
my_cg_i = my_cg()
my_cg_i.sample(it.a, it.b)
it.b = 2
my_cg_i.sample(it.a, it.b)
self.assertEqual(my_cg_i.a_cp.get_coverage(), 25.0)
self.assertEqual(my_cg_i.b_cp.get_coverage(), 50.0)
self.assertEqual(my_cg_i.ab_cross.get_coverage(), 12.5)
report_coverage(details=True)
print("coverage: %f %f" % (my_cg_i.a_cp.get_coverage(), my_cg_i.b_cp.get_coverage()))
def test_ignore_left_trim(self):
import vsc
@vsc.randobj
class ignore_bins_test(object):
def __init__(self):
self.a = vsc.rand_int32_t()
self.value = vsc.rand_bit_t(32)
@vsc.covergroup
class val_cg(object):
def __init__(self):
self.with_sample(dict(a=vsc.uint8_t()))
self.cp_val = vsc.coverpoint(
self.a,
bins=dict(rng_1=vsc.bin_array([4], [1, 3], [4, 6], [7, 9],
[10, 12])),
ignore_bins=dict(invalid_value=vsc.bin(4)))
test_obj = ignore_bins_test()
val_cg_i = val_cg()
# Note: bins are partitioned *after* removing excluded bins. This means
# that 11 values are partitioned into 4 bins.
# [1,2]
# [3,5]
# [6,7]
# [8..12]
val_cg_i.sample(2)
val_cg_i.sample(5)
val_cg_i.sample(6)
val_cg_i.sample(12)
vsc.report_coverage(details=True)
cvg_m = vsc.get_coverage_report_model()
self.assertEqual(len(cvg_m.covergroups), 1)
self.assertEqual(len(cvg_m.covergroups[0].coverpoints), 1)
self.assertEqual(len(cvg_m.covergroups[0].coverpoints[0].bins), 4)
self.assertEqual(len(cvg_m.covergroups[0].coverpoints[0].ignore_bins),
1)
self.assertEqual(cvg_m.covergroups[0].coverpoints[0].bins[0].count, 1)
self.assertEqual(cvg_m.covergroups[0].coverpoints[0].bins[1].count, 1)
self.assertEqual(cvg_m.covergroups[0].coverpoints[0].bins[2].count, 1)
self.assertEqual(cvg_m.covergroups[0].coverpoints[0].bins[3].count, 1)
self.assertEqual(
cvg_m.covergroups[0].coverpoints[0].ignore_bins[0].count, 0)
val_cg_i.sample(4)
cvg_m = vsc.get_coverage_report_model()
self.assertEqual(
cvg_m.covergroups[0].coverpoints[0].ignore_bins[0].count, 1)
def test_covergroup_setname_init(self):
@vsc.covergroup
class cg_t(object):
def __init__(self, name):
self.with_sample(dict(a=vsc.uint8_t()))
self.set_name(name)
self.cp = vsc.coverpoint(self.a)
cg1 = cg_t("cg1")
cg2 = cg_t("cg2")
vsc.report_coverage()
report = vsc.get_coverage_report_model()
self.assertEqual(len(report.covergroups), 1)
self.assertEqual(len(report.covergroups[0].covergroups), 2)
self.assertEqual(report.covergroups[0].covergroups[0].name, "cg1")
self.assertEqual(report.covergroups[0].covergroups[1].name, "cg2")
def test_smoke(self):
class my_r(RandIF):
"""Defines operations to be implemented by a random generator"""
def __init__(self):
super().__init__()
def randint(self, low: int, high: int) -> int:
return low
def sample(self, s, k):
return random.sample(s, k)
@vsc.randobj
class cls(object):
def __init__(self):
self.a = vsc.rand_uint32_t()
self.b = vsc.rand_uint32_t()
@vsc.covergroup
class cvg(object):
def __init__(self):
self.with_sample(dict(a=vsc.uint32_t(), b=vsc.uint32_t()))
self.a_cp = vsc.coverpoint(
self.a, bins=dict(a1=vsc.bin_array([], 1, 2, 4, 8)))
self.b_cp = vsc.coverpoint(
self.b, bins=dict(b1=vsc.bin_array([], 1, 2, 4, 8)))
c = cls()
cg = cvg()
c.a = 1
c.b = 1
cg.sample(c.a, c.b)
r = my_r()
bin = cg.a_cp.get_model().select_unhit_bin(r)
rng = cg.a_cp.get_model().get_bin_range(bin)
print("bin=" + str(bin) + " rng=" + str(rng))
print(ModelPrettyPrinter().print(rng))
vsc.report_coverage()
def test_object_sample_2(self):
import vsc
@vsc.randobj
class BranchInstr:
def __init__(self):
self.type = vsc.rand_bit_t(1)
self.disp = vsc.rand_bit_t(19)
@vsc.constraint
def short_offset_cnstr(self):
self.disp <= 4096
def __str__(self):
return (f"type = {self.type}, displacement = {self.disp}")
@vsc.covergroup
class BranchInstr_cg:
def __init__(self):
self.with_sample(item=BranchInstr())
self.type = vsc.coverpoint(self.item.type)
self.disp_cp = vsc.coverpoint(
self.item.disp,
bins={"small_pos": vsc.bin_array([4], [0, 4096])})
branchInstr = BranchInstr()
branchInstr_cg = BranchInstr_cg()
for i in range(32):
branchInstr.randomize()
branchInstr_cg.sample(branchInstr)
print(branchInstr)
rpt = vsc.get_coverage_report_model()
self.assertEqual(len(rpt.covergroups[0].coverpoints), 2)
self.assertEqual(len(rpt.covergroups[0].coverpoints[0].bins), 2)
self.assertEqual(len(rpt.covergroups[0].coverpoints[1].bins), 4)
vsc.report_coverage(details=True)
def test_array_wildcard_bin_3(self):
import vsc
@vsc.covergroup
class cg(object):
def __init__(self):
self.with_sample(dict(a=vsc.bit_t(8)))
self.cp_a = vsc.coverpoint(
lambda: self.a[7:0],
bins=dict(a=vsc.wildcard_bin_array([], "0b1011011x",
"0b0x101010"),
b=vsc.wildcard_bin_array([], "0b1011011x",
"0b0x10x01x")))
obj1 = cg()
model = vsc.get_coverage_report_model()
self.assertEqual(len(model.covergroups), 1)
self.assertEqual(len(model.covergroups[0].coverpoints), 1)
self.assertEqual(len(model.covergroups[0].coverpoints[0].bins), 14)
vsc.report_coverage(details=True)
def test_cross_sampling(self):
@vsc.covergroup
class my_cg(object):
def __init__(self, a, b):
super().__init__()
self.cp1 = vsc.coverpoint(
a, bins={"a": vsc.bin_array([], [1, 10])})
self.cp2 = vsc.coverpoint(
b, bins={"b": vsc.bin_array([], [1, 10])})
self.cp1X2 = vsc.cross([self.cp1, self.cp2])
a = 6
b = 8
cg = my_cg(lambda: a, lambda: b)
for i in range(50):
cg.sample()
vsc.report_coverage(details=True)
# vsc.report_coverage(details=False)
print("Coverage: " + str(cg.get_coverage()))
def test_bin_names_int_enum(self):
class my_e_1(IntEnum):
A = auto()
B = auto()
class my_e_2(IntEnum):
C = auto()
D = auto()
@vsc.covergroup
class my_cg(object):
def __init__(self, v1, v2):
self.cp1 = vsc.coverpoint(v1, cp_t=vsc.enum_t(my_e_1))
self.cp2 = vsc.coverpoint(v2, cp_t=vsc.enum_t(my_e_2))
self.cp1X2 = vsc.cross([self.cp1, self.cp2])
for i in range(16):
# A=random.rand(2)
# B=random.rand(2)
# C=random.rand(2)
# D=random.rand(2)
v1 = my_e_1.A
v2 = my_e_2.C
cg = my_cg(lambda: v1, lambda: v2)
cg.sample()
v1 = my_e_1.B
v2 = my_e_2.D
cg.sample()
vsc.report_coverage(details=True)
report = vsc.get_coverage_report_model()
self.assertEqual(len(report.covergroups), 1)
self.assertEqual(len(report.covergroups[0].coverpoints), 2)
self.assertEqual(len(report.covergroups[0].crosses), 1)
self.assertEqual(report.covergroups[0].coverpoints[0].coverage, 100)
self.assertEqual(report.covergroups[0].coverpoints[1].coverage, 100)
self.assertEqual(report.covergroups[0].crosses[0].coverage, 50)
def test_coverpoint_atleast_option(self):
@vsc.covergroup
class cg(object):
def __init__(self):
self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t()))
self.options.at_least = 2
self.cp1 = vsc.coverpoint(self.a,
bins={
"a": vsc.bin_array([], 1, 2, 4,
8),
})
self.cp2 = vsc.coverpoint(
self.b, bins={"b": vsc.bin_array([], 1, 2, 4, 8)})
cg_i = cg()
cg_i.sample(1, 1)
cg_i.sample(1, 2)
cg_i.sample(2, 4)
cg_i.sample(2, 8)
vsc.report_coverage(details=True)
def test_single_type_two_inst(self):
@vsc.covergroup
class my_cg(object):
def __init__(self):
self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t()))
self.a_cp = vsc.coverpoint(self.a,
bins={"a": bin_array([], [0, 15])})
my_cg_1 = my_cg()
my_cg_2 = my_cg()
for i in range(16):
my_cg_1.sample(i, 0)
vsc.report_coverage()
report = vsc.get_coverage_report_model()
self.assertEqual(1, len(report.covergroups))
self.assertEqual(2, len(report.covergroups[0].covergroups))
self.assertEqual(100, report.covergroups[0].coverage)
self.assertEqual(100, report.covergroups[0].covergroups[0].coverage)
self.assertEqual(0, report.covergroups[0].covergroups[1].coverage)
def test_enum_bins_autobin_exclude(self):
import vsc
class my_e(IntEnum):
A = auto()
B = auto()
C = auto()
D = auto()
E = auto()
F = auto()
G = auto()
H = auto()
@vsc.randobj
class ignore_bins_test(object):
def __init__(self):
self.v = vsc.rand_enum_t(my_e)
@vsc.covergroup
class val_cg(object):
def __init__(self):
self.with_sample(dict(v=vsc.enum_t(my_e)))
self.cp_v = vsc.coverpoint(self.v,
ignore_bins=dict(
ignore_1=vsc.bin(my_e.D),
ignore_2=vsc.bin(my_e.H)))
test_obj = ignore_bins_test()
val_cg_i = val_cg()
# Sample all non-excluded values
for v in (my_e.A, my_e.B, my_e.C, my_e.E, my_e.F, my_e.G):
val_cg_i.sample(v)
vsc.report_coverage(details=True)
coverage_model = vsc.get_coverage_report_model()
self.assertEqual(len(coverage_model.covergroups), 1)
self.assertEqual(len(coverage_model.covergroups[0].coverpoints), 1)
self.assertEqual(
len(coverage_model.covergroups[0].coverpoints[0].bins), 6)
self.assertEqual(
len(coverage_model.covergroups[0].coverpoints[0].ignore_bins), 2)
self.assertEqual(
coverage_model.covergroups[0].coverpoints[0].ignore_bins[0].count,
0)
self.assertEqual(
coverage_model.covergroups[0].coverpoints[0].ignore_bins[1].count,
0)
val_cg_i.sample(my_e.D)
coverage_model = vsc.get_coverage_report_model()
self.assertEqual(
coverage_model.covergroups[0].coverpoints[0].ignore_bins[0].count,
1)
self.assertEqual(
coverage_model.covergroups[0].coverpoints[0].ignore_bins[1].count,
0)
val_cg_i.sample(my_e.H)
coverage_model = vsc.get_coverage_report_model()
self.assertEqual(
coverage_model.covergroups[0].coverpoints[0].ignore_bins[0].count,
1)
self.assertEqual(
coverage_model.covergroups[0].coverpoints[0].ignore_bins[1].count,
1)
