def get_exponent(x):
return ((x & 0x7f800000) >> 23) - 127
+def set_exponent(x, e):
+ return (x & ~0x7f800000) | ((e+127) << 23)
+
def get_sign(x):
return ((x & 0x80000000) >> 31)
(x == y)
)
-def get_case(dut, a, b):
- yield dut.in_a.v.eq(a)
- yield dut.in_a.stb.eq(1)
+def get_case(dut, a, b, mid):
+ in_a, in_b = dut.rs[0]
+ out_z = dut.res[0]
+ yield dut.ids.in_mid.eq(mid)
+ yield in_a.v.eq(a)
+ yield in_a.stb.eq(1)
+ yield
yield
yield
- a_ack = (yield dut.in_a.ack)
+ yield
+ a_ack = (yield in_a.ack)
assert a_ack == 0
- yield dut.in_b.v.eq(b)
- yield dut.in_b.stb.eq(1)
- b_ack = (yield dut.in_b.ack)
+
+ yield in_a.stb.eq(0)
+
+ yield in_b.v.eq(b)
+ yield in_b.stb.eq(1)
+ yield
+ yield
+ b_ack = (yield in_b.ack)
assert b_ack == 0
+ yield in_b.stb.eq(0)
+
+ yield out_z.ack.eq(1)
+
while True:
- yield
- out_z_stb = (yield dut.out_z.stb)
+ out_z_stb = (yield out_z.stb)
if not out_z_stb:
+ yield
continue
- yield dut.in_a.stb.eq(0)
- yield dut.in_b.stb.eq(0)
- yield dut.out_z.ack.eq(1)
- yield
- yield dut.out_z.ack.eq(0)
- yield
+ vout_z = yield out_z.v
+ #out_mid = yield dut.ids.out_mid
+ yield out_z.ack.eq(0)
yield
break
- out_z = yield dut.out_z.v
- return out_z
+ return vout_z, mid
-def check_case(dut, a, b, z):
- out_z = yield from get_case(dut, a, b)
+def check_case(dut, a, b, z, mid=None):
+ if mid is None:
+ mid = randint(0, 6)
+ mid = 0
+ out_z, out_mid = yield from get_case(dut, a, b, mid)
assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
+ assert out_mid == mid, "Output mid 0x%x != expected 0x%x" % (out_mid, mid)
def run_test(dut, stimulus_a, stimulus_b, op):
expected_responses = []
actual_responses = []
for a, b in zip(stimulus_a, stimulus_b):
+ mid = randint(0, 6)
+ mid = 0
af = Float32.from_bits(a)
bf = Float32.from_bits(b)
z = op(af, bf)
- expected_responses.append(z.get_bits())
+ expected_responses.append((z.get_bits(), mid))
#print (af, bf, z)
- actual = yield from get_case(dut, a, b)
+ actual = yield from get_case(dut, a, b, mid)
actual_responses.append(actual)
if len(actual_responses) < len(expected_responses):
for expected, actual, a, b in zip(expected_responses, actual_responses,
stimulus_a, stimulus_b):
- passed = match(expected, actual)
+ passed = match(expected[0], actual[0])
+ if expected[1] != actual[1]: # check mid
+ print ("MID failed", expected[1], actual[1])
+ sys.exit(0)
if not passed:
sys.exit(0)
+corner_cases = [0x80000000, 0x00000000, 0x7f800000, 0xff800000,
+ 0x7fc00000, 0xffc00000]
+
def run_corner_cases(dut, count, op):
#corner cases
from itertools import permutations
- stimulus_a = [i[0] for i in permutations([0x80000000, 0x00000000, 0x7f800000, 0xff800000, 0x7fc00000, 0xffc00000], 2)]
- stimulus_b = [i[1] for i in permutations([0x80000000, 0x00000000, 0x7f800000, 0xff800000, 0x7fc00000, 0xffc00000], 2)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
- count += len(stimulus_a)
- print (count, "vectors passed")
-
-
-def run_edge_cases(dut, count, op):
- #edge cases
- stimulus_a = [0x80000000 for i in range(1000)]
- stimulus_b = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
- count += len(stimulus_a)
- print (count, "vectors passed")
-
- stimulus_a = [0x00000000 for i in range(1000)]
- stimulus_b = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
- count += len(stimulus_a)
- print (count, "vectors passed")
-
- stimulus_b = [0x80000000 for i in range(1000)]
- stimulus_a = [randint(0, 1<<32) for i in range(1000)]
+ stimulus_a = [i[0] for i in permutations(corner_cases, 2)]
+ stimulus_b = [i[1] for i in permutations(corner_cases, 2)]
yield from run_test(dut, stimulus_a, stimulus_b, op)
count += len(stimulus_a)
print (count, "vectors passed")
- stimulus_b = [0x00000000 for i in range(1000)]
- stimulus_a = [randint(0, 1<<32) for i in range(1000)]
+def run_test_2(dut, stimulus_a, stimulus_b, op):
yield from run_test(dut, stimulus_a, stimulus_b, op)
+ yield from run_test(dut, stimulus_b, stimulus_a, op)
+
+def run_cases(dut, count, op, fixed_num, num_entries):
+ if isinstance(fixed_num, int):
+ stimulus_a = [fixed_num for i in range(num_entries)]
+ report = hex(fixed_num)
+ else:
+ stimulus_a = fixed_num
+ report = "random"
+
+ stimulus_b = [randint(0, 1<<32) for i in range(num_entries)]
+ yield from run_test_2(dut, stimulus_a, stimulus_b, op)
count += len(stimulus_a)
- print (count, "vectors passed")
+ print (count, "vectors passed 2^32", report)
- stimulus_a = [0x7F800000 for i in range(1000)]
- stimulus_b = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
+ # non-canonical NaNs.
+ stimulus_b = [set_exponent(randint(0, 1<<32), 128) \
+ for i in range(num_entries)]
+ yield from run_test_2(dut, stimulus_a, stimulus_b, op)
count += len(stimulus_a)
- print (count, "vectors passed")
+ print (count, "vectors passed Non-Canonical NaN", report)
- stimulus_a = [0xFF800000 for i in range(1000)]
- stimulus_b = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
+ # -127
+ stimulus_b = [set_exponent(randint(0, 1<<32), -127) \
+ for i in range(num_entries)]
+ yield from run_test_2(dut, stimulus_a, stimulus_b, op)
count += len(stimulus_a)
- print (count, "vectors passed")
+ print (count, "vectors passed exp=-127", report)
- stimulus_b = [0x7F800000 for i in range(1000)]
- stimulus_a = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
+ # nearly zero
+ stimulus_b = [set_exponent(randint(0, 1<<32), -126) \
+ for i in range(num_entries)]
+ yield from run_test_2(dut, stimulus_a, stimulus_b, op)
count += len(stimulus_a)
- print (count, "vectors passed")
+ print (count, "vectors passed exp=-126", report)
- stimulus_b = [0xFF800000 for i in range(1000)]
- stimulus_a = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
+ # nearly inf
+ stimulus_b = [set_exponent(randint(0, 1<<32), 127) \
+ for i in range(num_entries)]
+ yield from run_test_2(dut, stimulus_a, stimulus_b, op)
count += len(stimulus_a)
- print (count, "vectors passed")
+ print (count, "vectors passed exp=127", report)
- stimulus_a = [0x7FC00000 for i in range(1000)]
- stimulus_b = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
- count += len(stimulus_a)
- print (count, "vectors passed")
+ return count
- stimulus_a = [0xFFC00000 for i in range(1000)]
- stimulus_b = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
- count += len(stimulus_a)
- print (count, "vectors passed")
-
- stimulus_b = [0x7FC00000 for i in range(1000)]
- stimulus_a = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
- count += len(stimulus_a)
- print (count, "vectors passed")
-
- stimulus_b = [0xFFC00000 for i in range(1000)]
- stimulus_a = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
- count += len(stimulus_a)
- print (count, "vectors passed")
+def run_edge_cases(dut, count, op):
+ #edge cases
+ for testme in corner_cases:
+ count = yield from run_cases(dut, count, op, testme, 10)
- #seed(0)
for i in range(100000):
- stimulus_a = [randint(0, 1<<32) for i in range(1000)]
- stimulus_b = [randint(0, 1<<32) for i in range(1000)]
- yield from run_test(dut, stimulus_a, stimulus_b, op)
- count += 1000
- print (count, "random vectors passed")
-
-if __name__ == '__main__':
- dut = FPADD(width=32, single_cycle=True)
- run_simulation(dut, testbench(dut), vcd_name="test_add.vcd")
+ stimulus_a = [randint(0, 1<<32) for i in range(10)]
+ count = yield from run_cases(dut, count, op, stimulus_a, 10)
+ return count
projects / ieee754fpu.git / blobdiff