2 from random
import randint
3 from random
import seed
5 from sfpy
import Float64
7 from ieee754
.fpcommon
.fpbase
import FPFormat
10 fmt
= FPFormat
.standard(64)
12 max_e
= fmt
.exponent_inf_nan
- fmt
.exponent_bias
15 return fmt
.get_mantissa(x
)
18 return fmt
.get_exponent(x
)
20 def set_exponent(x
, e
):
21 return (x
& ~
0x7ff0000000000000) |
((e
+(max_e
-1
)) << 52)
24 return fmt
.get_sign(x
)
33 return is_inf(x
) and not get_sign(x
)
36 return is_inf(x
) and get_sign(x
)
40 (is_pos_inf(x
) and is_pos_inf(y
)) or
41 (is_neg_inf(x
) and is_neg_inf(y
)) or
42 (is_nan(x
) and is_nan(y
)) or
47 return set_exponent((s
<<63) | m
, e
)
50 return create(s
, 1024, 0)
53 return create(s
, 1024, 1<<51)
58 def get_case(dut
, a
, b
, mid
):
59 #yield dut.in_mid.eq(mid)
60 yield dut
.in_a
.v
.eq(a
)
61 yield dut
.in_a
.valid_i_test
.eq(1)
66 a_ack
= (yield dut
.in_a
.ready_o
)
69 yield dut
.in_a
.valid_i
.eq(0)
71 yield dut
.in_b
.v
.eq(b
)
72 yield dut
.in_b
.valid_i
.eq(1)
75 b_ack
= (yield dut
.in_b
.ready_o
)
78 yield dut
.in_b
.valid_i
.eq(0)
80 yield dut
.out_z
.ready_i
.eq(1)
83 out_z_stb
= (yield dut
.out_z
.valid_o
)
87 out_z
= yield dut
.out_z
.v
88 #out_mid = yield dut.out_mid
89 yield dut
.out_z
.ready_i
.eq(0)
93 return out_z
, mid
# TODO: mid
95 def check_case(dut
, a
, b
, z
, mid
=None):
99 out_z
, out_mid
= yield from get_case(dut
, a
, b
, mid
)
100 assert out_z
== z
, "Output z 0x%x not equal to expected 0x%x" % (out_z
, z
)
101 assert out_mid
== mid
, "Output mid 0x%x != expected 0x%x" % (out_mid
, mid
)
104 def run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
):
106 expected_responses
= []
107 actual_responses
= []
108 for a
, b
in zip(stimulus_a
, stimulus_b
):
111 af
= Float64
.from_bits(a
)
112 bf
= Float64
.from_bits(b
)
114 expected_responses
.append((z
.get_bits(), mid
))
115 actual
= yield from get_case_fn(dut
, a
, b
, mid
)
116 actual_responses
.append(actual
)
118 if len(actual_responses
) < len(expected_responses
):
119 print ("Fail ... not enough results")
122 for expected
, actual
, a
, b
in zip(expected_responses
, actual_responses
,
123 stimulus_a
, stimulus_b
):
124 passed
= match(expected
[0], actual
[0])
125 if expected
[1] != actual
[1]: # check mid
126 print ("MID failed", expected
[1], actual
[1])
131 print ("Fail ... expected:", hex(exp
), "actual:", hex(act
))
134 print ("a mantissa:", a
& 0x000fffffffffffff)
135 print ("a exponent:", ((a
& 0x7ff0000000000000) >> 52)\
137 print ("a sign:", ((a
& 0x8000000000000000) >> 63))
140 print ("b mantissa:", b
& 0x000fffffffffffff)
141 print ("b exponent:", ((b
& 0x7ff0000000000000) >> 52)\
143 print ("b sign:", ((b
& 0x8000000000000000) >> 63))
146 print ("expected mantissa:", exp
& 0x000fffffffffffff)
147 print ("expected exponent:", ((exp
& 0x7ff0000000000000) >> 52)\
149 print ("expected sign:", ((exp
& 0x8000000000000000) >> 63))
152 print ("actual mantissa:", act
& 0x000fffffffffffff)
153 print ("actual exponent:", ((act
& 0x7ff0000000000000) >> 52)\
155 print ("actual sign:", ((act
& 0x8000000000000000) >> 63))
160 def run_corner_cases(dut
, count
, op
, get_case_fn
):
162 from itertools
import permutations
163 stimulus_a
= [i
[0] for i
in permutations([
171 stimulus_b
= [i
[1] for i
in permutations([
179 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
180 count
+= len(stimulus_a
)
181 print (count
, "vectors passed")
184 def run_edge_cases(dut
, count
, op
, get_case_fn
, maxcount
=1000, num_loops
=1000):
186 stimulus_a
= [0x8000000000000000 for i
in range(maxcount
)]
187 stimulus_b
= [randint(0, 1<<64) for i
in range(maxcount
)]
188 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
189 count
+= len(stimulus_a
)
190 print (count
, "vectors passed")
192 stimulus_a
= [0x0000000000000000 for i
in range(maxcount
)]
193 stimulus_b
= [randint(0, 1<<64) for i
in range(maxcount
)]
194 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
195 count
+= len(stimulus_a
)
196 print (count
, "vectors passed")
198 stimulus_b
= [0x8000000000000000 for i
in range(maxcount
)]
199 stimulus_a
= [randint(0, 1<<64) for i
in range(maxcount
)]
200 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
201 count
+= len(stimulus_a
)
202 print (count
, "vectors passed")
204 stimulus_b
= [0x0000000000000000 for i
in range(maxcount
)]
205 stimulus_a
= [randint(0, 1<<64) for i
in range(maxcount
)]
206 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
207 count
+= len(stimulus_a
)
208 print (count
, "vectors passed")
210 stimulus_a
= [0x7FF8000000000000 for i
in range(maxcount
)]
211 stimulus_b
= [randint(0, 1<<64) for i
in range(maxcount
)]
212 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
213 count
+= len(stimulus_a
)
214 print (count
, "vectors passed")
216 stimulus_a
= [0xFFF8000000000000 for i
in range(maxcount
)]
217 stimulus_b
= [randint(0, 1<<64) for i
in range(maxcount
)]
218 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
219 count
+= len(stimulus_a
)
220 print (count
, "vectors passed")
222 stimulus_b
= [0x7FF8000000000000 for i
in range(maxcount
)]
223 stimulus_a
= [randint(0, 1<<64) for i
in range(maxcount
)]
224 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
225 count
+= len(stimulus_a
)
226 print (count
, "vectors passed")
228 stimulus_b
= [0xFFF8000000000000 for i
in range(maxcount
)]
229 stimulus_a
= [randint(0, 1<<64) for i
in range(maxcount
)]
230 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
231 count
+= len(stimulus_a
)
232 print (count
, "vectors passed")
234 stimulus_a
= [0x7FF0000000000000 for i
in range(maxcount
)]
235 stimulus_b
= [randint(0, 1<<64) for i
in range(maxcount
)]
236 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
237 count
+= len(stimulus_a
)
238 print (count
, "vectors passed")
240 stimulus_a
= [0xFFF0000000000000 for i
in range(maxcount
)]
241 stimulus_b
= [randint(0, 1<<64) for i
in range(maxcount
)]
242 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
243 count
+= len(stimulus_a
)
244 print (count
, "vectors passed")
246 stimulus_b
= [0x7FF0000000000000 for i
in range(maxcount
)]
247 stimulus_a
= [randint(0, 1<<64) for i
in range(maxcount
)]
248 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
249 count
+= len(stimulus_a
)
250 print (count
, "vectors passed")
252 stimulus_b
= [0xFFF0000000000000 for i
in range(maxcount
)]
253 stimulus_a
= [randint(0, 1<<64) for i
in range(maxcount
)]
254 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
255 count
+= len(stimulus_a
)
256 print (count
, "vectors passed")
259 for i
in range(num_loops
):
260 stimulus_a
= [randint(0, 1<<64) for i
in range(maxcount
)]
261 stimulus_b
= [randint(0, 1<<64) for i
in range(maxcount
)]
262 yield from run_fpunit(dut
, stimulus_a
, stimulus_b
, op
, get_case_fn
)
264 print (count
, "random vectors passed")