[AIG][DatapathToComb] Implement incremental longest path analysis for IR transformations

This commit introduces IncrementalLongestPathAnalysis to support lazy computation of delay information during IR mutations in synthesis passes. The analysis is updated incrementally so that we can lazily compute the delay while performing IR mutations.
A first use case is the DatapathToComb conversion pass.

Key changes include adding the IncrementalLongestPathAnalysis class that extends the existing longest path analysis with incremental update capabilities. The implementation includes the PatternRewriter::Listener interface to track IR mutations and maintain analysis validity. New getOrComputeDelay() and getOrComputePaths() methods enable on-demand delay computation, and the incremental analysis is integrated into DatapathCompressOpConversion for timing-aware compress operation lowering.

The longest path analysis is inherently complex and use-def chains must be taken into account when rewriting the IR. A top-down rewriting approach is necessary to maintain analysis correctness, as bottom-up mutations can invalidate paths that depend on erased values.

The incremental analysis validates that IR mutations don't break existing timing paths and provides early error detection when values used in critical paths are inappropriately modified.

Author: uenoku

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

@@ -22,6 +22,7 @@
 #include "circt/Support/LLVM.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Operation.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/ImmutableList.h"
 #include "llvm/ADT/SmallVector.h"
@@ -171,6 +172,11 @@ llvm::json::Value toJSON(const circt::aig::DataflowPath &path);
 // Options for the longest path analysis.
 struct LongestPathAnalysisOption {
   bool traceDebugPoints = false;
+  bool incremental = false;
+
+  LongestPathAnalysisOption(bool traceDebugPoints, bool incremental)
+      : traceDebugPoints(traceDebugPoints), incremental(incremental) {}
+  LongestPathAnalysisOption() = default;
 };
 
 // This analysis finds the longest paths in the dataflow graph across modules.
@@ -248,19 +254,47 @@ class LongestPathAnalysis {
 
   MLIRContext *getContext() const { return ctx; }
 
-private:
+protected:
+  friend class IncrementalLongestPathAnalysis;
   struct Impl;
   Impl *impl;
 
+private:
   mlir::MLIRContext *ctx;
 };
 
+// For incremental updates, this class exposes subset of the analysis results
+// and allows incremental updates.
+class IncrementalLongestPathAnalysis : private LongestPathAnalysis,
+                                       public mlir::PatternRewriter::Listener {
+public:
+  IncrementalLongestPathAnalysis(Operation *moduleOp, mlir::AnalysisManager &am)
+      : LongestPathAnalysis(moduleOp, am,
+                            LongestPathAnalysisOption(false, true)) {}
+
+  FailureOr<int64_t> getOrComputeDelay(Value value, size_t bitPos);
+  FailureOr<ArrayRef<OpenPath>> getOrComputePaths(Value value, size_t bitPos);
+
+  // Returns true if the analysis is still valid after the value is erased.
+  // If the client erased a value, then the analyais cannot be used anymore.
+  // A client should check this before erasing a value, and if this
+  // returns false, the client should raise an error or should not rely on the
+  // analysis.
+  bool isValueValidToErase(Value value) const;
+
+  // MLIR PatternRewriter::Listener interface.
+  void notifyOperationReplaced(Operation *op, ValueRange replacement) override;
+  void notifyOperationErased(Operation *op) override;
+
+  bool isAnalysisValid = true;
+};
+
 // A wrapper class for the longest path analysis that also traces debug points.
 // This is necessary for analysis manager to cache the analysis results.
 class LongestPathAnalysisWithTrace : public LongestPathAnalysis {
 public:
   LongestPathAnalysisWithTrace(Operation *moduleOp, mlir::AnalysisManager &am)
-      : LongestPathAnalysis(moduleOp, am, {true}) {}
+      : LongestPathAnalysis(moduleOp, am, {true, false}) {}
 };
 
 // A collection of longest paths. The data structure owns the paths, and used

lib/Conversion/DatapathToComb/DatapathToComb.cpp

@@ -7,9 +7,11 @@
 //===----------------------------------------------------------------------===//
 
 #include "circt/Conversion/DatapathToComb.h"
+#include "circt/Dialect/AIG/Analysis/LongestPathAnalysis.h"
 #include "circt/Dialect/Comb/CombOps.h"
 #include "circt/Dialect/Datapath/DatapathOps.h"
 #include "circt/Dialect/HW/HWOps.h"
+#include "mlir/Analysis/TopologicalSortUtils.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
@@ -62,6 +64,10 @@ struct DatapathCompressOpAddConversion : OpConversionPattern<CompressOp> {
 // Replace compressor by a wallace tree of full-adders
 struct DatapathCompressOpConversion : OpConversionPattern<CompressOp> {
   using OpConversionPattern<CompressOp>::OpConversionPattern;
+  DatapathCompressOpConversion(MLIRContext *context,
+                               aig::IncrementalLongestPathAnalysis *analysis)
+      : OpConversionPattern<CompressOp>(context), analysis(analysis) {}
+
   LogicalResult
   matchAndRewrite(CompressOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
@@ -73,17 +79,45 @@ struct DatapathCompressOpConversion : OpConversionPattern<CompressOp> {
     for (auto input : inputs) {
       addends.push_back(
           extractBits(rewriter, input)); // Extract bits from each input
+
+      // NOTE: Following change will be splitted into a separate PR.
+      if (analysis) {
+        auto delay = analysis->getOrComputePaths(input, 0);
+        if (failed(delay))
+          return op.emitError("Failed to get delay for input");
+        // TODO: Use the delay information to sort the inputs.
+      }
+
+      LLVM_DEBUG({
+        llvm::dbgs() << "Input: " << input << " delay: ";
+        assert(analysis && "Expected analysis to be set");
+        if (analysis) {
+          auto delay = analysis->getOrComputeDelay(
+              input, 0); // Query delay for each input
+          if (llvm::succeeded(delay))
+            llvm::dbgs() << *delay;
+          else
+            llvm::dbgs() << "N/A";
+        } else {
+          llvm::dbgs() << "N/A(analysis not set)";
+        }
+        llvm::dbgs() << "\n";
+      });
     }
 
     // Wallace tree reduction
-    // TODO - implement a more efficient compression algorithm to compete with
+    // TODO: Implement a more efficient compression algorithm to compete with
     // yosys's `alumacc` lowering - a coarse grained timing model would help to
     // sort the inputs according to arrival time.
+    // TODO: Use the listener to get arrival time information.
     auto targetAddends = op.getNumResults();
     rewriter.replaceOp(op, comb::wallaceReduction(rewriter, loc, width,
                                                   targetAddends, addends));
     return success();
   }
+
+private:
+  aig::IncrementalLongestPathAnalysis *analysis = nullptr;
 };
 
 struct DatapathPartialProductOpConversion
@@ -254,6 +288,22 @@ struct ConvertDatapathToCombPass
 };
 } // namespace
 
+static LogicalResult
+applyConversionWithTimingInfo(Operation *op, const ConversionTarget &target,
+                              RewritePatternSet &&patterns,
+                              aig::IncrementalLongestPathAnalysis *analysis) {
+  // TODO: Topologically sort the operations in the module to ensure that all
+  // dependencies are processed before their users.
+  mlir::ConversionConfig config;
+  config.listener = analysis;
+
+  // Apply the conversion patterns
+  if (failed(mlir::applyPartialConversion(op, target, std::move(patterns))))
+    return failure();
+
+  return success();
+}
+
 void ConvertDatapathToCombPass::runOnOperation() {
   ConversionTarget target(getContext());
 
@@ -264,15 +314,16 @@ void ConvertDatapathToCombPass::runOnOperation() {
 
   patterns.add<DatapathPartialProductOpConversion>(patterns.getContext(),
                                                    forceBooth);
-
+  auto &analysis = getAnalysis<aig::IncrementalLongestPathAnalysis>();
   if (lowerCompressToAdd)
     // Lower compressors to simple add operations for downstream optimisations
     patterns.add<DatapathCompressOpAddConversion>(patterns.getContext());
   else
     // Lower compressors to a complete gate-level implementation
-    patterns.add<DatapathCompressOpConversion>(patterns.getContext());
+    patterns.add<DatapathCompressOpConversion>(patterns.getContext(),
+                                               &analysis);
 
-  if (failed(mlir::applyPartialConversion(getOperation(), target,
-                                          std::move(patterns))))
+  if (failed(applyConversionWithTimingInfo(getOperation(), target,
+                                           std::move(patterns), &analysis)))
     return signalPassFailure();
 }

lib/Dialect/AIG/Analysis/LongestPathAnalysis.cpp

@@ -65,6 +65,7 @@
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/raw_ostream.h"
 #include <condition_variable>
+#include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <mutex>
@@ -73,7 +74,7 @@
 using namespace circt;
 using namespace aig;
 
-static size_t getBitWidth(Value value) {
+static int64_t getBitWidth(Value value) {
   if (auto vecType = dyn_cast<seq::ClockType>(value.getType()))
     return 1;
   if (auto memory = dyn_cast<seq::FirMemType>(value.getType()))
@@ -409,12 +410,16 @@ class Context {
   // Lookup a local visitor for `name`, and wait until it's done.
   const LocalVisitor *getAndWaitLocalVisitor(StringAttr name) const;
 
+  // Lookup a mutable local visitor for `name`.
+  LocalVisitor *getLocalVisitorMutable(StringAttr name) const;
+
   // A map from the module name to the local visitor.
   llvm::MapVector<StringAttr, std::unique_ptr<LocalVisitor>> localVisitors;
   // This is non-null only if `module` is a ModuleOp.
   circt::igraph::InstanceGraph *instanceGraph = nullptr;
 
   bool doTraceDebugPoints() const { return option.traceDebugPoints; }
+  bool doIncremental() const { return option.incremental; }
 
 private:
   llvm::sys::SmartMutex<true> mutex;
@@ -1057,6 +1062,9 @@ LogicalResult LocalVisitor::initializeAndRun(hw::OutputOp output) {
 }
 
 LogicalResult LocalVisitor::initializeAndRun() {
+  if (ctx->doIncremental())
+    return success();
+
   LLVM_DEBUG({ ctx->notifyStart(module.getModuleNameAttr()); });
   // Initialize the results for the block arguments.
   for (auto blockArgument : module.getBodyBlock()->getArguments())
@@ -1129,6 +1137,15 @@ const LocalVisitor *Context::getAndWaitLocalVisitor(StringAttr name) const {
   return visitor;
 }
 
+LocalVisitor *Context::getLocalVisitorMutable(StringAttr name) const {
+  auto *it = localVisitors.find(name);
+  if (it == localVisitors.end())
+    return nullptr;
+
+  // NOTE: Don't call waitUntilDone here.
+  return it->second.get();
+}
+
 //===----------------------------------------------------------------------===//
 // LongestPathAnalysis::Impl
 //===----------------------------------------------------------------------===//
@@ -1159,6 +1176,13 @@ struct LongestPathAnalysis::Impl {
 
   llvm::ArrayRef<hw::HWModuleOp> getTopModules() const { return topModules; }
 
+  // Incremental mode.
+  bool doIncremental() const { return ctx.doIncremental(); }
+
+protected:
+  friend class IncrementalLongestPathAnalysis;
+  FailureOr<ArrayRef<OpenPath>> getOrComputePaths(Value value, size_t bitPos);
+
 private:
   LogicalResult getResultsImpl(
       const Object &originalObject, Value value, size_t bitPos,
@@ -1330,6 +1354,7 @@ LongestPathAnalysis::Impl::Impl(Operation *moduleOp, mlir::AnalysisManager &am,
     llvm::report_fatal_error("Analysis scheduled on invalid operation");
   }
 }
+
 LogicalResult
 LongestPathAnalysis::Impl::initializeAndRun(hw::HWModuleOp module) {
   auto it =
@@ -1459,6 +1484,31 @@ int64_t LongestPathAnalysis::Impl::getMaxDelay(Value value) const {
   return maxDelay;
 }
 
+FailureOr<ArrayRef<OpenPath>>
+LongestPathAnalysis::Impl::getOrComputePaths(Value value, size_t bitPos) {
+  if (!doIncremental())
+    return mlir::emitError(value.getLoc())
+           << "getOrComputeMaxDelay is only available in incremental mode";
+  if (ctx.instanceGraph)
+    return mlir::emitError(value.getLoc())
+           << "inceremental mode is not supported for global analysis";
+  auto parentHWModule =
+      value.getParentRegion()->getParentOfType<hw::HWModuleOp>();
+  if (!parentHWModule)
+    return mlir::emitError(value.getLoc())
+           << "query value is not in a HWModuleOp";
+  assert(ctx.localVisitors.size() == 1 &&
+         "In incremental mode, there should be only one local visitor");
+
+  auto *localVisitor =
+      ctx.getLocalVisitorMutable(parentHWModule.getModuleNameAttr());
+  if (!localVisitor)
+    return mlir::emitError(value.getLoc())
+           << "the local visitor for the given value does not exist";
+  auto path = localVisitor->getOrComputeResults(value, bitPos);
+  return path;
+}
+
 //===----------------------------------------------------------------------===//
 // LongestPathAnalysis
 //===----------------------------------------------------------------------===//
@@ -1468,7 +1518,13 @@ LongestPathAnalysis::~LongestPathAnalysis() { delete impl; }
 LongestPathAnalysis::LongestPathAnalysis(
     Operation *moduleOp, mlir::AnalysisManager &am,
     const LongestPathAnalysisOption &option)
-    : impl(new Impl(moduleOp, am, option)), ctx(moduleOp->getContext()) {}
+    : impl(new Impl(moduleOp, am, option)), ctx(moduleOp->getContext()) {
+  llvm::errs() << "LongestPathAnalysis created\n";
+  if (option.traceDebugPoints)
+    llvm::errs() << " - Tracing debug points\n";
+  if (option.incremental)
+    llvm::errs() << " - Incremental analysis enabled\n";
+}
 
 bool LongestPathAnalysis::isAnalysisAvailable(StringAttr moduleName) const {
   return impl->isAnalysisAvailable(moduleName);
@@ -1518,6 +1574,82 @@ ArrayRef<hw::HWModuleOp> LongestPathAnalysis::getTopModules() const {
   return impl->getTopModules();
 }
 
+// === --------------------------------------------------------------------===//
+// InrementalLongestPathAnalysis
+// === --------------------------------------------------------------------===//
+
+FailureOr<ArrayRef<OpenPath>>
+IncrementalLongestPathAnalysis::getOrComputePaths(Value value, size_t bitPos) {
+  if (!isAnalysisValid)
+    return failure();
+
+  return impl->getOrComputePaths(value, bitPos);
+}
+
+FailureOr<int64_t>
+IncrementalLongestPathAnalysis::getOrComputeDelay(Value value, size_t bitPos) {
+  if (!isAnalysisValid)
+    return failure();
+
+  auto result = impl->getOrComputePaths(value, bitPos);
+  if (failed(result))
+    return failure();
+  int64_t maxDelay = 0;
+  for (auto &path : *result)
+    maxDelay = std::max(maxDelay, path.delay);
+  return maxDelay;
+}
+
+bool IncrementalLongestPathAnalysis::isValueValidToErase(Value value) const {
+  if (!isAnalysisValid)
+    return false;
+
+  auto parentHWModule =
+      value.getParentRegion()->getParentOfType<hw::HWModuleOp>();
+  if (!parentHWModule)
+    return true;
+  auto *localVisitor =
+      impl->ctx.getLocalVisitor(parentHWModule.getModuleNameAttr());
+  if (!localVisitor)
+    return true;
+
+  auto end = getBitWidth(value);
+  if (end <= 0)
+    return true;
+
+  for (int64_t i = 0, e = getBitWidth(value); i < e; ++i) {
+    auto path = localVisitor->getResults(value, i);
+    if (!path.empty())
+      return false;
+  }
+  return true;
+}
+
+void IncrementalLongestPathAnalysis::notifyOperationReplaced(
+    Operation *op, ValueRange replacement) {
+  for (auto value : op->getResults()) {
+    if (isValueValidToErase(value)) {
+      mlir::emitError(value.getLoc())
+          << "value " << value
+          << " replaced but contained in longest path analysis. It's required "
+             "to perform the IR mutation from buttom-up";
+      isAnalysisValid = false;
+    }
+  }
+}
+
+void IncrementalLongestPathAnalysis::notifyOperationErased(Operation *op) {
+  for (auto value : op->getResults()) {
+    if (isValueValidToErase(value)) {
+      mlir::emitError(value.getLoc())
+          << "value " << value
+          << " replaced but contained in longest path analysis. It's required "
+             "to perform the IR mutation from buttom-up";
+      isAnalysisValid = false;
+    }
+  }
+}
+
 // ===----------------------------------------------------------------------===//
 // LongestPathCollection
 // ===----------------------------------------------------------------------===//