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 PartitionedSignal 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.equal_ortree import PartitionedEq
21 from ieee754
.part_cmp
.eq_gt_ge
import PartitionedEqGtGe
22 from ieee754
.part_mul_add
.partpoints
import make_partition
23 from operator
import or_
, xor
, and_
, not_
25 from nmigen
import (Signal
,
27 def applyop(op1
, op2
, op
):
28 if isinstance(op1
, PartitionedSignal
):
30 if isinstance(op2
, PartitionedSignal
):
35 class PartitionedSignal
:
36 def __init__(self
, mask
, *args
, **kwargs
):
37 self
.sig
= Signal(*args
, **kwargs
)
38 width
= self
.sig
.shape()[0] # get signal width
39 self
.partpoints
= make_partition(mask
, width
) # create partition points
41 for name
in ['add', 'eq', 'gt']:
42 self
.modnames
[name
] = 0
44 def set_module(self
, m
):
47 def get_modname(self
, category
):
48 self
.modnames
[category
] += 1
49 return "%s%d" % (category
, self
.modnames
[category
])
52 return self
.sig
.eq(val
)
54 def __and__(self
, other
):
55 return applyop(self
, other
, and_
)
57 def __rand__(self
, other
):
58 return applyop(other
, self
, and_
)
60 def __or__(self
, other
):
61 return applyop(self
, other
, or_
)
63 def __ror__(self
, other
):
64 return applyop(other
, self
, or_
)
66 def __xor__(self
, other
):
67 return applyop(self
, other
, xor
)
69 def __rxor__(self
, other
):
70 return applyop(other
, self
, xor
)
72 def __add__(self
, other
):
73 shape
= self
.sig
.shape()
74 pa
= PartitionedAdder(shape
[0], self
.partpoints
)
75 setattr(self
.m
.submodules
, self
.get_modname('add'), pa
)
77 comb
+= pa
.a
.eq(self
.sig
)
78 if isinstance(other
, PartitionedSignal
):
79 comb
+= pa
.b
.eq(other
.sig
)
81 comb
+= pa
.b
.eq(other
)
84 def __eq__(self
, other
):
85 shape
= self
.sig
.shape()
86 pa
= PartitionedEqGtGe(shape
[0], self
.partpoints
)
87 setattr(self
.m
.submodules
, self
.get_modname('eq'), pa
)
89 comb
+= pa
.opcode
.eq(PartitionedEqGtGe
.EQ
) # set opcode to EQ
90 comb
+= pa
.a
.eq(self
.sig
)
91 if isinstance(other
, PartitionedSignal
):
92 comb
+= pa
.b
.eq(other
.sig
)
94 comb
+= pa
.b
.eq(other
)
97 def __gt__(self
, other
):
98 print ("gt", self
, other
)
99 shape
= self
.sig
.shape()
100 pa
= PartitionedEqGtGe(shape
[0], self
.partpoints
)
101 setattr(self
.m
.submodules
, self
.get_modname('gt'), pa
)
103 comb
+= pa
.opcode
.eq(PartitionedEqGtGe
.GT
) # set opcode to GT
104 comb
+= pa
.a
.eq(self
.sig
)
105 if isinstance(other
, PartitionedSignal
):
106 comb
+= pa
.b
.eq(other
.sig
)
108 comb
+= pa
.b
.eq(other
)