[Synth][LongestPathAnalysis] Remove hack for passing top module name through IR attribute (#9006)

This removes a hack `synth.longest-path-analysis-top` which was put to IR in order to pass a top name to analysis. The top module name is now passed explicitly as a parameter to the LongestPathAnalysis constructor and related APIs instead of being stored as an IR attribute.

Author: uenoku

include/circt-c/Dialect/Synth.h

@@ -51,7 +51,7 @@ DEFINE_C_API_STRUCT(SynthLongestPathCollection, void);
 // Create a LongestPathAnalysis for the given module
 MLIR_CAPI_EXPORTED SynthLongestPathAnalysis synthLongestPathAnalysisCreate(
     MlirOperation module, bool collectDebugInfo, bool keepOnlyMaxDelayPaths,
-    bool lazyComputation);
+    bool lazyComputation, MlirStringRef topModuleName);
 
 // Destroy a LongestPathAnalysis
 MLIR_CAPI_EXPORTED void

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

@@ -206,12 +206,18 @@ struct LongestPathAnalysisOptions {
   /// are needed rather than complete path enumeration.
   bool keepOnlyMaxDelayPaths = false;
 
+  /// Name of the top module for the analysis.
+  /// If empty, the top module is inferred from the instance graph.
+  StringAttr topModuleName = {};
+
   /// Construct analysis options with the specified settings.
   LongestPathAnalysisOptions(bool collectDebugInfo = false,
                              bool lazyComputation = false,
-                             bool keepOnlyMaxDelayPaths = false)
+                             bool keepOnlyMaxDelayPaths = false,
+                             StringAttr topModuleName = {})
       : collectDebugInfo(collectDebugInfo), lazyComputation(lazyComputation),
-        keepOnlyMaxDelayPaths(keepOnlyMaxDelayPaths) {}
+        keepOnlyMaxDelayPaths(keepOnlyMaxDelayPaths),
+        topModuleName(topModuleName) {}
 };
 
 // This analysis finds the longest paths in the dataflow graph across modules.
@@ -282,16 +288,6 @@ class LongestPathAnalysis {
   // Return the top nodes that were used for the analysis.
   llvm::ArrayRef<hw::HWModuleOp> getTopModules() const;
 
-  // This is the name of the attribute that can be attached to the module
-  // to specify the top module for the analysis. This is optional, if not
-  // specified, the analysis will infer the top module from the instance graph.
-  // However it's recommended to specify it, as the entire module tends to
-  // contain testbench or verification modules, which may have expensive paths
-  // that are not of interest.
-  static StringRef getTopModuleNameAttrName() {
-    return "synth.longest-path-analysis-top";
-  }
-
   MLIRContext *getContext() const { return ctx; }
 
 protected:

include/circt/Dialect/Synth/Transforms/SynthPasses.td

@@ -116,7 +116,10 @@ def PrintLongestPathAnalysis
                  Option<"showTopKPercent", "show-top-k-percent", "int", "5",
                         "The size of the longest paths to show.">,
                  Option<"emitJSON", "emit-json", "bool", "false",
-                        "Output analysis results in JSON format">];
+                        "Output analysis results in JSON format">,
+                 Option<"topModuleName", "top-module-name", "std::string", "",
+                        "Name of the top module to analyze (empty for automatic "
+                        "inference from instance graph)">];
 }
 
 class ExternalSolverPass<string name> : Pass<name, "hw::HWModuleOp"> {

integration_test/Bindings/Python/dialects/synth.py

@@ -141,7 +141,8 @@ def build_top(module):
     analysis = LongestPathAnalysis(test_child,
                                    collect_debug_info=True,
                                    keep_only_max_delay_paths=True,
-                                   lazy_computation=True)
+                                   lazy_computation=True,
+                                   top_module_name="test_child")
     c1 = analysis.get_paths(result0, 0)
     c2 = analysis.get_paths(result1, 0)
     # CHECK-NEXT: len(c1) = 1

lib/Bindings/Python/SynthModule.cpp

@@ -33,14 +33,15 @@ void circt::python::populateDialectSynthSubmodule(nb::module_ &m) {
           "__init__",
           [](SynthLongestPathAnalysis *self, MlirOperation module,
              bool collectDebugInfo, bool keepOnlyMaxDelayPaths,
-             bool lazyComputation) {
+             bool lazyComputation, const std::string &topModuleName) {
             new (self) SynthLongestPathAnalysis(synthLongestPathAnalysisCreate(
                 module, collectDebugInfo, keepOnlyMaxDelayPaths,
-                lazyComputation));
+                lazyComputation,
+                mlirStringRefCreateFromCString(topModuleName.c_str())));
           },
           nb::arg("module"), nb::arg("collect_debug_info") = false,
           nb::arg("keep_only_max_delay_paths") = false,
-          nb::arg("lazy_computation") = false)
+          nb::arg("lazy_computation") = false, nb::arg("top_module_name") = "")
       .def("__del__",
            [](SynthLongestPathAnalysis &self) {
              synthLongestPathAnalysisDestroy(self);

lib/Bindings/Python/dialects/synth.py

@@ -352,7 +352,8 @@ def __init__(self,
                module,
                collect_debug_info: bool = True,
                keep_only_max_delay_paths: bool = False,
-               lazy_computation: bool = False):
+               lazy_computation: bool = False,
+               top_module_name: str = ""):
     """
         Initialize the longest path analysis for a given module.
         Args:
@@ -365,7 +366,8 @@ def __init__(self,
         """
     self.analysis = synth._LongestPathAnalysis(module, collect_debug_info,
                                                keep_only_max_delay_paths,
-                                               lazy_computation)
+                                               lazy_computation,
+                                               top_module_name)
 
   def get_paths(self,
                 value,

lib/CAPI/Dialect/Synth.cpp

@@ -80,17 +80,19 @@ SynthLongestPathObject wrap(const DataflowPath::OutputPort *object) {
 
 SynthLongestPathAnalysis
 synthLongestPathAnalysisCreate(MlirOperation module, bool collectDebugInfo,
-                               bool keepOnlyMaxDelayPaths,
-                               bool lazyComputation) {
+                               bool keepOnlyMaxDelayPaths, bool lazyComputation,
+                               MlirStringRef topModuleName) {
   auto *op = unwrap(module);
   auto *wrapper = new LongestPathAnalysisWrapper();
   wrapper->analysisManager =
       std::make_unique<mlir::ModuleAnalysisManager>(op, nullptr);
   mlir::AnalysisManager am = *wrapper->analysisManager;
+  auto topModuleNameAttr =
+      StringAttr::get(op->getContext(), unwrap(topModuleName));
   wrapper->analysis = std::make_unique<LongestPathAnalysis>(
       op, am,
       LongestPathAnalysisOptions(collectDebugInfo, lazyComputation,
-                                 keepOnlyMaxDelayPaths));
+                                 keepOnlyMaxDelayPaths, topModuleNameAttr));
   return wrap(wrapper);
 }
 

lib/Dialect/Synth/Analysis/LongestPathAnalysis.cpp

@@ -485,6 +485,7 @@ class Context {
   bool doLazyComputation() const { return option.lazyComputation; }
   bool doKeepOnlyMaxDelayPaths() const { return option.keepOnlyMaxDelayPaths; }
   bool isLocalScope() const { return instanceGraph == nullptr; }
+  StringAttr getTopModuleName() const { return option.topModuleName; }
 
 private:
   bool isRunningParallel() const { return !doLazyComputation(); }
@@ -1752,14 +1753,12 @@ LongestPathAnalysis::Impl::initializeAndRun(hw::HWModuleOp module) {
 
 LogicalResult
 LongestPathAnalysis::Impl::initializeAndRun(mlir::ModuleOp module) {
-  auto topNameAttr =
-      module->getAttrOfType<FlatSymbolRefAttr>(getTopModuleNameAttrName());
-
+  auto topNameAttr = ctx.getTopModuleName();
   topModules.clear();
   llvm::SetVector<Operation *> visited;
   auto *instanceGraph = ctx.instanceGraph;
-  if (topNameAttr) {
-    auto *topNode = instanceGraph->lookup(topNameAttr.getAttr());
+  if (topNameAttr && topNameAttr.getValue() != "") {
+    auto *topNode = instanceGraph->lookupOrNull(topNameAttr);
     if (!topNode || !topNode->getModule() ||
         !isa<hw::HWModuleOp>(topNode->getModule())) {
       module.emitError() << "top module not found in instance graph "

lib/Dialect/Synth/Analysis/PrintLongestPathAnalysis.cpp

@@ -280,7 +280,7 @@ void PrintLongestPathAnalysisPass::runOnOperation() {
           /*collectDebugInfo=*/showTopKPercent.getValue() > 0,
           /*lazyComputation=*/false,
           /*keepOnlyMaxDelayPaths=*/
-          !test));
+          !test, StringAttr::get(&getContext(), topModuleName.getValue())));
 
   igraph::InstancePathCache pathCache(
       getAnalysis<circt::igraph::InstanceGraph>());

test/CAPI/support.c

@@ -55,10 +55,10 @@ void testInstancePath(void) {
   // for testing purposes without needing to expose additional InstancePathCache
   // APIs.
 
+  MlirStringRef moduleName = mlirStringRefCreateFromCString("top");
   SynthLongestPathAnalysis analysis =
-      synthLongestPathAnalysisCreate(moduleOp, true, false, false);
+      synthLongestPathAnalysisCreate(moduleOp, true, false, false, moduleName);
 
-  MlirStringRef moduleName = mlirStringRefCreateFromCString("top");
   SynthLongestPathCollection collection =
       synthLongestPathAnalysisGetAllPaths(analysis, moduleName, true);