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_class_field_iff(self):
@vsc.covergroup
class my_cg(object):
def __init__(self):
self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t()))
self.cp1 = vsc.coverpoint(self.a,
iff=(self.b == 9),
bins={
"a": vsc.bin_array([], 1, 2, 4),
"b": vsc.bin_array([4], [8, 16])
})
my_cg_1 = my_cg()
my_cg_1.sample(1, 0)
my_cg_1.sample(2, 9)
my_cg_1.sample(4, 0)
report = vsc.get_coverage_report_model()
str_report = vsc.get_coverage_report(details=True)
print("Report:\n" + str_report)
self.assertEquals(len(report.covergroups), 1)
self.assertEquals(len(report.covergroups[0].coverpoints), 1)
self.assertEquals(len(report.covergroups[0].coverpoints[0].bins), 7)
self.assertEquals(report.covergroups[0].coverpoints[0].bins[0].count,
0)
self.assertEquals(report.covergroups[0].coverpoints[0].bins[1].count,
1)
self.assertEquals(report.covergroups[0].coverpoints[0].bins[2].count,
0)
def test_mult_instances(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=dict(a_bins=vsc.bin_array([4], [0, 16])))
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)
str_report = vsc.get_coverage_report(details=True)
print("Report:\n" + str_report)
report = vsc.get_coverage_report_model()
self.assertEqual(1, len(report.covergroups))
self.assertEquals(2, len(report.covergroups[0].covergroups))
self.assertEquals(100, report.covergroups[0].coverage)
self.assertEquals(50, report.covergroups[0].covergroups[0].coverage)
self.assertEquals(100, report.covergroups[0].covergroups[1].coverage)
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_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_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_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_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 get_coverage_report(self):
model = vsc.get_coverage_report_model()
cov_dir = self.argv.log_file_name.split("/")[0]
file = open('{}/CoverageReport.txt'.format(cov_dir), 'w')
file.write("Groups Coverage Summary\n")
file.write("Total groups in report: {}\n".format(
len(model.covergroups)))
headers = ["SCORE", "WEIGHT", "NAME"]
table = []
for cg in model.covergroups:
table.append([cg.coverage, cg.weight, cg.name])
file.write(tabulate(table, headers, tablefmt="grid",
numalign="center", stralign="center"))
file.close()
# If enabled, write in xml format to be read by pyucis-viewer (visualization)
if self.argv.enable_visualization:
vsc.write_coverage_db("{}/cov_db.xml".format(cov_dir))
def get_coverage_report():
model = vsc.get_coverage_report_model()
file = open('CoverageReport.txt', 'w')
file.write("Groups Coverage Summary\n")
file.write("Total groups in report: {}\n".format(len(
model.covergroups)))
headers = ["SCORE", "WEIGHT", "NAME"]
table = []
for cg in model.covergroups:
table.append([cg.coverage, cg.weight, cg.name])
file.write(
tabulate(table,
headers,
tablefmt="grid",
numalign="center",
stralign="center"))
file.close()
# Write in xml format to be read by pyucis-viewer (visualization)
vsc.write_coverage_db("cov_db.xml")
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_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_single_type_two_inst_details(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)
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 disabled_test_programmatic_coverpoints(self):
@vsc.covergroup
class my_cg(object):
def __init__(self, n_cp):
var_names = ["a", "b", "c", "d"]
# Create a variable for all possible variables
parameters = dict()
parameters.update(map(lambda n: (n, vsc.uint8_t()), var_names))
self.with_sample(parameters)
self.coverpoints = []
for i in range(n_cp):
self.coverpoints.append(
vsc.coverpoint(
getattr(self, var_names[i]),
bins=dict(values=bin_array([], [1, 15]))))
cg1 = my_cg(2)
cg2 = my_cg(4)
report = get_coverage_report_model()
self.assertEqual(2, report.covergroups)
def test_diff_coverpoints(self):
@vsc.covergroup
class my_cg(object):
def __init__(self, create_cpb):
self.with_sample(a=vsc.uint32_t(), b=vsc.uint32_t())
self.a_cp = vsc.coverpoint(
self.a, bins=dict(bins_a=bin_array([], [1, 16])))
if create_cpb:
self.b_cp = vsc.coverpoint(
self.b, bins=dict(bins_b=bin_array([], [1, 16])))
cg1 = my_cg(False)
cg2 = my_cg(True)
cg1.sample(1, 0)
cg2.sample(0, 1)
report = vsc.get_coverage_report_model()
# There are two covergroup types
self.assertEqual(2, len(report.covergroups))
def test_class_field_cross_iff(self):
@vsc.covergroup
class my_cg(object):
def __init__(self):
self.with_sample(
dict(a=vsc.uint8_t(), b=vsc.uint8_t(), c=vsc.bool_t()))
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)})
self.cr = vsc.cross([self.cp1, self.cp2], iff=self.c)
# self.cr = vsc.cross([self.cp1, self.cp2])
my_cg_1 = my_cg()
for i in [1, 2, 4, 8]:
for j in [1, 2, 4, 8]:
my_cg_1.sample(i, j, i == j)
report = vsc.get_coverage_report_model()
str_report = vsc.get_coverage_report(details=True)
print("Report:\n" + str_report)
self.assertEquals(len(report.covergroups), 1)
self.assertEquals(len(report.covergroups[0].coverpoints), 2)
self.assertEquals(len(report.covergroups[0].crosses), 1)
for ii, i in enumerate([1, 2, 4, 8]):
for ji, j in enumerate([1, 2, 4, 8]):
if i == j:
self.assertEquals(
report.covergroups[0].crosses[0].bins[4 * ii +
ji].count, 1)
else:
self.assertEquals(
report.covergroups[0].crosses[0].bins[4 * ii +
ji].count, 0)
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)
