src/add/test_add64.py

   1 from nmigen import Module, Signal
   2 from nmigen.compat.sim import run_simulation
   3 from sfpy import Float64
   4
   5 from nmigen_add_experiment import FPADD
   6
   7 import sys
   8 import atexit
   9 from random import randint
  10 from random import seed
  11
  12 def get_mantissa(x):
  13     return x & 0x000fffffffffffff
  14
  15 def get_exponent(x):
  16     return ((x & 0x7ff0000000000000) >> 52) - 1023
  17
  18 def get_sign(x):
  19     return ((x & 0x8000000000000000) >> 63)
  20
  21 def is_nan(x):
  22     return get_exponent(x) == 1024 and get_mantissa(x) != 0
  23
  24 def is_inf(x):
  25     return get_exponent(x) == 1024 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 = Float64.from_bits(a)
  81         bf = Float64.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 exp, act, a, b in zip(expected_responses, actual_responses,
  93                                       stimulus_a, stimulus_b):
  94         passed = match(exp, act)
  95
  96         if not passed:
  97
  98             print ("Fail ... expected:", hex(exp), "actual:", hex(act))
  99
 100             print (hex(a))
 101             print ("a mantissa:",              a & 0x000fffffffffffff)
 102             print ("a exponent:",            ((a & 0x7ff0000000000000) >> 52)\
 103                                                 - 1023)
 104             print ("a sign:",                ((a & 0x8000000000000000) >> 63))
 105
 106             print (hex(b))
 107             print ("b mantissa:",              b & 0x000fffffffffffff)
 108             print ("b exponent:",            ((b & 0x7ff0000000000000) >> 52)\
 109                                                  - 1023)
 110             print ("b sign:",                ((b & 0x8000000000000000) >> 63))
 111
 112             print (hex(exp))
 113             print ("expected mantissa:",   exp & 0x000fffffffffffff)
 114             print ("expected exponent:", ((exp & 0x7ff0000000000000) >> 52)\
 115                                                  - 1023)
 116             print ("expected sign:",     ((exp & 0x8000000000000000) >> 63))
 117
 118             print (hex(act))
 119             print ("actual mantissa:",       act & 0x000fffffffffffff)
 120             print ("actual exponent:",     ((act & 0x7ff0000000000000) >> 52)\
 121                                                  - 1023)
 122             print ("actual sign:",         ((act & 0x8000000000000000) >> 63))
 123
 124             sys.exit(0)
 125
 126 def testbench(dut):
 127     yield from check_case(dut, 0, 0, 0)
 128     yield from check_case(dut, 0x3FF0000000000000, 0x4000000000000000,
 129                                0x4008000000000000)
 130     yield from check_case(dut, 0x4000000000000000, 0x3FF0000000000000,
 131                                0x4008000000000000)
 132     yield from check_case(dut, 0x4056C00000000000, 0x4042800000000000,
 133                                0x4060000000000000)
 134     yield from check_case(dut, 0x4056C00000000000, 0x4042EA3D70A3D70A,
 135                                0x40601A8F5C28F5C2)
 136
 137     count = 0
 138
 139     #regression tests
 140     stimulus_a = [0x3ff00000000000c5, 0xff80000000000000]
 141     stimulus_b = [0xbd28a404211fb72b, 0x7f80000000000000]
 142     yield from run_test(dut, stimulus_a, stimulus_b)
 143     count += len(stimulus_a)
 144     print (count, "vectors passed")
 145
 146     #corner cases
 147     from itertools import permutations
 148     stimulus_a = [i[0] for i in permutations([
 149         0x8000000000000000,
 150         0x0000000000000000,
 151         0x7ff8000000000000,
 152         0xfff8000000000000,
 153         0x7ff0000000000000,
 154         0xfff0000000000000
 155     ], 2)]
 156     stimulus_b = [i[1] for i in permutations([
 157         0x8000000000000000,
 158         0x0000000000000000,
 159         0x7ff8000000000000,
 160         0xfff8000000000000,
 161         0x7ff0000000000000,
 162         0xfff0000000000000
 163     ], 2)]
 164     yield from run_test(dut, stimulus_a, stimulus_b)
 165     count += len(stimulus_a)
 166     print (count, "vectors passed")
 167
 168     #edge cases
 169     stimulus_a = [0x8000000000000000 for i in range(1000)]
 170     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
 171     yield from run_test(dut, stimulus_a, stimulus_b)
 172     count += len(stimulus_a)
 173     print (count, "vectors passed")
 174
 175     stimulus_a = [0x0000000000000000 for i in range(1000)]
 176     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
 177     yield from run_test(dut, stimulus_a, stimulus_b)
 178     count += len(stimulus_a)
 179     print (count, "vectors passed")
 180
 181     stimulus_b = [0x8000000000000000 for i in range(1000)]
 182     stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
 183     yield from run_test(dut, stimulus_a, stimulus_b)
 184     count += len(stimulus_a)
 185     print (count, "vectors passed")
 186
 187     stimulus_b = [0x0000000000000000 for i in range(1000)]
 188     stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
 189     yield from run_test(dut, stimulus_a, stimulus_b)
 190     count += len(stimulus_a)
 191     print (count, "vectors passed")
 192
 193     stimulus_a = [0x7FF8000000000000 for i in range(1000)]
 194     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
 195     yield from run_test(dut, stimulus_a, stimulus_b)
 196     count += len(stimulus_a)
 197     print (count, "vectors passed")
 198
 199     stimulus_a = [0xFFF8000000000000 for i in range(1000)]
 200     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
 201     yield from run_test(dut, stimulus_a, stimulus_b)
 202     count += len(stimulus_a)
 203     print (count, "vectors passed")
 204
 205     stimulus_b = [0x7FF8000000000000 for i in range(1000)]
 206     stimulus_a = [randint(0, 1<<64) for i in range(1000)]
 207     yield from run_test(dut, stimulus_a, stimulus_b)
 208     count += len(stimulus_a)
 209     print (count, "vectors passed")
 210
 211     stimulus_b = [0xFFF8000000000000 for i in range(1000)]
 212     stimulus_a = [randint(0, 1<<64) for i in range(1000)]
 213     yield from run_test(dut, stimulus_a, stimulus_b)
 214     count += len(stimulus_a)
 215     print (count, "vectors passed")
 216
 217     stimulus_a = [0x7FF0000000000000 for i in range(1000)]
 218     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
 219     yield from run_test(dut, stimulus_a, stimulus_b)
 220     count += len(stimulus_a)
 221     print (count, "vectors passed")
 222
 223     stimulus_a = [0xFFF0000000000000 for i in range(1000)]
 224     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
 225     yield from run_test(dut, stimulus_a, stimulus_b)
 226     count += len(stimulus_a)
 227     print (count, "vectors passed")
 228
 229     stimulus_b = [0x7FF0000000000000 for i in range(1000)]
 230     stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
 231     yield from run_test(dut, stimulus_a, stimulus_b)
 232     count += len(stimulus_a)
 233     print (count, "vectors passed")
 234
 235     stimulus_b = [0xFFF0000000000000 for i in range(1000)]
 236     stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
 237     yield from run_test(dut, stimulus_a, stimulus_b)
 238     count += len(stimulus_a)
 239     print (count, "vectors passed")
 240
 241     #seed(0)
 242     for i in range(100000):
 243         stimulus_a = [randint(0, 1<<64) for i in range(1000)]
 244         stimulus_b = [randint(0, 1<<64) for i in range(1000)]
 245         yield from run_test(dut, stimulus_a, stimulus_b)
 246         count += 1000
 247         print (count, "random vectors passed")
 248
 249
 250 if __name__ == '__main__':
 251     dut = FPADD(width=64, single_cycle=True)
 252     run_simulation(dut, testbench(dut), vcd_name="test_add64.vcd")
 253