1 from random
import randint
2 from random
import seed
5 from sfpy
import Float32
11 return ((x
& 0x7f800000) >> 23) - 127
13 def set_exponent(x
, e
):
14 return (x
& ~
0x7f800000) |
((e
+127) << 23)
17 return ((x
& 0x80000000) >> 31)
20 return get_exponent(x
) == 128 and get_mantissa(x
) != 0
23 return get_exponent(x
) == 128 and get_mantissa(x
) == 0
26 return is_inf(x
) and not get_sign(x
)
29 return is_inf(x
) and get_sign(x
)
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
39 def get_case(dut
, a
, b
):
40 yield dut
.in_a
.v
.eq(a
)
41 yield dut
.in_a
.stb
.eq(1)
44 a_ack
= (yield dut
.in_a
.ack
)
46 yield dut
.in_b
.v
.eq(b
)
47 yield dut
.in_b
.stb
.eq(1)
48 b_ack
= (yield dut
.in_b
.ack
)
53 out_z_stb
= (yield dut
.out_z
.stb
)
56 out_z
= yield dut
.out_z
.v
57 yield dut
.out_z
.ack
.eq(0)
58 yield dut
.in_a
.stb
.eq(0)
59 yield dut
.in_b
.stb
.eq(0)
61 yield dut
.out_z
.ack
.eq(1)
66 def check_case(dut
, a
, b
, z
):
67 out_z
= yield from get_case(dut
, a
, b
)
68 assert out_z
== z
, "Output z 0x%x not equal to expected 0x%x" % (out_z
, z
)
71 def run_test(dut
, stimulus_a
, stimulus_b
, op
):
73 expected_responses
= []
75 for a
, b
in zip(stimulus_a
, stimulus_b
):
76 af
= Float32
.from_bits(a
)
77 bf
= Float32
.from_bits(b
)
79 expected_responses
.append(z
.get_bits())
81 actual
= yield from get_case(dut
, a
, b
)
82 actual_responses
.append(actual
)
84 if len(actual_responses
) < len(expected_responses
):
85 print ("Fail ... not enough results")
88 for expected
, actual
, a
, b
in zip(expected_responses
, actual_responses
,
89 stimulus_a
, stimulus_b
):
90 passed
= match(expected
, actual
)
94 print ("Fail ... expected:", hex(expected
), "actual:", hex(actual
))
97 print ("a mantissa:", a
& 0x7fffff)
98 print ("a exponent:", ((a
& 0x7f800000) >> 23) - 127)
99 print ("a sign:", ((a
& 0x80000000) >> 31))
102 print ("b mantissa:", b
& 0x7fffff)
103 print ("b exponent:", ((b
& 0x7f800000) >> 23) - 127)
104 print ("b sign:", ((b
& 0x80000000) >> 31))
106 print (hex(expected
))
107 print ("expected mantissa:", expected
& 0x7fffff)
108 print ("expected exponent:", ((expected
& 0x7f800000) >> 23) - 127)
109 print ("expected sign:", ((expected
& 0x80000000) >> 31))
112 print ("actual mantissa:", actual
& 0x7fffff)
113 print ("actual exponent:", ((actual
& 0x7f800000) >> 23) - 127)
114 print ("actual sign:", ((actual
& 0x80000000) >> 31))
118 corner_cases
= [0x80000000, 0x00000000, 0x7f800000, 0xff800000,
119 0x7fc00000, 0xffc00000]
121 def run_corner_cases(dut
, count
, op
):
123 from itertools
import permutations
124 stimulus_a
= [i
[0] for i
in permutations(corner_cases
, 2)]
125 stimulus_b
= [i
[1] for i
in permutations(corner_cases
, 2)]
126 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
127 count
+= len(stimulus_a
)
128 print (count
, "vectors passed")
130 def run_test_2(dut
, stimulus_a
, stimulus_b
, op
):
131 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
132 yield from run_test(dut
, stimulus_b
, stimulus_a
, op
)
134 def run_cases(dut
, count
, op
, fixed_num
, num_entries
):
135 if isinstance(fixed_num
, int):
136 stimulus_a
= [fixed_num
for i
in range(num_entries
)]
137 report
= hex(fixed_num
)
139 stimulus_a
= fixed_num
142 stimulus_b
= [randint(0, 1<<32) for i
in range(num_entries
)]
143 yield from run_test_2(dut
, stimulus_a
, stimulus_b
, op
)
144 count
+= len(stimulus_a
)
145 print (count
, "vectors passed 2^32", report
)
147 # non-canonical NaNs.
148 stimulus_b
= [set_exponent(randint(0, 1<<32), 128) \
149 for i
in range(num_entries
)]
150 yield from run_test_2(dut
, stimulus_a
, stimulus_b
, op
)
151 count
+= len(stimulus_a
)
152 print (count
, "vectors passed Non-Canonical NaN", report
)
155 stimulus_b
= [set_exponent(randint(0, 1<<32), -127) \
156 for i
in range(num_entries
)]
157 yield from run_test_2(dut
, stimulus_a
, stimulus_b
, op
)
158 count
+= len(stimulus_a
)
159 print (count
, "vectors passed exp=-127", report
)
162 stimulus_b
= [set_exponent(randint(0, 1<<32), -126) \
163 for i
in range(num_entries
)]
164 yield from run_test_2(dut
, stimulus_a
, stimulus_b
, op
)
165 count
+= len(stimulus_a
)
166 print (count
, "vectors passed exp=-126", report
)
169 stimulus_b
= [set_exponent(randint(0, 1<<32), 127) \
170 for i
in range(num_entries
)]
171 yield from run_test_2(dut
, stimulus_a
, stimulus_b
, op
)
172 count
+= len(stimulus_a
)
173 print (count
, "vectors passed exp=127", report
)
177 def run_edge_cases(dut
, count
, op
):
179 for testme
in corner_cases
:
180 count
= yield from run_cases(dut
, count
, op
, testme
, 1000)
182 for i
in range(100000):
183 stimulus_a
= [randint(0, 1<<32) for i
in range(1000)]
184 count
= yield from run_cases(dut
, count
, op
, stimulus_a
, 1000)