[Synth] Refactor and expose dropNonCriticalPaths to Python bindings (#9141)

Refactored LongestPathCollection::sortAndDropNonCriticalPathsPerEndPoint
to dropNonCriticalPaths with a parameter to filter by end point or start
point. Separated sorting from dropping for better control. Exposed the
functionality through C API and Python bindings.

Author: uenoku

include/circt-c/Dialect/Synth.h

@@ -104,6 +104,9 @@ MLIR_CAPI_EXPORTED void
 synthLongestPathCollectionMerge(SynthLongestPathCollection dest,
                                 SynthLongestPathCollection src);
 
+MLIR_CAPI_EXPORTED void synthLongestPathCollectionDropNonCriticalPaths(
+    SynthLongestPathCollection collection, bool perEndPoint);
+
 //===----------------------------------------------------------------------===//
 // DataflowPath API
 //===----------------------------------------------------------------------===//

include/circt/Dialect/Synth/Analysis/LongestPathAnalysis.h

@@ -342,8 +342,8 @@ class LongestPathCollection {
   // Sort the paths by delay in descending order.
   void sortInDescendingOrder();
 
-  // Sort and drop all paths except the longest path per end point.
-  void sortAndDropNonCriticalPathsPerEndPoint();
+  // Drop all paths except the longest path per end point or start point.
+  void dropNonCriticalPaths(bool perEndPoint = true);
 
   // Merge another collection into this one.
   void merge(const LongestPathCollection &other);

integration_test/Bindings/Python/dialects/synth.py

@@ -133,6 +133,15 @@ def build_top(module):
     # CHECK: top:test_aig;child:test_child;a[0] 2
     print(collection.longest_path.to_flamegraph())
 
+    original_length = len(collection)
+    collection.drop_non_critical_paths(per_end_point=True)
+    after_per_end_point = len(collection)
+    collection.drop_non_critical_paths(per_end_point=False)
+    after_per_start_point = len(collection)
+    # CHECK-NEXT: drop_non_critical_paths: True True
+    print("drop_non_critical_paths:", original_length > after_per_end_point,
+          after_per_end_point > after_per_start_point)
+
     test_child = m.body.operations[0]
     body_block = test_child.regions[0].blocks[0]
     result0 = body_block.operations[0].results[0]

lib/Bindings/Python/SynthModule.cpp

@@ -128,10 +128,15 @@ void circt::python::populateDialectSynthSubmodule(nb::module_ &m) {
               int pathIndex) -> SynthLongestPathDataflowPath {
              return synthLongestPathCollectionGetDataflowPath(self, pathIndex);
            })
-      .def("merge", [](SynthLongestPathCollection &self,
-                       SynthLongestPathCollection &src) {
-        synthLongestPathCollectionMerge(self, src);
-      });
+      .def("merge",
+           [](SynthLongestPathCollection &self,
+              SynthLongestPathCollection &src) {
+             synthLongestPathCollectionMerge(self, src);
+           })
+      .def("drop_non_critical_paths",
+           [](SynthLongestPathCollection &self, bool perEndPoint) {
+             synthLongestPathCollectionDropNonCriticalPaths(self, perEndPoint);
+           });
 
   nb::class_<SynthLongestPathDataflowPath>(m, "_LongestPathDataflowPath")
       .def_prop_ro("delay",

lib/Bindings/Python/dialects/synth.py

@@ -332,6 +332,17 @@ def merge(self, src: "LongestPathCollection"):
     # Re-initialize to reflect the merged collection
     self.__init__(self.collection)
 
+  def drop_non_critical_paths(self, per_end_point: bool = True):
+    """
+        Drop all paths except the longest path per end point or start point.
+        Args:
+            per_end_point: Whether to keep only the longest path per end point
+                           (True) or per start point (False)
+    """
+    self.collection.drop_non_critical_paths(per_end_point)
+    # Re-initialize to reflect the dropped paths
+    self.__init__(self.collection)
+
 
 # ============================================================================
 # Main Analysis Interface

lib/CAPI/Dialect/Synth.cpp

@@ -203,6 +203,12 @@ void synthLongestPathCollectionMerge(SynthLongestPathCollection dest,
   destWrapper->merge(*srcWrapper);
 }
 
+void synthLongestPathCollectionDropNonCriticalPaths(
+    SynthLongestPathCollection collection, bool perEndPoint) {
+  auto *wrapper = unwrap(collection);
+  wrapper->dropNonCriticalPaths(perEndPoint);
+}
+
 //===----------------------------------------------------------------------===//
 // DataflowPath
 //===----------------------------------------------------------------------===//

lib/Dialect/Synth/Analysis/LongestPathAnalysis.cpp

@@ -2047,17 +2047,24 @@ void LongestPathCollection::sortInDescendingOrder() {
   });
 }
 
-void LongestPathCollection::sortAndDropNonCriticalPathsPerEndPoint() {
-  sortInDescendingOrder();
-  // Deduplicate paths by end-point, keeping only the worst-case delay per
-  // end-point. This gives us the critical delay for each end-point in the
-  // design
-  llvm::DenseSet<DataflowPath::EndPointType> seen;
-  for (size_t i = 0; i < paths.size(); ++i) {
-    if (seen.insert(paths[i].getEndPoint()).second)
-      paths[seen.size() - 1] = std::move(paths[i]);
+void LongestPathCollection::dropNonCriticalPaths(bool perEndPoint) {
+  // Deduplicate paths by start/end-point, keeping only the worst-case delay.
+  if (perEndPoint) {
+    llvm::DenseSet<DataflowPath::EndPointType> seen;
+    for (size_t i = 0; i < paths.size(); ++i) {
+      if (seen.insert(paths[i].getEndPoint()).second)
+        paths[seen.size() - 1] = std::move(paths[i]);
+    }
+
+    paths.resize(seen.size());
+  } else {
+    llvm::DenseSet<Object> seen;
+    for (size_t i = 0; i < paths.size(); ++i) {
+      if (seen.insert(paths[i].getStartPoint()).second)
+        paths[seen.size() - 1] = std::move(paths[i]);
+    }
+    paths.resize(seen.size());
   }
-  paths.resize(seen.size());
 }
 
 void LongestPathCollection::merge(const LongestPathCollection &other) {

lib/Dialect/Synth/Analysis/PrintLongestPathAnalysis.cpp

@@ -94,7 +94,8 @@ LogicalResult PrintLongestPathAnalysisPass::printAnalysisResult(
   }
 
   size_t oldPathCount = collection.paths.size();
-  collection.sortAndDropNonCriticalPathsPerEndPoint();
+  collection.sortInDescendingOrder();
+  collection.dropNonCriticalPaths(/*perEndPoint=*/true);
   auto &longestPathForEachEndPoint = collection.paths;
 
   // Print analysis header

test/CAPI/CMakeLists.txt

@@ -108,6 +108,7 @@ target_link_libraries(circt-capi-synth-test
   PRIVATE
 
   MLIRCAPIIR
+  CIRCTCAPIComb
   CIRCTCAPIHW
   CIRCTCAPISeq
   CIRCTCAPISynth

test/CAPI/synth.c

@@ -10,6 +10,7 @@
  */
 
 #include "circt-c/Dialect/Synth.h"
+#include "circt-c/Dialect/Comb.h"
 #include "circt-c/Dialect/HW.h"
 #include "circt-c/Dialect/Seq.h"
 #include "mlir-c/BuiltinAttributes.h"
@@ -39,12 +40,17 @@ void testLongestPathAnalysis(void) {
   mlirDialectHandleLoadDialect(mlirGetDialectHandle__synth__(), ctx);
   mlirDialectHandleLoadDialect(mlirGetDialectHandle__hw__(), ctx);
   mlirDialectHandleLoadDialect(mlirGetDialectHandle__seq__(), ctx);
+  mlirDialectHandleLoadDialect(mlirGetDialectHandle__comb__(), ctx);
 
   // clang-format off
   const char *moduleStr =
       "hw.module private @ch(in %c : !seq.clock, in %a: i2, out x: i2) {\n"
       "  %p = seq.compreg %q, %c : i2\n"
-      "  %q = synth.aig.and_inv %p, %p {sv.namehint = \"q\"}: i2\n"
+      "  %p0 = comb.extract %p from 0 : (i2) -> i1\n"
+      "  %p1 = comb.extract %p from 1 : (i2) -> i1\n"
+      "  %q0 = synth.aig.and_inv %p0, %p1  : i1\n"
+      "  %q1 = synth.aig.and_inv %p0, not %p1 : i1\n"
+      "  %q = comb.concat %q0, %q1 {sv.namehint = \"q\"} : i1, i1\n"
       "  hw.output %p: i2\n"
       "}\n"
       "hw.module private @top(in %c : !seq.clock, in %a: i2) {\n"
@@ -71,11 +77,11 @@ void testLongestPathAnalysis(void) {
 
     size_t pathCount = synthLongestPathCollectionGetSize(collection1);
     printf("Path count with elaboration: %zu\n", pathCount);
-    // CHECK: Path count with elaboration: 4
+    // CHECK: Path count with elaboration: 8
 
     pathCount = synthLongestPathCollectionGetSize(collection2);
     printf("Path count without elaboration: %zu\n", pathCount);
-    // CHECK: Path count without elaboration: 2
+    // CHECK: Path count without elaboration: 4
 
     // Test DataflowPath API
     if (pathCount > 0) {
@@ -101,8 +107,8 @@ void testLongestPathAnalysis(void) {
              startPointName.data, startPointBitPos);
       printf("EndPoint: %.*s[%zu]\n", (int)endPointName.length,
              endPointName.data, endPointBitPos);
-      // CHECK: StartPoint: p[[[BIT:[0-9]]]]
-      // CHECK: EndPoint: p[[[BIT]]]
+      // CHECK: StartPoint: p[{{[0-9]}}]
+      // CHECK: EndPoint: p[{{[0-9]}}]
 
       // Test instance path
       IgraphInstancePath startPointPath =
@@ -162,6 +168,19 @@ void testLongestPathAnalysis(void) {
     // CHECK: Input-to-internal paths count: 0
     // CHECK-NEXT: Internal-to-output paths count: 2
 
+    printf("Path count before drop: %zu\n",
+           synthLongestPathCollectionGetSize(collection1));
+    // CHECK: Path count before drop: 8
+    synthLongestPathCollectionDropNonCriticalPaths(collection1, true);
+    size_t pathCountAfterDrop = synthLongestPathCollectionGetSize(collection1);
+    printf("Path count after drop perEndPoint=true: %zu\n", pathCountAfterDrop);
+    // CHECK: Path count after drop perEndPoint=true: 4
+    synthLongestPathCollectionDropNonCriticalPaths(collection1, false);
+    pathCountAfterDrop = synthLongestPathCollectionGetSize(collection1);
+    printf("Path count after drop perEndPoint=false: %zu\n",
+           pathCountAfterDrop);
+    // CHECK: Path count after drop perEndPoint=false: 2
+
     // Cleanup
     synthLongestPathCollectionDestroy(collection1);
     synthLongestPathCollectionDestroy(collection2);