src/ieee754/fpcommon/test/unit_test_half.py

   1 from random import randint
   2 from random import seed
   3
   4 import sys
   5 from sfpy import Float16
   6
   7 max_e = 16
   8
   9 def get_mantissa(x):
  10     return 0x3ff & x
  11
  12 def get_exponent(x):
  13     return ((x & 0x7800) >> 11) - 15
  14
  15 def set_exponent(x, e):
  16     return (x & ~0x7800) | ((e+15) << 11)
  17
  18 def get_sign(x):
  19     return ((x & 0x8000) >> 15)
  20
  21 def is_nan(x):
  22     return get_exponent(x) == 16 and get_mantissa(x) != 0
  23
  24 def is_inf(x):
  25     return get_exponent(x) == 16 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<<15) | m, e)
  43
  44 def inf(s):
  45     return create(s, 16, 0)
  46
  47 def nan(s):
  48     return create(s, 16, 1<<10)
  49
  50 def zero(s):
  51     return s<<15
  52
  53 def get_case(dut, a, b):
  54     yield dut.in_a.v.eq(a)
  55     yield dut.in_a.stb.eq(1)
  56     yield
  57     yield
  58     a_ack = (yield dut.in_a.ack)
  59     assert a_ack == 0
  60     yield dut.in_b.v.eq(b)
  61     yield dut.in_b.stb.eq(1)
  62     b_ack = (yield dut.in_b.ack)
  63     assert b_ack == 0
  64
  65     while True:
  66         yield
  67         out_z_stb = (yield dut.out_z.stb)
  68         if not out_z_stb:
  69             continue
  70         yield dut.in_a.stb.eq(0)
  71         yield dut.in_b.stb.eq(0)
  72         yield dut.out_z.ack.eq(1)
  73         yield
  74         yield dut.out_z.ack.eq(0)
  75         yield
  76         yield
  77         break
  78
  79     out_z = yield dut.out_z.v
  80     return out_z
  81
  82 def check_case(dut, a, b, z):
  83     out_z = yield from get_case(dut, a, b)
  84     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
  85
  86
  87 def run_fpunit(dut, stimulus_a, stimulus_b, op):
  88
  89     expected_responses = []
  90     actual_responses = []
  91     for a, b in zip(stimulus_a, stimulus_b):
  92         af = Float16.from_bits(a)
  93         bf = Float16.from_bits(b)
  94         z = op(af, bf)
  95         expected_responses.append(z.get_bits())
  96         #print (af, bf, z)
  97         actual = yield from get_case(dut, a, b)
  98         actual_responses.append(actual)
  99
 100     if len(actual_responses) < len(expected_responses):
 101         print ("Fail ... not enough results")
 102         exit(0)
 103
 104     for expected, actual, a, b in zip(expected_responses, actual_responses,
 105                                       stimulus_a, stimulus_b):
 106         passed = match(expected, actual)
 107
 108         if not passed:
 109
 110             print ("Fail ... expected:", hex(expected), "actual:", hex(actual))
 111
 112             print (hex(a))
 113             print ("a mantissa:", get_mantissa(a))
 114             print ("a exponent:", get_exponent(a))
 115             print ("a sign:", get_sign(a))
 116
 117             print (hex(b))
 118             print ("b mantissa:", get_mantissa(b))
 119             print ("b exponent:", get_exponent(b))
 120             print ("b sign:", get_sign(b))
 121
 122             print (hex(expected))
 123             print ("expected mantissa:", get_mantissa(expected))
 124             print ("expected exponent:", get_exponent(expected))
 125             print ("expected sign:", get_sign(expected))
 126
 127             print (hex(actual))
 128             print ("actual mantissa:", get_mantissa(actual))
 129             print ("actual exponent:", get_exponent(actual))
 130             print ("actual sign:", get_sign(actual))
 131
 132             sys.exit(0)
 133
 134 def run_corner_cases(dut, count, op):
 135     #corner cases
 136     corners = [0x8000, 0x0000, 0x7800, 0xf800, 0x7c00, 0xfc00]
 137     from itertools import permutations
 138     stimulus_a = [i[0] for i in permutations(corners, 2)]
 139     stimulus_b = [i[1] for i in permutations(corners, 2)]
 140     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 141     count += len(stimulus_a)
 142     print (count, "vectors passed")
 143
 144
 145 def run_edge_cases(dut, count, op, maxcount=10, num_loops=1000):
 146     maxint16 = 1<<16
 147     #edge cases
 148     stimulus_a = [0x8000 for i in range(maxcount)]
 149     stimulus_b = [randint(0, maxint16-1) for i in range(maxcount)]
 150     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 151     count += len(stimulus_a)
 152     print (count, "vectors passed")
 153
 154     stimulus_a = [0x0000 for i in range(maxcount)]
 155     stimulus_b = [randint(0, maxint16-1) for i in range(maxcount)]
 156     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 157     count += len(stimulus_a)
 158     print (count, "vectors passed")
 159
 160     stimulus_b = [0x8000 for i in range(maxcount)]
 161     stimulus_a = [randint(0, maxint16-1) for i in range(maxcount)]
 162     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 163     count += len(stimulus_a)
 164     print (count, "vectors passed")
 165
 166     stimulus_b = [0x0000 for i in range(maxcount)]
 167     stimulus_a = [randint(0, maxint16-1) for i in range(maxcount)]
 168     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 169     count += len(stimulus_a)
 170     print (count, "vectors passed")
 171
 172     stimulus_a = [0x7800 for i in range(maxcount)]
 173     stimulus_b = [randint(0, maxint16-1) for i in range(maxcount)]
 174     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 175     count += len(stimulus_a)
 176     print (count, "vectors passed")
 177
 178     stimulus_a = [0xF800 for i in range(maxcount)]
 179     stimulus_b = [randint(0, maxint16-1) for i in range(maxcount)]
 180     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 181     count += len(stimulus_a)
 182     print (count, "vectors passed")
 183
 184     stimulus_b = [0x7800 for i in range(maxcount)]
 185     stimulus_a = [randint(0, maxint16-1) for i in range(maxcount)]
 186     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 187     count += len(stimulus_a)
 188     print (count, "vectors passed")
 189
 190     stimulus_b = [0xF800 for i in range(maxcount)]
 191     stimulus_a = [randint(0, maxint16-1) for i in range(maxcount)]
 192     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 193     count += len(stimulus_a)
 194     print (count, "vectors passed")
 195
 196     stimulus_a = [0x7C00 for i in range(maxcount)]
 197     stimulus_b = [randint(0, maxint16-1) for i in range(maxcount)]
 198     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 199     count += len(stimulus_a)
 200     print (count, "vectors passed")
 201
 202     stimulus_a = [0xFC00 for i in range(maxcount)]
 203     stimulus_b = [randint(0, maxint16-1) for i in range(maxcount)]
 204     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 205     count += len(stimulus_a)
 206     print (count, "vectors passed")
 207
 208     stimulus_b = [0x7C00 for i in range(maxcount)]
 209     stimulus_a = [randint(0, maxint16-1) for i in range(maxcount)]
 210     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 211     count += len(stimulus_a)
 212     print (count, "vectors passed")
 213
 214     stimulus_b = [0xFC00 for i in range(maxcount)]
 215     stimulus_a = [randint(0, maxint16-1) for i in range(maxcount)]
 216     yield from run_fpunit(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, maxint16-1) for i in range(maxcount)]
 223         stimulus_b = [randint(0, maxint16-1) for i in range(maxcount)]
 224         yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 225         count += maxcount
 226         print (count, "random vectors passed")
 227