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_rs_case(dut, a, b, mid):
  40     in_a, in_b = dut.rs[0]
  41     out_z = dut.res[0]
  42     yield dut.ids.in_mid.eq(mid)
  43     yield in_a.v.eq(a)
  44     yield in_a.valid_i.eq(1)
  45     yield
  46     yield
  47     yield
  48     yield
  49     a_ack = (yield in_a.ready_o)
  50     assert a_ack == 0
  51
  52     yield in_a.valid_i.eq(0)
  53
  54     yield in_b.v.eq(b)
  55     yield in_b.valid_i.eq(1)
  56     yield
  57     yield
  58     b_ack = (yield in_b.ready_o)
  59     assert b_ack == 0
  60
  61     yield in_b.valid_i.eq(0)
  62
  63     yield out_z.ready_i.eq(1)
  64
  65     while True:
  66         out_z_stb = (yield out_z.valid_o)
  67         if not out_z_stb:
  68             yield
  69             continue
  70         vout_z = yield out_z.v
  71         #out_mid = yield dut.ids.out_mid
  72         yield out_z.ready_i.eq(0)
  73         yield
  74         break
  75
  76     return vout_z, mid
  77
  78 def check_rs_case(dut, a, b, z, mid=None):
  79     if mid is None:
  80         mid = randint(0, 6)
  81     mid = 0
  82     out_z, out_mid = yield from get_rs_case(dut, a, b, mid)
  83     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
  84     assert out_mid == mid, "Output mid 0x%x != expected 0x%x" % (out_mid, mid)
  85
  86
  87 def get_case(dut, a, b, mid):
  88     #yield dut.in_mid.eq(mid)
  89     yield dut.in_a.v.eq(a)
  90     yield dut.in_a.valid_i_test.eq(1)
  91     yield
  92     yield
  93     yield
  94     yield
  95     a_ack = (yield dut.in_a.ready_o)
  96     assert a_ack == 0
  97
  98     yield dut.in_a.valid_i.eq(0)
  99
 100     yield dut.in_b.v.eq(b)
 101     yield dut.in_b.valid_i.eq(1)
 102     yield
 103     yield
 104     b_ack = (yield dut.in_b.ready_o)
 105     assert b_ack == 0
 106
 107     yield dut.in_b.valid_i.eq(0)
 108
 109     yield dut.out_z.ready_i.eq(1)
 110
 111     while True:
 112         out_z_stb = (yield dut.out_z.valid_o)
 113         if not out_z_stb:
 114             yield
 115             continue
 116         out_z = yield dut.out_z.v
 117         #out_mid = yield dut.out_mid
 118         yield dut.out_z.ready_i.eq(0)
 119         yield
 120         break
 121
 122     return out_z, mid # TODO: mid
 123
 124 def check_case(dut, a, b, z, mid=None):
 125     if mid is None:
 126         mid = randint(0, 6)
 127     mid = 0
 128     out_z, out_mid = yield from get_case(dut, a, b, mid)
 129     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
 130     assert out_mid == mid, "Output mid 0x%x != expected 0x%x" % (out_mid, mid)
 131
 132
 133 def run_test(dut, stimulus_a, stimulus_b, op, get_case_fn):
 134
 135     expected_responses = []
 136     actual_responses = []
 137     for a, b in zip(stimulus_a, stimulus_b):
 138         mid = randint(0, 6)
 139         mid = 0
 140         af = Float32.from_bits(a)
 141         bf = Float32.from_bits(b)
 142         z = op(af, bf)
 143         expected_responses.append((z.get_bits(), mid))
 144         actual = yield from get_case_fn(dut, a, b, mid)
 145         actual_responses.append(actual)
 146
 147     if len(actual_responses) < len(expected_responses):
 148         print ("Fail ... not enough results")
 149         exit(0)
 150
 151     for expected, actual, a, b in zip(expected_responses, actual_responses,
 152                                       stimulus_a, stimulus_b):
 153         passed = match(expected[0], actual[0])
 154         if expected[1] != actual[1]: # check mid
 155             print ("MID failed", expected[1], actual[1])
 156             sys.exit(0)
 157
 158         if not passed:
 159
 160             expected = expected[0]
 161             actual = actual[0]
 162             print ("Fail ... expected:", hex(expected), "actual:", hex(actual))
 163
 164             print (hex(a))
 165             print ("a mantissa:", a & 0x7fffff)
 166             print ("a exponent:", ((a & 0x7f800000) >> 23) - 127)
 167             print ("a sign:", ((a & 0x80000000) >> 31))
 168
 169             print (hex(b))
 170             print ("b mantissa:", b & 0x7fffff)
 171             print ("b exponent:", ((b & 0x7f800000) >> 23) - 127)
 172             print ("b sign:", ((b & 0x80000000) >> 31))
 173
 174             print (hex(expected))
 175             print ("expected mantissa:", expected & 0x7fffff)
 176             print ("expected exponent:", ((expected & 0x7f800000) >> 23) - 127)
 177             print ("expected sign:", ((expected & 0x80000000) >> 31))
 178
 179             print (hex(actual))
 180             print ("actual mantissa:", actual & 0x7fffff)
 181             print ("actual exponent:", ((actual & 0x7f800000) >> 23) - 127)
 182             print ("actual sign:", ((actual & 0x80000000) >> 31))
 183
 184             sys.exit(0)
 185
 186 corner_cases = [0x80000000, 0x00000000, 0x7f800000, 0xff800000,
 187                 0x7fc00000, 0xffc00000]
 188
 189 def run_corner_cases(dut, count, op, get_case_fn):
 190     #corner cases
 191     from itertools import permutations
 192     stimulus_a = [i[0] for i in permutations(corner_cases, 2)]
 193     stimulus_b = [i[1] for i in permutations(corner_cases, 2)]
 194     yield from run_test(dut, stimulus_a, stimulus_b, op, get_case_fn)
 195     count += len(stimulus_a)
 196     print (count, "vectors passed")
 197
 198 def run_test_2(dut, stimulus_a, stimulus_b, op, get_case_fn):
 199     yield from run_test(dut, stimulus_a, stimulus_b, op, get_case_fn)
 200     yield from run_test(dut, stimulus_b, stimulus_a, op, get_case_fn)
 201
 202 def run_cases(dut, count, op, fixed_num, num_entries, get_case_fn):
 203     if isinstance(fixed_num, int):
 204         stimulus_a = [fixed_num for i in range(num_entries)]
 205         report = hex(fixed_num)
 206     else:
 207         stimulus_a = fixed_num
 208         report = "random"
 209
 210     stimulus_b = [randint(0, 1<<32) for i in range(num_entries)]
 211     yield from run_test_2(dut, stimulus_a, stimulus_b, op, get_case_fn)
 212     count += len(stimulus_a)
 213     print (count, "vectors passed 2^32", report)
 214
 215     # non-canonical NaNs.
 216     stimulus_b = [set_exponent(randint(0, 1<<32), 128) \
 217                         for i in range(num_entries)]
 218     yield from run_test_2(dut, stimulus_a, stimulus_b, op, get_case_fn)
 219     count += len(stimulus_a)
 220     print (count, "vectors passed Non-Canonical NaN", report)
 221
 222     # -127
 223     stimulus_b = [set_exponent(randint(0, 1<<32), -127) \
 224                         for i in range(num_entries)]
 225     yield from run_test_2(dut, stimulus_a, stimulus_b, op, get_case_fn)
 226     count += len(stimulus_a)
 227     print (count, "vectors passed exp=-127", report)
 228
 229     # nearly zero
 230     stimulus_b = [set_exponent(randint(0, 1<<32), -126) \
 231                         for i in range(num_entries)]
 232     yield from run_test_2(dut, stimulus_a, stimulus_b, op, get_case_fn)
 233     count += len(stimulus_a)
 234     print (count, "vectors passed exp=-126", report)
 235
 236     # nearly inf
 237     stimulus_b = [set_exponent(randint(0, 1<<32), 127) \
 238                         for i in range(num_entries)]
 239     yield from run_test_2(dut, stimulus_a, stimulus_b, op, get_case_fn)
 240     count += len(stimulus_a)
 241     print (count, "vectors passed exp=127", report)
 242
 243     return count
 244
 245 def run_edge_cases(dut, count, op, get_case_fn):
 246     #edge cases
 247     for testme in corner_cases:
 248         count = yield from run_cases(dut, count, op, testme, 10, get_case_fn)
 249
 250     for i in range(100000):
 251         stimulus_a = [randint(0, 1<<32) for i in range(10)]
 252         count = yield from run_cases(dut, count, op, stimulus_a, 10,
 253                                      get_case_fn)
 254     return count
 255