src/add/test_add.py

   1 import sys
   2 import subprocess
   3 from random import randint
   4 from random import seed
   5 from sfpy import Float32
   6
   7 from nmigen import Module, Signal
   8 from nmigen.compat.sim import run_simulation
   9
  10 from nmigen_add_experiment import FPADD
  11
  12 def get_mantissa(x):
  13     return 0x7fffff & x
  14
  15 def get_exponent(x):
  16     return ((x & 0x7f800000) >> 23) - 127
  17
  18 def get_sign(x):
  19     return ((x & 0x80000000) >> 31)
  20
  21 def is_nan(x):
  22     return get_exponent(x) == 128 and get_mantissa(x) != 0
  23
  24 def is_inf(x):
  25     return get_exponent(x) == 128 and get_mantissa(x) == 0
  26
  27 def is_pos_inf(x):
  28     return is_inf(x) and not get_sign(x)
  29
  30 def is_neg_inf(x):
  31     return is_inf(x) and get_sign(x)
  32
  33 def match(x, y):
  34     return (
  35         (is_pos_inf(x) and is_pos_inf(y)) or
  36         (is_neg_inf(x) and is_neg_inf(y)) or
  37         (is_nan(x) and is_nan(y)) or
  38         (x == y)
  39         )
  40
  41 def get_case(dut, a, b):
  42     yield dut.in_a.v.eq(a)
  43     yield dut.in_a.stb.eq(1)
  44     yield
  45     yield
  46     a_ack = (yield dut.in_a.ack)
  47     assert a_ack == 0
  48     yield dut.in_b.v.eq(b)
  49     yield dut.in_b.stb.eq(1)
  50     b_ack = (yield dut.in_b.ack)
  51     assert b_ack == 0
  52
  53     while True:
  54         yield
  55         out_z_stb = (yield dut.out_z.stb)
  56         if not out_z_stb:
  57             continue
  58         yield dut.in_a.stb.eq(0)
  59         yield dut.in_b.stb.eq(0)
  60         yield dut.out_z.ack.eq(1)
  61         yield
  62         yield dut.out_z.ack.eq(0)
  63         yield
  64         yield
  65         break
  66
  67     out_z = yield dut.out_z.v
  68     return out_z
  69
  70 def check_case(dut, a, b, z):
  71     out_z = yield from get_case(dut, a, b)
  72     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
  73
  74
  75 def run_test(dut, stimulus_a, stimulus_b):
  76
  77     expected_responses = []
  78     actual_responses = []
  79     for a, b in zip(stimulus_a, stimulus_b):
  80         af = Float32.from_bits(a)
  81         bf = Float32.from_bits(b)
  82         z = af + bf
  83         expected_responses.append(z.get_bits())
  84         #print (af, bf, z)
  85         actual = yield from get_case(dut, a, b)
  86         actual_responses.append(actual)
  87
  88     if len(actual_responses) < len(expected_responses):
  89         print ("Fail ... not enough results")
  90         exit(0)
  91
  92     for expected, actual, a, b in zip(expected_responses, actual_responses,
  93                                       stimulus_a, stimulus_b):
  94         passed = match(expected, actual)
  95
  96         if not passed:
  97
  98             print ("Fail ... expected:", hex(expected), "actual:", hex(actual))
  99
 100             print (hex(a))
 101             print ("a mantissa:", a & 0x7fffff)
 102             print ("a exponent:", ((a & 0x7f800000) >> 23) - 127)
 103             print ("a sign:", ((a & 0x80000000) >> 31))
 104
 105             print (hex(b))
 106             print ("b mantissa:", b & 0x7fffff)
 107             print ("b exponent:", ((b & 0x7f800000) >> 23) - 127)
 108             print ("b sign:", ((b & 0x80000000) >> 31))
 109
 110             print (hex(expected))
 111             print ("expected mantissa:", expected & 0x7fffff)
 112             print ("expected exponent:", ((expected & 0x7f800000) >> 23) - 127)
 113             print ("expected sign:", ((expected & 0x80000000) >> 31))
 114
 115             print (hex(actual))
 116             print ("actual mantissa:", actual & 0x7fffff)
 117             print ("actual exponent:", ((actual & 0x7f800000) >> 23) - 127)
 118             print ("actual sign:", ((actual & 0x80000000) >> 31))
 119
 120             sys.exit(0)
 121
 122 def testbench(dut):
 123     yield from check_case(dut, 0x82471f51, 0x243985f, 0x801c3790)
 124     yield from check_case(dut, 0, 0, 0)
 125     yield from check_case(dut, 0x40000000, 0xc0000000, 0x00000000)
 126     yield from check_case(dut, 0x3F800000, 0x40000000, 0x40400000)
 127     yield from check_case(dut, 0x40000000, 0x3F800000, 0x40400000)
 128     yield from check_case(dut, 0x447A0000, 0x4488B000, 0x4502D800)
 129     yield from check_case(dut, 0x463B800A, 0x42BA8A3D, 0x463CF51E)
 130     yield from check_case(dut, 0x42BA8A3D, 0x463B800A, 0x463CF51E)
 131     yield from check_case(dut, 0x463B800A, 0xC2BA8A3D, 0x463A0AF6)
 132     yield from check_case(dut, 0xC2BA8A3D, 0x463B800A, 0x463A0AF6)
 133     yield from check_case(dut, 0xC63B800A, 0x42BA8A3D, 0xC63A0AF6)
 134     yield from check_case(dut, 0x42BA8A3D, 0xC63B800A, 0xC63A0AF6)
 135     yield from check_case(dut, 0xFFFFFFFF, 0xC63B800A, 0xFFC00000)
 136     yield from check_case(dut, 0x7F800000, 0x00000000, 0x7F800000)
 137     yield from check_case(dut, 0x00000000, 0x7F800000, 0x7F800000)
 138     yield from check_case(dut, 0xFF800000, 0x00000000, 0xFF800000)
 139     yield from check_case(dut, 0x00000000, 0xFF800000, 0xFF800000)
 140     yield from check_case(dut, 0x7F800000, 0x7F800000, 0x7F800000)
 141     yield from check_case(dut, 0xFF800000, 0xFF800000, 0xFF800000)
 142     yield from check_case(dut, 0x7F800000, 0xFF800000, 0xFFC00000)
 143     yield from check_case(dut, 0xFF800000, 0x7F800000, 0x7FC00000)
 144     yield from check_case(dut, 0x00018643, 0x00FA72A4, 0x00FBF8E7)
 145     yield from check_case(dut, 0x001A2239, 0x00FA72A4, 0x010A4A6E)
 146     yield from check_case(dut, 0x3F7FFFFE, 0x3F7FFFFE, 0x3FFFFFFE)
 147     yield from check_case(dut, 0x7EFFFFEE, 0x7EFFFFEE, 0x7F7FFFEE)
 148     yield from check_case(dut, 0x7F7FFFEE, 0xFEFFFFEE, 0x7EFFFFEE)
 149     yield from check_case(dut, 0x7F7FFFEE, 0x756CA884, 0x7F7FFFFD)
 150     yield from check_case(dut, 0x7F7FFFEE, 0x758A0CF8, 0x7F7FFFFF)
 151     yield from check_case(dut, 0x42500000, 0x51A7A358, 0x51A7A358)
 152     yield from check_case(dut, 0x51A7A358, 0x42500000, 0x51A7A358)
 153     yield from check_case(dut, 0x4E5693A4, 0x42500000, 0x4E5693A5)
 154     yield from check_case(dut, 0x42500000, 0x4E5693A4, 0x4E5693A5)
 155     #yield from check_case(dut, 1, 0, 1)
 156     #yield from check_case(dut, 1, 1, 1)
 157
 158     count = 0
 159
 160     #regression tests
 161     stimulus_a = [0x22cb525a, 0x40000000, 0x83e73d5c, 0xbf9b1e94, 0x34082401, 0x5e8ef81, 0x5c75da81, 0x2b017]
 162     stimulus_b = [0xadd79efa, 0xC0000000, 0x1c800000, 0xc038ed3a, 0xb328cd45, 0x114f3db, 0x2f642a39, 0xff3807ab]
 163     yield from run_test(dut, stimulus_a, stimulus_b)
 164     count += len(stimulus_a)
 165     print (count, "vectors passed")
 166
 167     #corner cases
 168     from itertools import permutations
 169     stimulus_a = [i[0] for i in permutations([0x80000000, 0x00000000, 0x7f800000, 0xff800000, 0x7fc00000, 0xffc00000], 2)]
 170     stimulus_b = [i[1] for i in permutations([0x80000000, 0x00000000, 0x7f800000, 0xff800000, 0x7fc00000, 0xffc00000], 2)]
 171     yield from run_test(dut, stimulus_a, stimulus_b)
 172     count += len(stimulus_a)
 173     print (count, "vectors passed")
 174
 175     #edge cases
 176     stimulus_a = [0x80000000 for i in range(1000)]
 177     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 178     yield from run_test(dut, stimulus_a, stimulus_b)
 179     count += len(stimulus_a)
 180     print (count, "vectors passed")
 181
 182     stimulus_a = [0x00000000 for i in range(1000)]
 183     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 184     yield from run_test(dut, stimulus_a, stimulus_b)
 185     count += len(stimulus_a)
 186     print (count, "vectors passed")
 187
 188     stimulus_b = [0x80000000 for i in range(1000)]
 189     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 190     yield from run_test(dut, stimulus_a, stimulus_b)
 191     count += len(stimulus_a)
 192     print (count, "vectors passed")
 193
 194     stimulus_b = [0x00000000 for i in range(1000)]
 195     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 196     yield from run_test(dut, stimulus_a, stimulus_b)
 197     count += len(stimulus_a)
 198     print (count, "vectors passed")
 199
 200     stimulus_a = [0x7F800000 for i in range(1000)]
 201     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 202     yield from run_test(dut, stimulus_a, stimulus_b)
 203     count += len(stimulus_a)
 204     print (count, "vectors passed")
 205
 206     stimulus_a = [0xFF800000 for i in range(1000)]
 207     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 208     yield from run_test(dut, stimulus_a, stimulus_b)
 209     count += len(stimulus_a)
 210     print (count, "vectors passed")
 211
 212     stimulus_b = [0x7F800000 for i in range(1000)]
 213     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 214     yield from run_test(dut, stimulus_a, stimulus_b)
 215     count += len(stimulus_a)
 216     print (count, "vectors passed")
 217
 218     stimulus_b = [0xFF800000 for i in range(1000)]
 219     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 220     yield from run_test(dut, stimulus_a, stimulus_b)
 221     count += len(stimulus_a)
 222     print (count, "vectors passed")
 223
 224     stimulus_a = [0x7FC00000 for i in range(1000)]
 225     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 226     yield from run_test(dut, stimulus_a, stimulus_b)
 227     count += len(stimulus_a)
 228     print (count, "vectors passed")
 229
 230     stimulus_a = [0xFFC00000 for i in range(1000)]
 231     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 232     yield from run_test(dut, stimulus_a, stimulus_b)
 233     count += len(stimulus_a)
 234     print (count, "vectors passed")
 235
 236     stimulus_b = [0x7FC00000 for i in range(1000)]
 237     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 238     yield from run_test(dut, stimulus_a, stimulus_b)
 239     count += len(stimulus_a)
 240     print (count, "vectors passed")
 241
 242     stimulus_b = [0xFFC00000 for i in range(1000)]
 243     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 244     yield from run_test(dut, stimulus_a, stimulus_b)
 245     count += len(stimulus_a)
 246     print (count, "vectors passed")
 247
 248     #seed(0)
 249     for i in range(100000):
 250         stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 251         stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 252         yield from run_test(dut, stimulus_a, stimulus_b)
 253         count += 1000
 254         print (count, "vectors passed")
 255
 256 if __name__ == '__main__':
 257     dut = FPADD(width=32, single_cycle=True)
 258     run_simulation(dut, testbench(dut), vcd_name="test_add.vcd")
 259