42compress

lib/src/arithmetic/addend_compressor.dart

@@ -152,7 +152,7 @@ abstract class BitCompressor extends Module {
   late final List<List<double>> _delays;
 
   /// Construct a column compressor.
-  BitCompressor(this.terms) {
+  BitCompressor(this.terms, {super.name = 'bitcompressor'}) {
     compressBits = [
       for (var pos = 0; pos < terms.length; pos++)
         addInput('t_$pos', terms[pos].logic)
@@ -171,7 +171,7 @@ abstract class BitCompressor extends Module {
 /// 2-input column compressor (half-adder)
 class Compressor2 extends BitCompressor {
   /// Construct a 2-input compressor (half-adder).
-  Compressor2(super.terms) {
+  Compressor2(super.terms, {super.name = 'bitcompressor2'}) {
     sum <= compressBits.xor();
     carry <= compressBits.and();
     _delays[CompressTermType.sum.index][CompressTermType.pp.index] = 1.0;
@@ -182,7 +182,7 @@ class Compressor2 extends BitCompressor {
 /// 3-input column compressor (full-adder)
 class Compressor3 extends BitCompressor {
   /// Construct a 3-input column compressor (full-adder).
-  Compressor3(super.terms) {
+  Compressor3(super.terms, {super.name = 'bitcompressor3'}) {
     sum <= compressBits.xor();
     carry <=
         mux(compressBits[0], compressBits.slice(2, 1).or(),
@@ -200,7 +200,8 @@ class Compressor4 extends BitCompressor {
   Logic get cout => output('cout');
 
   /// Construct a 4-input column compressor using two 3-input compressors.
-  Compressor4(List<CompressTerm> terms, List<CompressTerm> cinL)
+  Compressor4(List<CompressTerm> terms, List<CompressTerm> cinL,
+      {super.name = 'bitcompressor4'})
       : super(terms) {
     // We need to use internal Logic and regenerate Term lists inside
     cinL = [
@@ -270,9 +271,9 @@ class ColumnCompressor {
   ColumnCompressor(this.pp,
       {this.use42Compressors = false, this.clk, this.reset, this.enable}) {
     columns = List.generate(pp.maxWidth(), (i) => ColumnQueue());
-    if (use42Compressors) {
-      carryColumns = List.generate(pp.maxWidth(), (i) => ColumnQueue());
-    }
+    // if (use42Compressors) {
+    carryColumns = List.generate(pp.maxWidth(), (i) => ColumnQueue());
+    // }
     for (var row = 0; row < pp.rows; row++) {
       for (var col = 0; col < pp.partialProducts[row].length; col++) {
         final trueColumn = pp.rowShift[row] + col;
@@ -285,23 +286,26 @@ class ColumnCompressor {
 
   /// Return the longest column length
   int longestColumn() =>
-      columns.reduce((a, b) => a.length > b.length ? a : b).length;
+      columns.reduce((a, b) => a.length > b.length ? a : b).length +
+      carryColumns.reduce((a, b) => a.length > b.length ? a : b).length;
 
   /// Convert a row to a Logic bitvector
   Logic extractRow(int row) {
     final width = pp.maxWidth();
 
     final rowBits = <Logic>[];
     for (var col = columns.length - 1; col >= 0; col--) {
-      final colList = columns[col].toList();
+      final colList = carryColumns[col].toList() + columns[col].toList();
       if (row < colList.length) {
         final value = colList[row].logic;
 
         rowBits.add(
             clk != null ? flop(clk!, value, reset: reset, en: enable) : value);
+      } else {
+        rowBits.add(Const(0));
       }
     }
-    rowBits.addAll(List.filled(pp.rowShift[row], Const(0)));
+    // rowBits.addAll(List.filled(pp.rowShift[row], Const(0)));
     if (width > rowBits.length) {
       return rowBits.swizzle().zeroExtend(width);
     }
@@ -319,7 +323,7 @@ class ColumnCompressor {
       } else {
         carryQueue = PriorityQueue<CompressTerm>();
       }
-      final depth = queue.length;
+      final depth = queue.length + carryQueue.length;
       if (depth > iteration) {
         if (depth > 2) {
           final first = queue.removeFirst();
@@ -333,7 +337,6 @@ class ColumnCompressor {
             inputs
               ..add(queue.removeFirst())
               ..add(queue.removeFirst());
-
             compressor = Compressor4(inputs, [cin]);
             if (col < columns.length - 1) {
               final t = CompressTerm(compressor, CompressTermType.carry,

lib/src/arithmetic/evaluate_compressor.dart

@@ -24,23 +24,30 @@ extension EvaluateLiveColumnCompressor on ColumnCompressor {
       bool logic = false,
       bool header = true,
       int prefix = 1,
-      int extraSpace = 5}) {
+      int extraSpace = 0}) {
     final ts = StringBuffer();
     final rows = longestColumn();
     final width = pp.maxWidth();
     var accum = BigInt.zero;
 
     for (var row = 0; row < rows; row++) {
+      final int shift;
+      if (row >= pp.rows) {
+        shift = pp.rowShift[pp.rows - 1];
+      } else {
+        shift = pp.rowShift[row];
+      }
       final rowLogic = <Logic>[];
       for (var col = columns.length - 1; col >= 0; col--) {
-        final colList = columns[col].toList();
+        final colList = carryColumns[col].toList() + columns[col].toList();
         if (row < colList.length) {
           rowLogic.insert(0, colList[row].logic);
+        } else if (col >= shift) {
+          // rowLogic.insert(0, Const(0));
         }
       }
-      final rowBits = [for (final c in rowLogic) c.value].reversed.toList();
-      // ignore: cascade_invocations
-      rowBits.addAll(List.filled(pp.rowShift[row], LogicValue.zero));
+      final rowBits = [for (final c in rowLogic) c.value].reversed.toList()
+        ..addAll(List.filled(shift, LogicValue.zero));
       final rowBitsExtend = rowBits.length < width
           ? rowBits.swizzle().zeroExtend(width)
           : rowBits.swizzle();
@@ -53,7 +60,7 @@ extension EvaluateLiveColumnCompressor on ColumnCompressor {
             prefix: prefix,
             extraSpace: extraSpace,
             intValue: true,
-            shift: pp.rowShift[row]))
+            shift: shift))
         ..write('\n');
     }
 
@@ -67,15 +74,23 @@ extension EvaluateLiveColumnCompressor on ColumnCompressor {
   }
 
   /// Return a string representing the compression tree in its current state
-  String representation() {
+  String representation({bool evalLogic = false, bool useTabs = true}) {
     final ts = StringBuffer();
+
+    final sep = useTabs ? '\t' : '  ';
+
     for (var row = 0; row < longestColumn(); row++) {
+      ts.write(useTabs ? '' : ' ');
       for (var col = columns.length - 1; col >= 0; col--) {
-        final colList = columns[col].toList();
+        final colList = columns[col].toList() + carryColumns[col].toList();
         if (row < colList.length) {
-          ts.write('\t${colList[row]}');
+          if (evalLogic) {
+            ts.write('$sep${colList[row].logic.value.toInt()}');
+          } else {
+            ts.write('$sep${colList[row]}');
+          }
         } else {
-          ts.write('\t');
+          ts.write(useTabs ? sep : '$sep ');
         }
       }
       ts.write('\n');

lib/src/arithmetic/multiplier.dart

@@ -250,7 +250,6 @@ class CompressionTreeMultiplier extends Multiplier {
               Logic? selectSignedMultiplicand})
           ppGen = PartialProductGeneratorCompactRectSignExtension.new,
       bool use42Compressors = false,
-      super.signed = false,
       super.name = 'compression_tree_multiplier'}) {
     clk = (clk != null) ? addInput('clk', clk!) : null;
     reset = (reset != null) ? addInput('reset', reset!) : null;
@@ -266,17 +265,17 @@ class CompressionTreeMultiplier extends Multiplier {
       selectSignedMultiplier: selectSignedMultiplier,
       signedMultiplier: signedMultiplier,
     );
-
     final compressor = ColumnCompressor(
-        clk: iClk,
-        reset: iReset,
-        enable: iEnable,
+        clk: clk,
+        reset: reset,
+        enable: enable,
         pp,
         use42Compressors: use42Compressors)
       ..compress();
     final adder = ParallelPrefixAdder(
         compressor.extractRow(0), compressor.extractRow(1),
         ppGen: ppTree);
+
     product <= adder.sum.slice(a.width + b.width - 1, 0);
   }
 }
@@ -394,9 +393,9 @@ class CompressionTreeMultiplyAccumulate extends MultiplyAccumulate {
     pp.rowShift.insert(0, 0);
 
     final compressor = ColumnCompressor(
-        clk: iClk,
-        reset: iReset,
-        enable: iEnable,
+        clk: clk,
+        reset: reset,
+        enable: enable,
         pp,
         use42Compressors: use42Compressors)
       ..compress();

lib/src/component_config/components/config_compression_tree_multiplier.dart

@@ -17,7 +17,7 @@ class CompressionTreeMultiplierConfigurator extends Configurator {
   /// Map from Type to Function for Parallel Prefix generator
   static Map<Type,
           ParallelPrefix Function(List<Logic>, Logic Function(Logic, Logic))>
-      generatorMap = {
+      ppGeneratorMap = {
     Ripple: Ripple.new,
     Sklansky: Sklansky.new,
     KoggeStone: KoggeStone.new,
@@ -26,7 +26,7 @@ class CompressionTreeMultiplierConfigurator extends Configurator {
 
   /// Controls the type of [ParallelPrefix] tree used in the adder.
   final prefixTreeKnob =
-      ChoiceConfigKnob(generatorMap.keys.toList(), value: KoggeStone);
+      ChoiceConfigKnob(ppGeneratorMap.keys.toList(), value: KoggeStone);
 
   /// Controls the Booth encoding radix of the multiplier.!
   final radixKnob = ChoiceConfigKnob<int>(
@@ -60,7 +60,13 @@ class CompressionTreeMultiplierConfigurator extends Configurator {
       Logic(name: 'a', width: multiplicandWidthKnob.value),
       Logic(name: 'b', width: multiplierWidthKnob.value),
       radixKnob.value,
-      ppTree: generatorMap[prefixTreeKnob.value]!,
+      signedMultiplicand: signMultiplicandValueKnob.value == 'signed',
+      signedMultiplier: signMultiplierValueKnob.value == 'signed',
+      selectSignedMultiplicand:
+          signMultiplicandValueKnob.value == 'selected' ? Logic() : null,
+      selectSignedMultiplier:
+          signMultiplierValueKnob.value == 'selected' ? Logic() : null,
+      ppTree: ppGeneratorMap[prefixTreeKnob.value]!,
       use42Compressors: use42CompressorsKnob.value);
 
   @override