Merge branch 'master' of https://github.com/The-OpenROAD-Project-private/OpenROAD into secure-store-hier-flag-in-odb

Signed-off-by: Jaehyun Kim <[email protected]>

Author: jhkim-pii

.gemini/config.yaml

@@ -0,0 +1,8 @@
+memory_config:
+  disabled: false
+code_review:
+  pull_request_opened:
+    help: false
+    summary: false
+    code_review: true
+    include_drafts: true

MODULE.bazel

@@ -146,7 +146,7 @@ bazel_dep(name = "bazel-orfs")
 # To bump version, run: bazelisk run @bazel-orfs//:bump
 git_override(
     module_name = "bazel-orfs",
-    commit = "e96d7d2a4405a99fc689b4f2f676d3bda7b9430b",
+    commit = "1e862b169d97dc0fec5db106559640886e7fd7d0",
     remote = "https://github.com/The-OpenROAD-Project/bazel-orfs.git",
 )
 
@@ -155,10 +155,10 @@ orfs = use_extension("@bazel-orfs//:extension.bzl", "orfs_repositories")
 # To bump version, run: bazelisk run @bazel-orfs//:bump
 orfs.default(
     # Official image https://hub.docker.com/r/openroad/orfs/tags
-    image = "docker.io/openroad/orfs:v3.0-4362-gaec1d8d35",
+    image = "docker.io/openroad/orfs:v3.0-4367-g79b6a48ab",
     # Use OpenROAD of this repo instead of from the docker image
     openroad = "//:openroad",
-    sha256 = "5f94f0481d1339493918208060be116da101405251bce22691ac4b2d662d276e",
+    sha256 = "0d0dd3d8d346360a71f6325ce776a984c5a6296fc6e51956b53f136e1dd13462",
 )
 use_repo(orfs, "com_github_nixos_patchelf_download")
 use_repo(orfs, "docker_orfs")

MODULE.bazel.lock

@@ -950,7 +950,7 @@ std::vector<TechChar::SolutionData> TechChar::createPatterns(
   odb::dbNet* net = nullptr;
   // clang-format off
   debugPrint(logger_, CTS, "tech char", 1, "*createPatterns for #nodes = {}"
-             " #topologies = {}", setupWirelength, numberOfNodes, numberOfTopologies);
+             " #topologies = {}", numberOfNodes, numberOfTopologies);
   // clang-format on
   // For each possible topology...
   for (unsigned solutionCounterInt = 0; solutionCounterInt < numberOfTopologies;
@@ -1051,9 +1051,6 @@ std::vector<TechChar::SolutionData> TechChar::createPatterns(
     tmp << "OUT";
     debugPrint(logger_, CTS, "tech char", 1, tmp.str());
     topology.outPort = outPortPin;
-    if (isPureWire) {
-      topology.instVector.push_back(nullptr);
-    }
     topology.isPureWire = isPureWire;
     topology.netVector.push_back(net);
     topology.nodesWithoutBufVector.push_back(nodesWithoutBuf);
@@ -1478,6 +1475,7 @@ std::vector<TechChar::ResultData> TechChar::characterizationPostProcess()
   unsigned maxResultCapacitance = 0;
   unsigned minResultSlew = std::numeric_limits<unsigned>::max();
   unsigned maxResultSlew = 0;
+
   std::vector<ResultData> convertedSolutions;
   for (ResultData solution : selectedSolutions) {
     if (solution.pinSlew <= options_->getMaxCharSlew()) {
@@ -1530,6 +1528,7 @@ std::vector<TechChar::ResultData> TechChar::characterizationPostProcess()
       convertedSolutions.push_back(convertedResult);
     }
   }
+
   // Sets the min and max values and returns the result vector.
   minSlew_ = minResultSlew;
   maxSlew_ = maxResultSlew;
@@ -1631,10 +1630,10 @@ void TechChar::create()
                  masterNames_.size(), solution.instVector.size());
       // clang-format on
       // For each possible buffer combination (different sizes).
-      unsigned buffersUpdate
+      unsigned buffersCombinations
           = getBufferingCombo(masterNames_.size(), solution.instVector.size());
 
-      if (buffersUpdate == 0) {
+      if (buffersCombinations == 0) {
         continue;
       }
 
@@ -1697,12 +1696,13 @@ void TechChar::create()
           }
         }
         // If the solution is not a pure-wire, update the buffer topologies.
-        if (!solution.isPureWire) {
+        if (!solution.isPureWire && buffersCombinations > 1) {
           updateBufferTopologies(solution);
         }
-        // For pure-wire solution buffersUpdate == 1, so it only runs once.
-        buffersUpdate--;
-      } while (buffersUpdate != 0);
+        // For pure-wire solution buffersCombinations == 1, so it only runs
+        // once.
+        buffersCombinations--;
+      } while (buffersCombinations != 0);
     }
     openStaChar_.reset(nullptr);
   }

src/cts/src/TechChar.cpp

@@ -44,7 +44,7 @@ class MplObserver
       const std::vector<odb::Rect>& placement_blockages)
   {
   }
-  virtual void setBundledNets(const std::vector<BundledNet>& bundled_nets) {}
+  virtual void setNets(const BundledNetList& nets) {}
   virtual void setShowBundledNets(bool show_bundled_nets) {}
   virtual void setShowClustersIds(bool show_clusters_ids) {}
   virtual void setSkipSteps(bool skip_steps) {}

src/mpl/src/MplObserver.h

@@ -118,7 +118,7 @@ void SimulatedAnnealingCore<T>::initSequencePair()
 
 // access functions
 template <class T>
-void SimulatedAnnealingCore<T>::setNets(const std::vector<BundledNet>& nets)
+void SimulatedAnnealingCore<T>::setNets(const BundledNetList& nets)
 {
   nets_ = nets;
 }
@@ -286,7 +286,7 @@ void SimulatedAnnealingCore<T>::calWirelength()
 
 template <class T>
 float SimulatedAnnealingCore<T>::computeNetsWireLength(
-    const std::vector<BundledNet>& nets) const
+    const BundledNetList& nets) const
 {
   float nets_wire_length = 0.0;
   float nets_weight_sum = 0.0;

src/mpl/src/SimulatedAnnealingCore.cpp

@@ -64,7 +64,7 @@ class SimulatedAnnealingCore
   {
     number_of_sequence_pair_macros_ = number_of_sequence_pair_macros;
   };
-  void setNets(const std::vector<BundledNet>& nets);
+  void setNets(const BundledNetList& nets);
   void setFences(const std::map<int, odb::Rect>& fences);
   void setGuides(const std::map<int, odb::Rect>& guides);
   void setInitialSequencePair(const SequencePair& sequence_pair);
@@ -118,7 +118,7 @@ class SimulatedAnnealingCore
   virtual void calPenalty() = 0;
   void calOutlinePenalty();
   void calWirelength();
-  float computeNetsWireLength(const std::vector<BundledNet>& nets) const;
+  float computeNetsWireLength(const BundledNetList& nets) const;
   int64_t computeWLForClusterOfUnplacedIOPins(const T& macro,
                                               const T& unplaced_ios,
                                               float net_weight) const;
@@ -154,7 +154,7 @@ class SimulatedAnnealingCore
 
   int number_of_sequence_pair_macros_ = 0;
 
-  std::vector<BundledNet> nets_;
+  BundledNetList nets_;
   std::map<int, odb::Rect> fences_;  // Macro Id -> Fence
   std::map<int, odb::Rect> guides_;  // Macro Id -> Guide
 

src/mpl/src/SimulatedAnnealingCore.h

@@ -42,7 +42,6 @@ ClusteringEngine::ClusteringEngine(odb::dbBlock* block,
 
 void ClusteringEngine::run()
 {
-  design_metrics_ = computeModuleMetrics(block_->getTopModule());
   init();
 
   if (!tree_->has_unfixed_macros) {
@@ -88,17 +87,18 @@ void ClusteringEngine::setTree(PhysicalHierarchy* tree)
 // initialize the tree with data from the design.
 void ClusteringEngine::init()
 {
+  setDieArea();
+  setFloorplanShape();
+
+  design_metrics_ = computeModuleMetrics(block_->getTopModule());
+
   const std::vector<odb::dbInst*> unfixed_macros = getUnfixedMacros();
   if (unfixed_macros.empty()) {
     tree_->has_unfixed_macros = false;
     logger_->info(MPL, 17, "No unfixed macros.");
     return;
   }
 
-  setDieArea();
-  setFloorplanShape();
-  searchForFixedInstsInsideFloorplanShape();
-
   tree_->macro_with_halo_area = computeMacroWithHaloArea(unfixed_macros);
   const float inst_area_with_halos
       = tree_->macro_with_halo_area + design_metrics_->getStdCellArea();
@@ -154,25 +154,6 @@ void ClusteringEngine::setFloorplanShape()
   tree_->floorplan_shape = block_->getCoreArea().intersect(tree_->global_fence);
 }
 
-void ClusteringEngine::searchForFixedInstsInsideFloorplanShape()
-{
-  for (odb::dbInst* inst : block_->getInsts()) {
-    odb::dbMaster* master = inst->getMaster();
-
-    if (master->isBlock() || master->isCover()) {
-      continue;
-    }
-
-    if (inst->isFixed()
-        && inst->getBBox()->getBox().overlaps(tree_->floorplan_shape)) {
-      logger_->error(MPL,
-                     50,
-                     "Found fixed instance {} inside the floorplan area.",
-                     inst->getName());
-    }
-  }
-}
-
 Metrics* ClusteringEngine::computeModuleMetrics(odb::dbModule* module)
 {
   unsigned int num_std_cell = 0;
@@ -183,15 +164,25 @@ Metrics* ClusteringEngine::computeModuleMetrics(odb::dbModule* module)
   const odb::Rect& core = block_->getCoreArea();
 
   for (odb::dbInst* inst : module->getInsts()) {
-    if (isIgnoredInst(inst)) {
-      continue;
-    }
-
-    int64_t inst_area = computeArea(inst);
-
-    if (inst->isBlock()) {  // a macro
+    if (inst->isBlock()) {
       num_macro += 1;
-      macro_area += inst_area;
+      macro_area += computeArea(inst);
+
+      if (inst->isFixed()) {
+        logger_->info(MPL, 62, "Found fixed macro {}.", inst->getName());
+
+        if (!inst->getBBox()->getBox().overlaps(tree_->floorplan_shape)) {
+          ignorable_macros_.insert(inst);
+          logger_->info(MPL,
+                        63,
+                        "{} is outside the macro placement area and will be "
+                        "ignored.",
+                        inst->getName());
+          continue;
+        }
+
+        tree_->has_fixed_macros = true;
+      }
 
       auto macro = std::make_unique<HardMacro>(
           inst, tree_->halo_width, tree_->halo_height);
@@ -205,14 +196,17 @@ Metrics* ClusteringEngine::computeModuleMetrics(odb::dbModule* module)
             generateMacroAndCoreDimensionsTable(macro.get(), core));
       }
 
-      if (macro->isFixed()) {
-        tree_->has_fixed_macros = true;
-      }
-
       tree_->maps.inst_to_hard[inst] = std::move(macro);
-    } else {
+    } else if (inst->isFixed() && !inst->getMaster()->isCover()
+               && inst->getBBox()->getBox().overlaps(tree_->floorplan_shape)) {
+      logger_->error(MPL,
+                     50,
+                     "Found fixed non-macro instance {} inside the macro "
+                     "placement area.",
+                     inst->getName());
+    } else if (!isIgnoredInst(inst)) {
       num_std_cell += 1;
-      std_cell_area += inst_area;
+      std_cell_area += computeArea(inst);
     }
   }
 
@@ -856,12 +850,15 @@ DataFlowHypergraph ClusteringEngine::computeHypergraph(
   return graph;
 }
 
-/* static */
 bool ClusteringEngine::isIgnoredInst(odb::dbInst* inst)
 {
+  if (inst->isBlock()
+      && (ignorable_macros_.find(inst) != ignorable_macros_.end())) {
+    return true;
+  }
+
   odb::dbMaster* master = inst->getMaster();
-  return master->isPad() || master->isCover() || master->isEndCap()
-         || inst->getITerms().empty();
+  return master->isPad() || master->isCover() || master->isEndCap();
 }
 
 // Forward or Backward DFS search to find sequential paths from/to IO pins based

src/mpl/src/clusterEngine.cpp

@@ -10,6 +10,7 @@
 #include <set>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -161,7 +162,7 @@ class ClusteringEngine
 
   int getNumberOfIOs(Cluster* target) const;
 
-  static bool isIgnoredInst(odb::dbInst* inst);
+  bool isIgnoredInst(odb::dbInst* inst);
 
  private:
   using UniqueClusterQueue = std::queue<std::unique_ptr<Cluster>>;
@@ -179,7 +180,6 @@ class ClusteringEngine
   std::vector<odb::dbInst*> getUnfixedMacros();
   void setDieArea();
   void setFloorplanShape();
-  void searchForFixedInstsInsideFloorplanShape();
   int64_t computeMacroWithHaloArea(
       const std::vector<odb::dbInst*>& unfixed_macros);
   std::vector<odb::dbInst*> getIOPads() const;
@@ -316,11 +316,12 @@ class ClusteringEngine
   // The register distance between two macros for
   // them to be considered connected when creating data flow.
   const int max_num_of_hops_ = 5;
-
   const float minimum_connection_ratio_{0.08};
 
   int first_io_bundle_id_{-1};
   IOBundleSpans io_bundle_spans_;
+
+  std::unordered_set<odb::dbInst*> ignorable_macros_;
 };
 
 }  // namespace mpl