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 def get_mantissa(x):
   8     return x & 0x000fffffffffffff
   9
  10 def get_exponent(x):
  11     return ((x & 0x7ff0000000000000) >> 52) - 1023
  12
  13 def get_sign(x):
  14     return ((x & 0x8000000000000000) >> 63)
  15
  16 def is_nan(x):
  17     return get_exponent(x) == 1024 and get_mantissa(x) != 0
  18
  19 def is_inf(x):
  20     return get_exponent(x) == 1024 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 = Float64.from_bits(a)
  76         bf = Float64.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 exp, act, a, b in zip(expected_responses, actual_responses,
  88                                       stimulus_a, stimulus_b):
  89         passed = match(exp, act)
  90
  91         if not passed:
  92
  93             print ("Fail ... expected:", hex(exp), "actual:", hex(act))
  94
  95             print (hex(a))
  96             print ("a mantissa:",              a & 0x000fffffffffffff)
  97             print ("a exponent:",            ((a & 0x7ff0000000000000) >> 52)\
  98                                                 - 1023)
  99             print ("a sign:",                ((a & 0x8000000000000000) >> 63))
 100
 101             print (hex(b))
 102             print ("b mantissa:",              b & 0x000fffffffffffff)
 103             print ("b exponent:",            ((b & 0x7ff0000000000000) >> 52)\
 104                                                  - 1023)
 105             print ("b sign:",                ((b & 0x8000000000000000) >> 63))
 106
 107             print (hex(exp))
 108             print ("expected mantissa:",   exp & 0x000fffffffffffff)
 109             print ("expected exponent:", ((exp & 0x7ff0000000000000) >> 52)\
 110                                                  - 1023)
 111             print ("expected sign:",     ((exp & 0x8000000000000000) >> 63))
 112
 113             print (hex(act))
 114             print ("actual mantissa:",       act & 0x000fffffffffffff)
 115             print ("actual exponent:",     ((act & 0x7ff0000000000000) >> 52)\
 116                                                  - 1023)
 117             print ("actual sign:",         ((act & 0x8000000000000000) >> 63))
 118
 119             sys.exit(0)
 120
 121
 122 def run_corner_cases(dut, count, op):
 123     #corner cases
 124     from itertools import permutations
 125     stimulus_a = [i[0] for i in permutations([
 126         0x8000000000000000,
 127         0x0000000000000000,
 128         0x7ff8000000000000,
 129         0xfff8000000000000,
 130         0x7ff0000000000000,
 131         0xfff0000000000000
 132     ], 2)]
 133     stimulus_b = [i[1] for i in permutations([
 134         0x8000000000000000,
 135         0x0000000000000000,
 136         0x7ff8000000000000,
 137         0xfff8000000000000,
 138         0x7ff0000000000000,
 139         0xfff0000000000000
 140     ], 2)]
 141     yield from run_test(dut, stimulus_a, stimulus_b, op)
 142     count += len(stimulus_a)
 143     print (count, "vectors passed")
 144
 145
 146 def run_edge_cases(dut, count, op, maxcount=1000, num_loops=1000):
 147     #edge cases
 148     stimulus_a = [0x8000000000000000 for i in range(maxcount)]
 149     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 150     yield from run_test(dut, stimulus_a, stimulus_b, op)
 151     count += len(stimulus_a)
 152     print (count, "vectors passed")
 153
 154     stimulus_a = [0x0000000000000000 for i in range(maxcount)]
 155     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 156     yield from run_test(dut, stimulus_a, stimulus_b, op)
 157     count += len(stimulus_a)
 158     print (count, "vectors passed")
 159
 160     stimulus_b = [0x8000000000000000 for i in range(maxcount)]
 161     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 162     yield from run_test(dut, stimulus_a, stimulus_b, op)
 163     count += len(stimulus_a)
 164     print (count, "vectors passed")
 165
 166     stimulus_b = [0x0000000000000000 for i in range(maxcount)]
 167     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 168     yield from run_test(dut, stimulus_a, stimulus_b, op)
 169     count += len(stimulus_a)
 170     print (count, "vectors passed")
 171
 172     stimulus_a = [0x7FF8000000000000 for i in range(maxcount)]
 173     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 174     yield from run_test(dut, stimulus_a, stimulus_b, op)
 175     count += len(stimulus_a)
 176     print (count, "vectors passed")
 177
 178     stimulus_a = [0xFFF8000000000000 for i in range(maxcount)]
 179     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 180     yield from run_test(dut, stimulus_a, stimulus_b, op)
 181     count += len(stimulus_a)
 182     print (count, "vectors passed")
 183
 184     stimulus_b = [0x7FF8000000000000 for i in range(maxcount)]
 185     stimulus_a = [randint(0, 1<<64) for i in range(maxcount)]
 186     yield from run_test(dut, stimulus_a, stimulus_b, op)
 187     count += len(stimulus_a)
 188     print (count, "vectors passed")
 189
 190     stimulus_b = [0xFFF8000000000000 for i in range(maxcount)]
 191     stimulus_a = [randint(0, 1<<64) for i in range(maxcount)]
 192     yield from run_test(dut, stimulus_a, stimulus_b, op)
 193     count += len(stimulus_a)
 194     print (count, "vectors passed")
 195
 196     stimulus_a = [0x7FF0000000000000 for i in range(maxcount)]
 197     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 198     yield from run_test(dut, stimulus_a, stimulus_b, op)
 199     count += len(stimulus_a)
 200     print (count, "vectors passed")
 201
 202     stimulus_a = [0xFFF0000000000000 for i in range(maxcount)]
 203     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 204     yield from run_test(dut, stimulus_a, stimulus_b, op)
 205     count += len(stimulus_a)
 206     print (count, "vectors passed")
 207
 208     stimulus_b = [0x7FF0000000000000 for i in range(maxcount)]
 209     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 210     yield from run_test(dut, stimulus_a, stimulus_b, op)
 211     count += len(stimulus_a)
 212     print (count, "vectors passed")
 213
 214     stimulus_b = [0xFFF0000000000000 for i in range(maxcount)]
 215     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 216     yield from run_test(dut, stimulus_a, stimulus_b, op)
 217     count += len(stimulus_a)
 218     print (count, "vectors passed")
 219
 220     #seed(0)
 221     for i in range(num_loops):
 222         stimulus_a = [randint(0, 1<<64) for i in range(maxcount)]
 223         stimulus_b = [randint(0, 1<<64) for i in range(maxcount)]
 224         yield from run_test(dut, stimulus_a, stimulus_b, op)
 225         count += maxcount
 226         print (count, "random vectors passed")
 227