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 set_exponent(x, e):
  14     return (x & ~0x7f800000) | ((e+127) << 23)
  15
  16 def get_sign(x):
  17     return ((x & 0x80000000) >> 31)
  18
  19 def is_nan(x):
  20     return get_exponent(x) == 128 and get_mantissa(x) != 0
  21
  22 def is_inf(x):
  23     return get_exponent(x) == 128 and get_mantissa(x) == 0
  24
  25 def is_pos_inf(x):
  26     return is_inf(x) and not get_sign(x)
  27
  28 def is_neg_inf(x):
  29     return is_inf(x) and get_sign(x)
  30
  31 def match(x, y):
  32     return (
  33         (is_pos_inf(x) and is_pos_inf(y)) or
  34         (is_neg_inf(x) and is_neg_inf(y)) or
  35         (is_nan(x) and is_nan(y)) or
  36         (x == y)
  37         )
  38
  39 def get_case(dut, a, b):
  40     yield dut.in_a.v.eq(a)
  41     yield dut.in_a.stb.eq(1)
  42     yield
  43     yield
  44     a_ack = (yield dut.in_a.ack)
  45     assert a_ack == 0
  46     yield dut.in_b.v.eq(b)
  47     yield dut.in_b.stb.eq(1)
  48     b_ack = (yield dut.in_b.ack)
  49     assert b_ack == 0
  50
  51     while True:
  52         yield
  53         out_z_stb = (yield dut.out_z.stb)
  54         if not out_z_stb:
  55             continue
  56         yield dut.in_a.stb.eq(0)
  57         yield dut.in_b.stb.eq(0)
  58         yield dut.out_z.ack.eq(1)
  59         yield
  60         yield dut.out_z.ack.eq(0)
  61         yield
  62         yield
  63         break
  64
  65     out_z = yield dut.out_z.v
  66     return out_z
  67
  68 def check_case(dut, a, b, z):
  69     out_z = yield from get_case(dut, a, b)
  70     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
  71
  72
  73 def run_test(dut, stimulus_a, stimulus_b, op):
  74
  75     expected_responses = []
  76     actual_responses = []
  77     for a, b in zip(stimulus_a, stimulus_b):
  78         af = Float32.from_bits(a)
  79         bf = Float32.from_bits(b)
  80         z = op(af, bf)
  81         expected_responses.append(z.get_bits())
  82         #print (af, bf, z)
  83         actual = yield from get_case(dut, a, b)
  84         actual_responses.append(actual)
  85
  86     if len(actual_responses) < len(expected_responses):
  87         print ("Fail ... not enough results")
  88         exit(0)
  89
  90     for expected, actual, a, b in zip(expected_responses, actual_responses,
  91                                       stimulus_a, stimulus_b):
  92         passed = match(expected, actual)
  93
  94         if not passed:
  95
  96             print ("Fail ... expected:", hex(expected), "actual:", hex(actual))
  97
  98             print (hex(a))
  99             print ("a mantissa:", a & 0x7fffff)
 100             print ("a exponent:", ((a & 0x7f800000) >> 23) - 127)
 101             print ("a sign:", ((a & 0x80000000) >> 31))
 102
 103             print (hex(b))
 104             print ("b mantissa:", b & 0x7fffff)
 105             print ("b exponent:", ((b & 0x7f800000) >> 23) - 127)
 106             print ("b sign:", ((b & 0x80000000) >> 31))
 107
 108             print (hex(expected))
 109             print ("expected mantissa:", expected & 0x7fffff)
 110             print ("expected exponent:", ((expected & 0x7f800000) >> 23) - 127)
 111             print ("expected sign:", ((expected & 0x80000000) >> 31))
 112
 113             print (hex(actual))
 114             print ("actual mantissa:", actual & 0x7fffff)
 115             print ("actual exponent:", ((actual & 0x7f800000) >> 23) - 127)
 116             print ("actual sign:", ((actual & 0x80000000) >> 31))
 117
 118             sys.exit(0)
 119
 120 corner_cases = [0x80000000, 0x00000000, 0x7f800000, 0xff800000,
 121                 0x7fc00000, 0xffc00000]
 122
 123 def run_corner_cases(dut, count, op):
 124     #corner cases
 125     from itertools import permutations
 126     stimulus_a = [i[0] for i in permutations(corner_cases, 2)]
 127     stimulus_b = [i[1] for i in permutations(corner_cases, 2)]
 128     yield from run_test(dut, stimulus_a, stimulus_b, op)
 129     count += len(stimulus_a)
 130     print (count, "vectors passed")
 131
 132 def run_test_2(dut, stimulus_a, stimulus_b, op):
 133     yield from run_test(dut, stimulus_a, stimulus_b, op)
 134     yield from run_test(dut, stimulus_b, stimulus_a, op)
 135
 136 def run_cases(dut, count, op, fixed_num, num_entries):
 137     if isinstance(fixed_num, int):
 138         stimulus_a = [fixed_num for i in range(num_entries)]
 139         report = hex(fixed_num)
 140     else:
 141         stimulus_a = fixed_num
 142         report = "random"
 143
 144     stimulus_b = [randint(0, 1<<32) for i in range(num_entries)]
 145     yield from run_test_2(dut, stimulus_a, stimulus_b, op)
 146     count += len(stimulus_a)
 147     print (count, "vectors passed 2^32", report)
 148
 149     # non-canonical NaNs.
 150     stimulus_b = [set_exponent(randint(0, 1<<32), 128) \
 151                         for i in range(num_entries)]
 152     yield from run_test_2(dut, stimulus_a, stimulus_b, op)
 153     count += len(stimulus_a)
 154     print (count, "vectors passed Non-Canonical NaN", report)
 155
 156     # -127
 157     stimulus_b = [set_exponent(randint(0, 1<<32), -127) \
 158                         for i in range(num_entries)]
 159     yield from run_test_2(dut, stimulus_a, stimulus_b, op)
 160     count += len(stimulus_a)
 161     print (count, "vectors passed exp=-127", report)
 162
 163     # nearly zero
 164     stimulus_b = [set_exponent(randint(0, 1<<32), -126) \
 165                         for i in range(num_entries)]
 166     yield from run_test_2(dut, stimulus_a, stimulus_b, op)
 167     count += len(stimulus_a)
 168     print (count, "vectors passed exp=-126", report)
 169
 170     # nearly inf
 171     stimulus_b = [set_exponent(randint(0, 1<<32), 127) \
 172                         for i in range(num_entries)]
 173     yield from run_test_2(dut, stimulus_a, stimulus_b, op)
 174     count += len(stimulus_a)
 175     print (count, "vectors passed exp=127", report)
 176
 177     return count
 178
 179 def run_edge_cases(dut, count, op):
 180     #edge cases
 181     for testme in corner_cases:
 182         count = yield from run_cases(dut, count, op, testme, 1000)
 183
 184     for i in range(100000):
 185         stimulus_a = [randint(0, 1<<32) for i in range(1000)]
 186         count = yield from run_cases(dut, count, op, stimulus_a, 1000)
 187     return count
 188