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