1 # SPDX-License-Identifier: LGPL-2.1-or-later
2 # See Notices.txt for copyright information
5 Copyright (C) 2020 Luke Kenneth Casson Leighton <lkcl@lkcl.net>
7 dynamic-partitionable class similar to Signal, which, when the partition
8 is fully open will be identical to Signal. when partitions are closed,
9 the class turns into a SIMD variant of Signal. *this is dynamic*.
11 the basic fundamental idea is: write code once, and if you want a SIMD
12 version of it, use SimdSignal in place of Signal. job done.
13 this however requires the code to *not* be designed to use nmigen.If,
14 nmigen.Case, or other constructs: only Mux and other logic.
16 * http://bugs.libre-riscv.org/show_bug.cgi?id=132
19 from ieee754
.part_mul_add
.adder
import PartitionedAdder
20 from ieee754
.part_cmp
.eq_gt_ge
import PartitionedEqGtGe
21 from ieee754
.part_bits
.xor
import PartitionedXOR
22 from ieee754
.part_bits
.bool import PartitionedBool
23 from ieee754
.part_bits
.all
import PartitionedAll
24 from ieee754
.part_shift
.part_shift_dynamic
import PartitionedDynamicShift
25 from ieee754
.part_shift
.part_shift_scalar
import PartitionedScalarShift
26 from ieee754
.part_mul_add
.partpoints
import make_partition2
, PartitionPoints
27 from ieee754
.part_mux
.part_mux
import PMux
28 from ieee754
.part_ass
.passign
import PAssign
29 from ieee754
.part_cat
.pcat
import PCat
30 from ieee754
.part_repl
.prepl
import PRepl
31 from operator
import or_
, xor
, and_
, not_
33 from nmigen
import (Signal
, Const
, Cat
)
34 from nmigen
.hdl
.ast
import UserValue
, Shape
38 if isinstance(op1
, SimdSignal
):
43 def applyop(op1
, op2
, op
):
44 if isinstance(op1
, SimdSignal
):
45 result
= SimdSignal
.like(op1
)
47 result
= SimdSignal
.like(op2
)
48 result
.m
.d
.comb
+= result
.sig
.eq(op(getsig(op1
), getsig(op2
)))
54 # for sub-modules to be created on-demand. Mux is done slightly
55 # differently (has its own global)
56 for name
in ['add', 'eq', 'gt', 'ge', 'ls', 'xor', 'bool', 'all']:
60 # Prototype https://bugs.libre-soc.org/show_bug.cgi?id=713#c53
61 # this provides a "compatibility" layer with existing SimdSignal
62 # behaviour. the idea is that this interface defines which "combinations"
63 # of partition selections are relevant, and as an added bonus it says
64 # which partition lanes are completely irrelevant (padding, blank).
65 class PartType
: # TODO decide name
66 def __init__(self
, psig
):
70 return list(self
.psig
.partpoints
.values())
73 return Cat(self
.get_mask())
76 return range(1 << len(self
.get_mask()))
82 # this one would be an elwidth version
83 # see https://bugs.libre-soc.org/show_bug.cgi?id=713#c34
84 # it requires an "adapter" which is the layout() function
85 # where the PartitionPoints was *created* by the layout()
86 # function and this class then "understands" the relationship
87 # between elwidth and the PartitionPoints that were created
91 class ElWidthPartType
: # TODO decide name
92 def __init__(self
, psig
):
96 ppoints
, pbits
= layout()
97 return ppoints
.values() # i think
100 return self
.psig
.elwidth
103 ppoints
, pbits
= layout()
107 def blanklanes(self
):
111 class SimdSignal(UserValue
):
112 # XXX ################################################### XXX
113 # XXX Keep these functions in the same order as ast.Value XXX
114 # XXX ################################################### XXX
115 def __init__(self
, mask
, *args
, src_loc_at
=0, **kwargs
):
116 super().__init
__(src_loc_at
=src_loc_at
)
117 self
.sig
= Signal(*args
, **kwargs
)
118 width
= len(self
.sig
) # get signal width
119 # create partition points
120 if isinstance(mask
, PartitionPoints
):
121 self
.partpoints
= mask
123 self
.partpoints
= make_partition2(mask
, width
)
124 self
.ptype
= PartType(self
)
126 def set_module(self
, m
):
129 def get_modname(self
, category
):
130 modnames
[category
] += 1
131 return "%s_%d" % (category
, modnames
[category
])
134 def like(other
, *args
, **kwargs
):
135 """Builds a new SimdSignal with the same PartitionPoints and
136 Signal properties as the other"""
137 result
= SimdSignal(PartitionPoints(other
.partpoints
))
138 result
.sig
= Signal
.like(other
.sig
, *args
, **kwargs
)
145 # nmigen-redirected constructs (Mux, Cat, Switch, Assign)
147 # TODO, http://bugs.libre-riscv.org/show_bug.cgi?id=458
148 # def __Part__(self, offset, width, stride=1, *, src_loc_at=0):
150 def __Repl__(self
, count
, *, src_loc_at
=0):
151 return PRepl(self
.m
, self
, count
, self
.ptype
)
153 def __Cat__(self
, *args
, src_loc_at
=0):
154 # TODO: need SwizzledSimdValue-aware Cat
155 args
= [self
] + list(args
)
157 assert isinstance(sig
, SimdSignal
), \
158 "All SimdSignal.__Cat__ arguments must be " \
159 "a SimdSignal. %s is not." % repr(sig
)
160 return PCat(self
.m
, args
, self
.ptype
)
162 def __Mux__(self
, val1
, val2
):
163 # print ("partsig mux", self, val1, val2)
164 assert len(val1
) == len(val2
), \
165 "SimdSignal width sources must be the same " \
166 "val1 == %d, val2 == %d" % (len(val1
), len(val2
))
167 return PMux(self
.m
, self
.partpoints
, self
, val1
, val2
, self
.ptype
)
169 def __Assign__(self
, val
, *, src_loc_at
=0):
170 # print ("partsig ass", self, val)
171 return PAssign(self
.m
, self
, val
, self
.ptype
)
173 def __Slice__(self
, start
, stop
, *, src_loc_at
=0):
174 # TODO: add __Slice__ redirection to nmigen
175 raise NotImplementedError("TODO: need SwizzledSimdValue-aware Slice")
177 # TODO, http://bugs.libre-riscv.org/show_bug.cgi?id=458
178 # def __Switch__(self, cases, *, src_loc=None, src_loc_at=0,
181 # no override needed, Value.__bool__ sufficient
182 # def __bool__(self):
184 # unary ops that do not require partitioning
186 def __invert__(self
):
187 result
= SimdSignal
.like(self
)
188 self
.m
.d
.comb
+= result
.sig
.eq(~self
.sig
)
191 # unary ops that require partitioning
194 z
= Const(0, len(self
.sig
))
195 result
, _
= self
.sub_op(z
, self
)
198 # binary ops that need partitioning
200 def add_op(self
, op1
, op2
, carry
):
203 pa
= PartitionedAdder(len(op1
), self
.partpoints
)
204 setattr(self
.m
.submodules
, self
.get_modname('add'), pa
)
208 comb
+= pa
.carry_in
.eq(carry
)
209 result
= SimdSignal
.like(self
)
210 comb
+= result
.sig
.eq(pa
.output
)
211 return result
, pa
.carry_out
213 def sub_op(self
, op1
, op2
, carry
=~
0):
216 pa
= PartitionedAdder(len(op1
), self
.partpoints
)
217 setattr(self
.m
.submodules
, self
.get_modname('add'), pa
)
220 comb
+= pa
.b
.eq(~op2
)
221 comb
+= pa
.carry_in
.eq(carry
)
222 result
= SimdSignal
.like(self
)
223 comb
+= result
.sig
.eq(pa
.output
)
224 return result
, pa
.carry_out
226 def __add__(self
, other
):
227 result
, _
= self
.add_op(self
, other
, carry
=0)
230 def __radd__(self
, other
):
231 # https://bugs.libre-soc.org/show_bug.cgi?id=718
232 result
, _
= self
.add_op(other
, self
)
235 def __sub__(self
, other
):
236 result
, _
= self
.sub_op(self
, other
)
239 def __rsub__(self
, other
):
240 # https://bugs.libre-soc.org/show_bug.cgi?id=718
241 result
, _
= self
.sub_op(other
, self
)
244 def __mul__(self
, other
):
245 raise NotImplementedError # too complicated at the moment
246 return Operator("*", [self
, other
])
248 def __rmul__(self
, other
):
249 raise NotImplementedError # too complicated at the moment
250 return Operator("*", [other
, self
])
252 # not needed: same as Value.__check_divisor
253 # def __check_divisor(self):
255 def __mod__(self
, other
):
256 raise NotImplementedError
257 other
= Value
.cast(other
)
258 other
.__check
_divisor
()
259 return Operator("%", [self
, other
])
261 def __rmod__(self
, other
):
262 raise NotImplementedError
263 self
.__check
_divisor
()
264 return Operator("%", [other
, self
])
266 def __floordiv__(self
, other
):
267 raise NotImplementedError
268 other
= Value
.cast(other
)
269 other
.__check
_divisor
()
270 return Operator("//", [self
, other
])
272 def __rfloordiv__(self
, other
):
273 raise NotImplementedError
274 self
.__check
_divisor
()
275 return Operator("//", [other
, self
])
277 # not needed: same as Value.__check_shamt
278 # def __check_shamt(self):
280 # TODO: detect if the 2nd operand is a Const, a Signal or a
281 # SimdSignal. if it's a Const or a Signal, a global shift
282 # can occur. if it's a SimdSignal, that's much more interesting.
283 def ls_op(self
, op1
, op2
, carry
, shr_flag
=0):
285 if isinstance(op2
, Const
) or isinstance(op2
, Signal
):
287 pa
= PartitionedScalarShift(len(op1
), self
.partpoints
)
291 pa
= PartitionedDynamicShift(len(op1
), self
.partpoints
)
293 # TODO: case where the *shifter* is a SimdSignal but
294 # the thing *being* Shifted is a scalar (Signal, expression)
295 # https://bugs.libre-soc.org/show_bug.cgi?id=718
296 setattr(self
.m
.submodules
, self
.get_modname('ls'), pa
)
299 comb
+= pa
.data
.eq(op1
)
300 comb
+= pa
.shifter
.eq(op2
)
301 comb
+= pa
.shift_right
.eq(shr_flag
)
305 comb
+= pa
.shift_right
.eq(shr_flag
)
306 # XXX TODO: carry-in, carry-out (for arithmetic shift)
307 #comb += pa.carry_in.eq(carry)
308 return (pa
.output
, 0)
310 def __lshift__(self
, other
):
311 z
= Const(0, len(self
.partpoints
)+1)
312 result
, _
= self
.ls_op(self
, other
, carry
=z
) # TODO, carry
315 def __rlshift__(self
, other
):
316 # https://bugs.libre-soc.org/show_bug.cgi?id=718
317 raise NotImplementedError
318 return Operator("<<", [other
, self
])
320 def __rshift__(self
, other
):
321 z
= Const(0, len(self
.partpoints
)+1)
322 result
, _
= self
.ls_op(self
, other
, carry
=z
, shr_flag
=1) # TODO, carry
325 def __rrshift__(self
, other
):
326 # https://bugs.libre-soc.org/show_bug.cgi?id=718
327 raise NotImplementedError
328 return Operator(">>", [other
, self
])
330 # binary ops that don't require partitioning
332 def __and__(self
, other
):
333 return applyop(self
, other
, and_
)
335 def __rand__(self
, other
):
336 return applyop(other
, self
, and_
)
338 def __or__(self
, other
):
339 return applyop(self
, other
, or_
)
341 def __ror__(self
, other
):
342 return applyop(other
, self
, or_
)
344 def __xor__(self
, other
):
345 return applyop(self
, other
, xor
)
347 def __rxor__(self
, other
):
348 return applyop(other
, self
, xor
)
350 # binary comparison ops that need partitioning
352 def _compare(self
, width
, op1
, op2
, opname
, optype
):
353 # print (opname, op1, op2)
354 pa
= PartitionedEqGtGe(width
, self
.partpoints
)
355 setattr(self
.m
.submodules
, self
.get_modname(opname
), pa
)
357 comb
+= pa
.opcode
.eq(optype
) # set opcode
358 if isinstance(op1
, SimdSignal
):
359 comb
+= pa
.a
.eq(op1
.sig
)
362 if isinstance(op2
, SimdSignal
):
363 comb
+= pa
.b
.eq(op2
.sig
)
368 def __eq__(self
, other
):
369 width
= len(self
.sig
)
370 return self
._compare
(width
, self
, other
, "eq", PartitionedEqGtGe
.EQ
)
372 def __ne__(self
, other
):
373 width
= len(self
.sig
)
374 eq
= self
._compare
(width
, self
, other
, "eq", PartitionedEqGtGe
.EQ
)
375 ne
= Signal(eq
.width
)
376 self
.m
.d
.comb
+= ne
.eq(~eq
)
379 def __lt__(self
, other
):
380 width
= len(self
.sig
)
381 # swap operands, use gt to do lt
382 return self
._compare
(width
, other
, self
, "gt", PartitionedEqGtGe
.GT
)
384 def __le__(self
, other
):
385 width
= len(self
.sig
)
386 # swap operands, use ge to do le
387 return self
._compare
(width
, other
, self
, "ge", PartitionedEqGtGe
.GE
)
389 def __gt__(self
, other
):
390 width
= len(self
.sig
)
391 return self
._compare
(width
, self
, other
, "gt", PartitionedEqGtGe
.GT
)
393 def __ge__(self
, other
):
394 width
= len(self
.sig
)
395 return self
._compare
(width
, self
, other
, "ge", PartitionedEqGtGe
.GE
)
397 # no override needed: Value.__abs__ is general enough it does the job
403 # TODO, http://bugs.libre-riscv.org/show_bug.cgi?id=716
404 # def __getitem__(self, key):
406 def __new_sign(self
, signed
):
407 shape
= Shape(len(self
), signed
=signed
)
408 result
= SimdSignal
.like(self
, shape
=shape
)
409 self
.m
.d
.comb
+= result
.sig
.eq(self
.sig
)
412 # http://bugs.libre-riscv.org/show_bug.cgi?id=719
413 def as_unsigned(self
):
414 return self
.__new
_sign
(False)
417 return self
.__new
_sign
(True)
422 """Conversion to boolean.
427 ``1`` if any bits are set, ``0`` otherwise.
429 width
= len(self
.sig
)
430 pa
= PartitionedBool(width
, self
.partpoints
)
431 setattr(self
.m
.submodules
, self
.get_modname("bool"), pa
)
432 self
.m
.d
.comb
+= pa
.a
.eq(self
.sig
)
436 """Check if any bits are ``1``.
441 ``1`` if any bits are set, ``0`` otherwise.
443 return self
!= Const(0) # leverage the __ne__ operator here
444 return Operator("r|", [self
])
447 """Check if all bits are ``1``.
452 ``1`` if all bits are set, ``0`` otherwise.
454 # something wrong with PartitionedAll, but self == Const(-1)"
455 # XXX https://bugs.libre-soc.org/show_bug.cgi?id=176#c17
456 #width = len(self.sig)
457 #pa = PartitionedAll(width, self.partpoints)
458 #setattr(self.m.submodules, self.get_modname("all"), pa)
459 #self.m.d.comb += pa.a.eq(self.sig)
461 return self
== Const(-1) # leverage the __eq__ operator here
464 """Compute pairwise exclusive-or of every bit.
469 ``1`` if an odd number of bits are set, ``0`` if an
470 even number of bits are set.
472 width
= len(self
.sig
)
473 pa
= PartitionedXOR(width
, self
.partpoints
)
474 setattr(self
.m
.submodules
, self
.get_modname("xor"), pa
)
475 self
.m
.d
.comb
+= pa
.a
.eq(self
.sig
)
478 # not needed: Value.implies does the job
479 # def implies(premise, conclusion):
481 # TODO. contains a Value.cast which means an override is needed (on both)
482 # def bit_select(self, offset, width):
483 # def word_select(self, offset, width):
485 # not needed: Value.matches, amazingly, should do the job
486 # def matches(self, *patterns):
488 # TODO, http://bugs.libre-riscv.org/show_bug.cgi?id=713
490 return self
.sig
.shape()