remove unneeded variable, use module overflow to get rounding signal

[ieee754fpu.git] / src / add / unit_test_single.py

diff --git a/src/add/unit_test_single.py b/src/add/unit_test_single.py
index a752189fca8e8deaf191d54172783ecc08773c83..3dba32ee0d3a24834d63f6037499bb7fffa5ff8e 100644 (file)
--- a/src/add/unit_test_single.py
+++ b/src/add/unit_test_single.py
@@ -10,6 +10,9 @@ def get_mantissa(x):
 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)
 
@@ -40,26 +43,30 @@ def get_case(dut, a, b):
     yield
     a_ack = (yield dut.in_a.ack)
     assert a_ack == 0
+
+    yield dut.in_a.stb.eq(0)
+
     yield dut.in_b.v.eq(b)
     yield dut.in_b.stb.eq(1)
+    yield
+    yield
     b_ack = (yield dut.in_b.ack)
     assert b_ack == 0
 
+    yield dut.in_b.stb.eq(0)
+
+    yield dut.out_z.ack.eq(1)
+
     while True:
-        yield
         out_z_stb = (yield dut.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
+        out_z = yield dut.out_z.v
         yield dut.out_z.ack.eq(0)
         yield
-        yield
         break
 
-    out_z = yield dut.out_z.v
     return out_z
 
 def check_case(dut, a, b, z):
@@ -114,99 +121,72 @@ def run_test(dut, stimulus_a, stimulus_b, op):
 
             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)]
+    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")
 
-
-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)]
+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 = [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)
+    # 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_b = [0x80000000 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)
+    # -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 = [0x00000000 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_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)
+    # 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 = [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)
-    count += len(stimulus_a)
-    print (count, "vectors passed")
+    return count
 
-    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)
-    count += len(stimulus_a)
-    print (count, "vectors passed")
-
-    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)
-    count += len(stimulus_a)
-    print (count, "vectors passed")
-
-    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")
-
-    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