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([], [1, 16])))
self.b_cp = vsc.coverpoint(
self.b, bins=dict(b_bins=vsc.bin_array([], [1, 16])))
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])))
def __init__(self):
self.with_sample(dict(a1=vsc.bit_t(8), a2=vsc.bit_t(8)))
self.cp_a1 = vsc.coverpoint(
self.a1, bins=dict(a=vsc.wildcard_bin("0x8x", "0x6x")))
self.cp_a2 = vsc.coverpoint(
self.a2, bins=dict(a=vsc.wildcard_bin("0x8x", "0x6x")))
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)))
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])
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])})
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)
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])))
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))
def __init__(self, a, b):
self.a_cp = vsc.coverpoint(
a,
options=dict(weight=8),
bins=dict(a_arr=vsc.bin_array([], [1, 8])))
self.b_cp = vsc.coverpoint(
b,
options=dict(weight=4),
bins=dict(b_arr=vsc.bin_array([], [1, 4])))
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)))
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)})
def __init__(self):
super().__init__()
self.a=None
self.b=None
self.cp1 = vsc.coverpoint(lambda:self.a,
bins=dict(
a = vsc.bin_array([], [0,15])
))
self.cp2 = vsc.coverpoint(lambda:self.b, bins=dict(
b = vsc.bin_array([], [0,15])
))
self.cross = vsc.cross([self.cp1, self.cp2])
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))
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)))
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)),
illegal_bins=dict(ignore_2=vsc.bin(my_e.H)))
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")))
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))
def __init__(self, sample_c):
self.with_sample(dict(a=vsc.uint8_t(), b=vsc.uint8_t()))
self.cp1 = vsc.coverpoint(self.a,
iff=sample_c,
bins={
"a": vsc.bin_array([], 1, 2, 4),
"b": vsc.bin_array([4], [8, 16])
})
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])
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]))))
def __init__(self, name):
self.with_sample(dict(a=vsc.uint8_t()))
self.options.name = name
self.cp = vsc.coverpoint(self.a)
def __init__(self):
self.with_sample(dict(a=vsc.bit_t(8)))
self.cp_a = vsc.coverpoint(
self.a, bins=dict(a=vsc.wildcard_bin_array([], "0x8x")))
def __init__(self):
self.with_sample(dict(a=vsc.bit_t(8)))
self.cp_a = vsc.coverpoint(
self.a, bins=dict(a=vsc.wildcard_bin((0x80, 0xF0))))
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])})
def __init__(self, it):
super().__init__(it)
self.cp2 = vsc.coverpoint(it, bins={"a": vsc.bin(7)})
def __init__(self):
self.with_sample(dict(
a=vsc.uint16_t()
))
self.a_cp = vsc.coverpoint(self.a)
def __init__(self, name):
self.with_sample(dict(a=vsc.uint8_t()))
self.set_name(name)
self.cp = vsc.coverpoint(self.a)
def __init__(self):
self.with_sample(dict(a=vsc.bit_t(8)))
self.a_cp = vsc.coverpoint(
self.a, bins=dict(a=vsc.bin_array([], [1, 16])))
def __init__(self, v):
self.cp = vsc.coverpoint(v, cp_t=vsc.enum_t(my_e))
