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