src/add/unit_test_single.py

   1 from random import randint
   2 from random import seed
   3
   4 import sys
   5 from sfpy import Float32
   6
   7 def get_mantissa(x):
   8     return 0x7fffff & x
   9
  10 def get_exponent(x):
  11     return ((x & 0x7f800000) >> 23) - 127
  12
  13 def get_sign(x):
  14     return ((x & 0x80000000) >> 31)
  15
  16 def is_nan(x):
  17     return get_exponent(x) == 128 and get_mantissa(x) != 0
  18
  19 def is_inf(x):
  20     return get_exponent(x) == 128 and get_mantissa(x) == 0
  21
  22 def is_pos_inf(x):
  23     return is_inf(x) and not get_sign(x)
  24
  25 def is_neg_inf(x):
  26     return is_inf(x) and get_sign(x)
  27
  28 def match(x, y):
  29     return (
  30         (is_pos_inf(x) and is_pos_inf(y)) or
  31         (is_neg_inf(x) and is_neg_inf(y)) or
  32         (is_nan(x) and is_nan(y)) or
  33         (x == y)
  34         )
  35
  36 def get_case(dut, a, b):
  37     yield dut.in_a.v.eq(a)
  38     yield dut.in_a.stb.eq(1)
  39     yield
  40     yield
  41     a_ack = (yield dut.in_a.ack)
  42     assert a_ack == 0
  43     yield dut.in_b.v.eq(b)
  44     yield dut.in_b.stb.eq(1)
  45     b_ack = (yield dut.in_b.ack)
  46     assert b_ack == 0
  47
  48     while True:
  49         yield
  50         out_z_stb = (yield dut.out_z.stb)
  51         if not out_z_stb:
  52             continue
  53         yield dut.in_a.stb.eq(0)
  54         yield dut.in_b.stb.eq(0)
  55         yield dut.out_z.ack.eq(1)
  56         yield
  57         yield dut.out_z.ack.eq(0)
  58         yield
  59         yield
  60         break
  61
  62     out_z = yield dut.out_z.v
  63     return out_z
  64
  65 def check_case(dut, a, b, z):
  66     out_z = yield from get_case(dut, a, b)
  67     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
  68
  69
  70 def run_test(dut, stimulus_a, stimulus_b, op):
  71
  72     expected_responses = []
  73     actual_responses = []
  74     for a, b in zip(stimulus_a, stimulus_b):
  75         af = Float32.from_bits(a)
  76         bf = Float32.from_bits(b)
  77         z = op(af, bf)
  78         expected_responses.append(z.get_bits())
  79         #print (af, bf, z)
  80         actual = yield from get_case(dut, a, b)
  81         actual_responses.append(actual)
  82
  83     if len(actual_responses) < len(expected_responses):
  84         print ("Fail ... not enough results")
  85         exit(0)
  86
  87     for expected, actual, a, b in zip(expected_responses, actual_responses,
  88                                       stimulus_a, stimulus_b):
  89         passed = match(expected, actual)
  90
  91         if not passed:
  92
  93             print ("Fail ... expected:", hex(expected), "actual:", hex(actual))
  94
  95             print (hex(a))
  96             print ("a mantissa:", a & 0x7fffff)
  97             print ("a exponent:", ((a & 0x7f800000) >> 23) - 127)
  98             print ("a sign:", ((a & 0x80000000) >> 31))
  99
 100             print (hex(b))
 101             print ("b mantissa:", b & 0x7fffff)
 102             print ("b exponent:", ((b & 0x7f800000) >> 23) - 127)
 103             print ("b sign:", ((b & 0x80000000) >> 31))
 104
 105             print (hex(expected))
 106             print ("expected mantissa:", expected & 0x7fffff)
 107             print ("expected exponent:", ((expected & 0x7f800000) >> 23) - 127)
 108             print ("expected sign:", ((expected & 0x80000000) >> 31))
 109
 110             print (hex(actual))
 111             print ("actual mantissa:", actual & 0x7fffff)
 112             print ("actual exponent:", ((actual & 0x7f800000) >> 23) - 127)
 113             print ("actual sign:", ((actual & 0x80000000) >> 31))
 114
 115             sys.exit(0)
 116
 117 def run_corner_cases(dut, count, op):
 118     #corner cases
 119     from itertools import permutations
 120     stimulus_a = [i[0] for i in permutations([0x80000000, 0x00000000, 0x7f800000, 0xff800000, 0x7fc00000, 0xffc00000], 2)]
 121     stimulus_b = [i[1] for i in permutations([0x80000000, 0x00000000, 0x7f800000, 0xff800000, 0x7fc00000, 0xffc00000], 2)]
 122     yield from run_test(dut, stimulus_a, stimulus_b, op)
 123     count += len(stimulus_a)
 124     print (count, "vectors passed")
 125
 126
 127 def run_edge_cases(dut, count, op):
 128     #edge cases
 129     stimulus_a = [0x80000000 for i in range(1000)]
 130     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 131     yield from run_test(dut, stimulus_a, stimulus_b, op)
 132     count += len(stimulus_a)
 133     print (count, "vectors passed")
 134
 135     stimulus_a = [0x00000000 for i in range(1000)]
 136     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 137     yield from run_test(dut, stimulus_a, stimulus_b, op)
 138     count += len(stimulus_a)
 139     print (count, "vectors passed")
 140
 141     stimulus_b = [0x80000000 for i in range(1000)]
 142     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 143     yield from run_test(dut, stimulus_a, stimulus_b, op)
 144     count += len(stimulus_a)
 145     print (count, "vectors passed")
 146
 147     stimulus_b = [0x00000000 for i in range(1000)]
 148     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 149     yield from run_test(dut, stimulus_a, stimulus_b, op)
 150     count += len(stimulus_a)
 151     print (count, "vectors passed")
 152
 153     stimulus_a = [0x7F800000 for i in range(1000)]
 154     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 155     yield from run_test(dut, stimulus_a, stimulus_b, op)
 156     count += len(stimulus_a)
 157     print (count, "vectors passed")
 158
 159     stimulus_a = [0xFF800000 for i in range(1000)]
 160     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 161     yield from run_test(dut, stimulus_a, stimulus_b, op)
 162     count += len(stimulus_a)
 163     print (count, "vectors passed")
 164
 165     stimulus_b = [0x7F800000 for i in range(1000)]
 166     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 167     yield from run_test(dut, stimulus_a, stimulus_b, op)
 168     count += len(stimulus_a)
 169     print (count, "vectors passed")
 170
 171     stimulus_b = [0xFF800000 for i in range(1000)]
 172     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 173     yield from run_test(dut, stimulus_a, stimulus_b, op)
 174     count += len(stimulus_a)
 175     print (count, "vectors passed")
 176
 177     stimulus_a = [0x7FC00000 for i in range(1000)]
 178     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 179     yield from run_test(dut, stimulus_a, stimulus_b, op)
 180     count += len(stimulus_a)
 181     print (count, "vectors passed")
 182
 183     stimulus_a = [0xFFC00000 for i in range(1000)]
 184     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 185     yield from run_test(dut, stimulus_a, stimulus_b, op)
 186     count += len(stimulus_a)
 187     print (count, "vectors passed")
 188
 189     stimulus_b = [0x7FC00000 for i in range(1000)]
 190     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 191     yield from run_test(dut, stimulus_a, stimulus_b, op)
 192     count += len(stimulus_a)
 193     print (count, "vectors passed")
 194
 195     stimulus_b = [0xFFC00000 for i in range(1000)]
 196     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 197     yield from run_test(dut, stimulus_a, stimulus_b, op)
 198     count += len(stimulus_a)
 199     print (count, "vectors passed")
 200
 201     #seed(0)
 202     for i in range(100000):
 203         stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 204         stimulus_b = [randint(0, 1<<32) for i in range(1000)]
 205         yield from run_test(dut, stimulus_a, stimulus_b, op)
 206         count += 1000
 207         print (count, "random vectors passed")
 208
 209 if __name__ == '__main__':
 210     dut = FPADD(width=32, single_cycle=True)
 211     run_simulation(dut, testbench(dut), vcd_name="test_add.vcd")
 212