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 test_coverpoint_array_bin(self):
cg = CovergroupModel("cg")
a = 0
a_cp = CoverpointModel(ExprRefModel(lambda: a, 32, False), "a_cp",
CoverageOptionsModel())
cg.add_coverpoint(a_cp)
bins = a_cp.add_bin_model(CoverpointBinArrayModel("a", 0, 15))
cg.finalize()
for i in range(8):
a = i
cg.sample()
for i in range(16):
if (i < 8):
self.assertEqual(a_cp.get_bin_hits(i), 1)
else:
self.assertEqual(a_cp.get_bin_hits(i), 0)
self.assertEqual(a_cp.get_coverage(), 50.0)
self.assertEqual(cg.get_coverage(), 50.0)
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_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 visit_coverpoint_bin_array(self, bn: CoverpointBinArrayModel):
from ucis.source_info import SourceInfo
active_cp = self.active_scope_s[-1]
decl_location = None
if bn.srcinfo_decl is not None:
decl_location = SourceInfo(
self.get_file_handle(bn.srcinfo_decl.filename),
bn.srcinfo_decl.lineno, 0)
for i in range((bn.high - bn.low) + 1):
v = bn.low + i
bn_name = bn.name + "[%d]" % (v, )
cp_bin = active_cp.createBin(
bn_name,
decl_location,
1, # weight
bn.get_hits(i),
bn.name)
def mk_collection(name: str, rangelist: RangelistModel,
n_bins) -> 'CoverpointBinCollectionModel':
"""Creates a bin collection by partitioning a rangelist"""
n_values = 0
for r in rangelist.range_l:
if r[0] == r[1]:
n_values += 1
else:
n_values += (r[1] - r[0] + 1)
idx = 0
if CoverpointBinCollectionModel.DEBUG_EN:
print("--> mk_collection: %d bins ; %d values" %
(n_bins, n_values))
ret = CoverpointBinCollectionModel(name)
if n_bins < n_values:
# We need to partition the values into bins
values_per_bin = int(n_values / n_bins)
have_leftover = ((n_values % n_bins) != 0)
r = None
if CoverpointBinCollectionModel.DEBUG_EN:
print(" Must partition into %d values per bin" %
values_per_bin)
rng_i = 0
for bin_i in range(n_bins):
# print("bin_i: " + str(bin_i))
if r is None:
r = rangelist.range_l[rng_i]
# print("r=" + str(r[0]) + ".." + str(r[1]))
# If the bin fits within this interval, then just
# create a range bin
if (r[1] - r[0] + 1) >= values_per_bin:
if CoverpointBinCollectionModel.DEBUG_EN:
print(
"Bin %d..%d is >= values_per_bin ; create bin %d..%d"
% (r[0], r[1], r[0], r[0] + values_per_bin - 1))
if bin_i + 1 < n_bins or not have_leftover:
ret.add_bin(
CoverpointBinSingleRangeModel(
name + "[" + str(idx) + "]", r[0],
r[0] + values_per_bin - 1))
else:
# When we have leftovers, ensure that the last
# bin is a collection
b = ret.add_bin(
CoverpointBinSingleBagModel(name + "[" + str(idx) +
"]"))
b.binspec.add_range(r[0], r[1])
idx += 1
if ((r[1] - r[0] + 1) > values_per_bin):
# We need to continue working on this range
if CoverpointBinCollectionModel.DEBUG_EN:
print("Still space in interval. Adjust to %d..%d" %
(r[0] + values_per_bin, r[1]))
r = r.copy()
r[0] += values_per_bin
else:
# We need to move to the next range
r = None
rng_i += 1
else:
# The number of values here is smaller than the bin size
# We need to start a bin and move forward until we've
# collected enough values
b = ret.add_bin(
CoverpointBinSingleBagModel(name + "[" + str(idx) +
"]"))
idx += 1
b.binspec.add_range(r[0], r[1])
n_remaining = values_per_bin - (r[1] - r[0] + 1)
if CoverpointBinCollectionModel.DEBUG_EN:
print(
"Too few values leftover to fill a bin: (%d..%d) remaining=%d"
% (r[0], r[1], n_remaining))
r = None
rng_i += 1
# print("n_remaining=" + str(n_remaining) + " values_per_bin=" + str(values_per_bin))
while n_remaining > 0:
if r is None:
r = rangelist.range_l[rng_i]
if (r[1] - r[0]) < n_remaining:
# This range is smaller than the remaining bin space
b.binspec.add_range(r[0], r[1])
n_remaining -= (r[1] - r[0] + 1)
r = None
rng_i += 1
else:
# This range is larger than the remaining bin space
b.binspec.add_range(r[0], r[0] + n_remaining - 1)
r = r.copy()
r[0] += n_remaining
n_remaining = 0
if r is not None:
# Extend the last bin range
if CoverpointBinCollectionModel.DEBUG_EN:
print("[1] Add leftover range %d..%d" % (r[0], r[1]))
if r[0] == r[1]:
ret.bin_l[-1].binspec.add_value(r[0])
else:
ret.bin_l[-1].binspec.add_range(r[0], r[1])
rng_i += 1
while rng_i < len(rangelist.range_l):
r = rangelist.range_l[rng_i]
if CoverpointBinCollectionModel.DEBUG_EN:
print("[2] Add leftover range %d..%d" % (r[0], r[1]))
if r[0] == r[1]:
ret.bin_l[-1].binspec.add_value(r[0])
else:
ret.bin_l[-1].binspec.add_range(r[0], r[1])
rng_i += 1
else:
# We don't actually need to partition
for r in rangelist.range_l:
if r[0] == r[1]:
ret.add_bin(
CoverpointBinSingleValModel(
name + "[" + str(idx) + "]", r[0]))
else:
ret.add_bin(CoverpointBinArrayModel(name, r[0], r[1]))
idx += 1
return ret