src/add/unit_test_single.py

   1 def get_mantissa(x):
   2     return 0x7fffff & x
   3
   4 def get_exponent(x):
   5     return ((x & 0x7f800000) >> 23) - 127
   6
   7 def get_sign(x):
   8     return ((x & 0x80000000) >> 31)
   9
  10 def is_nan(x):
  11     return get_exponent(x) == 128 and get_mantissa(x) != 0
  12
  13 def is_inf(x):
  14     return get_exponent(x) == 128 and get_mantissa(x) == 0
  15
  16 def is_pos_inf(x):
  17     return is_inf(x) and not get_sign(x)
  18
  19 def is_neg_inf(x):
  20     return is_inf(x) and get_sign(x)
  21
  22 def match(x, y):
  23     return (
  24         (is_pos_inf(x) and is_pos_inf(y)) or
  25         (is_neg_inf(x) and is_neg_inf(y)) or
  26         (is_nan(x) and is_nan(y)) or
  27         (x == y)
  28         )
  29
  30 def get_case(dut, a, b):
  31     yield dut.in_a.v.eq(a)
  32     yield dut.in_a.stb.eq(1)
  33     yield
  34     yield
  35     a_ack = (yield dut.in_a.ack)
  36     assert a_ack == 0
  37     yield dut.in_b.v.eq(b)
  38     yield dut.in_b.stb.eq(1)
  39     b_ack = (yield dut.in_b.ack)
  40     assert b_ack == 0
  41
  42     while True:
  43         yield
  44         out_z_stb = (yield dut.out_z.stb)
  45         if not out_z_stb:
  46             continue
  47         yield dut.in_a.stb.eq(0)
  48         yield dut.in_b.stb.eq(0)
  49         yield dut.out_z.ack.eq(1)
  50         yield
  51         yield dut.out_z.ack.eq(0)
  52         yield
  53         yield
  54         break
  55
  56     out_z = yield dut.out_z.v
  57     return out_z
  58
  59 def check_case(dut, a, b, z):
  60     out_z = yield from get_case(dut, a, b)
  61     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
  62
  63
  64 def run_test(dut, stimulus_a, stimulus_b):
  65
  66     expected_responses = []
  67     actual_responses = []
  68     for a, b in zip(stimulus_a, stimulus_b):
  69         af = Float32.from_bits(a)
  70         bf = Float32.from_bits(b)
  71         z = af + bf
  72         expected_responses.append(z.get_bits())
  73         #print (af, bf, z)
  74         actual = yield from get_case(dut, a, b)
  75         actual_responses.append(actual)
  76
  77     if len(actual_responses) < len(expected_responses):
  78         print ("Fail ... not enough results")
  79         exit(0)
  80
  81     for expected, actual, a, b in zip(expected_responses, actual_responses,
  82                                       stimulus_a, stimulus_b):
  83         passed = match(expected, actual)
  84
  85         if not passed:
  86
  87             print ("Fail ... expected:", hex(expected), "actual:", hex(actual))
  88
  89             print (hex(a))
  90             print ("a mantissa:", a & 0x7fffff)
  91             print ("a exponent:", ((a & 0x7f800000) >> 23) - 127)
  92             print ("a sign:", ((a & 0x80000000) >> 31))
  93
  94             print (hex(b))
  95             print ("b mantissa:", b & 0x7fffff)
  96             print ("b exponent:", ((b & 0x7f800000) >> 23) - 127)
  97             print ("b sign:", ((b & 0x80000000) >> 31))
  98
  99             print (hex(expected))
 100             print ("expected mantissa:", expected & 0x7fffff)
 101             print ("expected exponent:", ((expected & 0x7f800000) >> 23) - 127)
 102             print ("expected sign:", ((expected & 0x80000000) >> 31))
 103
 104             print (hex(actual))
 105             print ("actual mantissa:", actual & 0x7fffff)
 106             print ("actual exponent:", ((actual & 0x7f800000) >> 23) - 127)
 107             print ("actual sign:", ((actual & 0x80000000) >> 31))
 108
 109             sys.exit(0)
 110