src/ieee754/fpcommon/test/unit_test_double.py

   1 import sys
   2 from random import randint
   3 from random import seed
   4
   5 from sfpy import Float64
   6
   7 from ieee754.fpcommon.fpbase import FPFormat
   8
   9
  10 fmt = FPFormat.standard(64)
  11
  12 max_e = fmt.exponent_inf_nan- fmt.exponent_bias
  13
  14 def get_mantissa(x):
  15     return fmt.get_mantissa(x)
  16
  17 def get_exponent(x):
  18     return fmt.get_exponent(x)
  19
  20 def set_exponent(x, e):
  21     return (x & ~0x7ff0000000000000) | ((e+(max_e-1)) << 52)
  22
  23 def get_sign(x):
  24     return fmt.get_sign(x)
  25
  26 def is_nan(x):
  27     return fmt.is_nan(x)
  28
  29 def is_inf(x):
  30     return fmt.is_inf(x)
  31
  32 def is_pos_inf(x):
  33     return is_inf(x) and not get_sign(x)
  34
  35 def is_neg_inf(x):
  36     return is_inf(x) and get_sign(x)
  37
  38 def match(x, y):
  39     return (
  40         (is_pos_inf(x) and is_pos_inf(y)) or
  41         (is_neg_inf(x) and is_neg_inf(y)) or
  42         (is_nan(x) and is_nan(y)) or
  43         (x == y)
  44         )
  45
  46 def create(s, e, m):
  47     return set_exponent((s<<63) | m, e)
  48
  49 def inf(s):
  50     return create(s, 1024, 0)
  51
  52 def nan(s):
  53     return create(s, 1024, 1<<51)
  54
  55 def zero(s):
  56     return s<<63
  57
  58 def get_case(dut, a, b, mid):
  59     #yield dut.in_mid.eq(mid)
  60     yield dut.in_a.v.eq(a)
  61     yield dut.in_a.valid_i_test.eq(1)
  62     yield
  63     yield
  64     yield
  65     yield
  66     a_ack = (yield dut.in_a.ready_o)
  67     assert a_ack == 0
  68
  69     yield dut.in_a.valid_i.eq(0)
  70
  71     yield dut.in_b.v.eq(b)
  72     yield dut.in_b.valid_i.eq(1)
  73     yield
  74     yield
  75     b_ack = (yield dut.in_b.ready_o)
  76     assert b_ack == 0
  77
  78     yield dut.in_b.valid_i.eq(0)
  79
  80     yield dut.out_z.ready_i.eq(1)
  81
  82     while True:
  83         out_z_stb = (yield dut.out_z.valid_o)
  84         if not out_z_stb:
  85             yield
  86             continue
  87         out_z = yield dut.out_z.v
  88         #out_mid = yield dut.out_mid
  89         yield dut.out_z.ready_i.eq(0)
  90         yield
  91         break
  92
  93     return out_z, mid # TODO: mid
  94
  95 def check_case(dut, a, b, z, mid=None):
  96     if mid is None:
  97         mid = randint(0, 6)
  98     mid = 0
  99     out_z, out_mid = yield from get_case(dut, a, b, mid)
 100     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
 101     assert out_mid == mid, "Output mid 0x%x != expected 0x%x" % (out_mid, mid)
 102
 103
 104 def run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn):
 105
 106     expected_responses = []
 107     actual_responses = []
 108     for a, b in zip(stimulus_a, stimulus_b):
 109         mid = randint(0, 6)
 110         mid = 0
 111         af = Float64.from_bits(a)
 112         bf = Float64.from_bits(b)
 113         z = op(af, bf)
 114         expected_responses.append((z.get_bits(), mid))
 115         actual = yield from get_case_fn(dut, a, b, mid)
 116         actual_responses.append(actual)
 117
 118     if len(actual_responses) < len(expected_responses):
 119         print ("Fail ... not enough results")
 120         exit(0)
 121
 122     for expected, actual, a, b in zip(expected_responses, actual_responses,
 123                                       stimulus_a, stimulus_b):
 124         passed = match(expected[0], actual[0])
 125         if expected[1] != actual[1]: # check mid
 126             print ("MID failed", expected[1], actual[1])
 127             sys.exit(0)
 128
 129         if not passed:
 130
 131             print ("Fail ... expected:", hex(exp), "actual:", hex(act))
 132
 133             print (hex(a))
 134             print ("a mantissa:",              a & 0x000fffffffffffff)
 135             print ("a exponent:",            ((a & 0x7ff0000000000000) >> 52)\
 136                                                 - 1023)
 137             print ("a sign:",                ((a & 0x8000000000000000) >> 63))
 138
 139             print (hex(b))
 140             print ("b mantissa:",              b & 0x000fffffffffffff)
 141             print ("b exponent:",            ((b & 0x7ff0000000000000) >> 52)\
 142                                                  - 1023)
 143             print ("b sign:",                ((b & 0x8000000000000000) >> 63))
 144
 145             print (hex(exp))
 146             print ("expected mantissa:",   exp & 0x000fffffffffffff)
 147             print ("expected exponent:", ((exp & 0x7ff0000000000000) >> 52)\
 148                                                  - 1023)
 149             print ("expected sign:",     ((exp & 0x8000000000000000) >> 63))
 150
 151             print (hex(act))
 152             print ("actual mantissa:",       act & 0x000fffffffffffff)
 153             print ("actual exponent:",     ((act & 0x7ff0000000000000) >> 52)\
 154                                                  - 1023)
 155             print ("actual sign:",         ((act & 0x8000000000000000) >> 63))
 156
 157             sys.exit(0)
 158
 159
 160 def run_corner_cases(dut, count, op, get_case_fn):
 161     #corner cases
 162     from itertools import permutations
 163     stimulus_a = [i[0] for i in permutations([
 164         0x8000000000000000,
 165         0x0000000000000000,
 166         0x7ff8000000000000,
 167         0xfff8000000000000,
 168         0x7ff0000000000000,
 169         0xfff0000000000000
 170     ], 2)]
 171     stimulus_b = [i[1] for i in permutations([
 172         0x8000000000000000,
 173         0x0000000000000000,
 174         0x7ff8000000000000,
 175         0xfff8000000000000,
 176         0x7ff0000000000000,
 177         0xfff0000000000000
 178     ], 2)]
 179     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 180     count += len(stimulus_a)
 181     print (count, "vectors passed")
 182
 183
 184 def run_edge_cases(dut, count, op, get_case_fn, maxcount=1000, num_loops=1000):
 185     #edge cases
 186     stimulus_a = [0x8000000000000000 for i in range(maxcount)]
 187     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 188     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 189     count += len(stimulus_a)
 190     print (count, "vectors passed")
 191
 192     stimulus_a = [0x0000000000000000 for i in range(maxcount)]
 193     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 194     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 195     count += len(stimulus_a)
 196     print (count, "vectors passed")
 197
 198     stimulus_b = [0x8000000000000000 for i in range(maxcount)]
 199     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 200     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 201     count += len(stimulus_a)
 202     print (count, "vectors passed")
 203
 204     stimulus_b = [0x0000000000000000 for i in range(maxcount)]
 205     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 206     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 207     count += len(stimulus_a)
 208     print (count, "vectors passed")
 209
 210     stimulus_a = [0x7FF8000000000000 for i in range(maxcount)]
 211     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 212     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 213     count += len(stimulus_a)
 214     print (count, "vectors passed")
 215
 216     stimulus_a = [0xFFF8000000000000 for i in range(maxcount)]
 217     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 218     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 219     count += len(stimulus_a)
 220     print (count, "vectors passed")
 221
 222     stimulus_b = [0x7FF8000000000000 for i in range(maxcount)]
 223     stimulus_a = [randint(0, 1<<64) for i in range(maxcount)]
 224     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 225     count += len(stimulus_a)
 226     print (count, "vectors passed")
 227
 228     stimulus_b = [0xFFF8000000000000 for i in range(maxcount)]
 229     stimulus_a = [randint(0, 1<<64) for i in range(maxcount)]
 230     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 231     count += len(stimulus_a)
 232     print (count, "vectors passed")
 233
 234     stimulus_a = [0x7FF0000000000000 for i in range(maxcount)]
 235     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 236     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 237     count += len(stimulus_a)
 238     print (count, "vectors passed")
 239
 240     stimulus_a = [0xFFF0000000000000 for i in range(maxcount)]
 241     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 242     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 243     count += len(stimulus_a)
 244     print (count, "vectors passed")
 245
 246     stimulus_b = [0x7FF0000000000000 for i in range(maxcount)]
 247     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 248     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 249     count += len(stimulus_a)
 250     print (count, "vectors passed")
 251
 252     stimulus_b = [0xFFF0000000000000 for i in range(maxcount)]
 253     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 254     yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 255     count += len(stimulus_a)
 256     print (count, "vectors passed")
 257
 258     #seed(0)
 259     for i in range(num_loops):
 260         stimulus_a = [randint(0, 1<<64) for i in range(maxcount)]
 261         stimulus_b = [randint(0, 1<<64) for i in range(maxcount)]
 262         yield from run_fpunit(dut, stimulus_a, stimulus_b, op, get_case_fn)
 263         count += maxcount
 264         print (count, "random vectors passed")
 265