mpl: renaming and minor cleanup for fixed macros support

Signed-off-by: Arthur Koucher <[email protected]>

Author: AcKoucher

src/mpl/src/SimulatedAnnealingCore.cpp

@@ -100,8 +100,9 @@ void SimulatedAnnealingCore<T>::initSequencePair()
     return;
   }
 
-  const int sequence_pair_size
-      = macros_to_place_ != 0 ? macros_to_place_ : macros_.size();
+  const int sequence_pair_size = number_of_sequence_pair_macros_ != 0
+                                     ? number_of_sequence_pair_macros_
+                                     : macros_.size();
 
   int macro_id = 0;
 

src/mpl/src/SimulatedAnnealingCore.h

@@ -59,9 +59,9 @@ class SimulatedAnnealingCore
 
   virtual ~SimulatedAnnealingCore() = default;
 
-  void setNumberOfMacrosToPlace(int macros_to_place)
+  void setNumberOfSequencePairMacros(int number_of_sequence_pair_macros)
   {
-    macros_to_place_ = macros_to_place;
+    number_of_sequence_pair_macros_ = number_of_sequence_pair_macros;
   };
   void setNets(const std::vector<BundledNet>& nets);
   void setFences(const std::map<int, Rect>& fences);
@@ -145,8 +145,7 @@ class SimulatedAnnealingCore
   BoundaryRegionList available_regions_for_unconstrained_pins_;
   ClusterToBoundaryRegionMap io_cluster_to_constraint_;
 
-  // Number of macros that will actually be part of the sequence pair
-  int macros_to_place_ = 0;
+  int number_of_sequence_pair_macros_ = 0;
 
   std::vector<BundledNet> nets_;
   std::map<int, Rect> fences_;  // Macro Id -> Fence

src/mpl/src/clusterEngine.cpp

@@ -171,11 +171,7 @@ void ClusteringEngine::setFloorplanShape()
 
 void ClusteringEngine::searchForFixedInstsInsideFloorplanShape()
 {
-  odb::Rect floorplan_shape(
-      block_->micronsToDbu(tree_->floorplan_shape.xMin()),
-      block_->micronsToDbu(tree_->floorplan_shape.yMin()),
-      block_->micronsToDbu(tree_->floorplan_shape.xMax()),
-      block_->micronsToDbu(tree_->floorplan_shape.yMax()));
+  odb::Rect floorplan_shape = micronsToDbu(block_, tree_->floorplan_shape);
 
   for (odb::dbInst* inst : block_->getInsts()) {
     if (inst->isFixed()
@@ -2105,7 +2101,7 @@ void ClusteringEngine::getHardMacros(odb::dbModule* module,
 }
 
 void ClusteringEngine::createOneClusterForEachMacro(
-    Cluster* parent,
+    Cluster* mixed_leaf_parent,
     const std::vector<HardMacro*>& hard_macros,
     std::vector<Cluster*>& macro_clusters)
 {
@@ -2116,7 +2112,7 @@ void ClusteringEngine::createOneClusterForEachMacro(
     single_macro_cluster->addLeafMacro(hard_macro->getInst());
     macro_clusters.push_back(single_macro_cluster.get());
 
-    incorporateNewCluster(std::move(single_macro_cluster), parent);
+    incorporateNewCluster(std::move(single_macro_cluster), mixed_leaf_parent);
   }
 }
 

src/mpl/src/clusterEngine.h

@@ -219,7 +219,7 @@ class ClusteringEngine
   void mapMacroInCluster2HardMacro(Cluster* cluster);
   void getHardMacros(odb::dbModule* module,
                      std::vector<HardMacro*>& hard_macros);
-  void createOneClusterForEachMacro(Cluster* parent,
+  void createOneClusterForEachMacro(Cluster* mixed_leaf_parent,
                                     const std::vector<HardMacro*>& hard_macros,
                                     std::vector<Cluster*>& macro_clusters);
   void classifyMacrosBySize(const std::vector<HardMacro*>& hard_macros,

src/mpl/src/hier_rtlmp.cpp

@@ -1394,13 +1394,14 @@ void HierRTLMP::placeChildren(Cluster* parent)
       io_clusters.push_back(cluster.get());
       continue;
     }
-    // for other clusters
+
     soft_macro_id_map[cluster->getName()] = macros.size();
     auto soft_macro = std::make_unique<SoftMacro>(cluster.get());
-    clustering_engine_->updateInstancesAssociation(
-        cluster.get());  // we need this step to calculate nets
+    // Needed for computing the nets.
+    clustering_engine_->updateInstancesAssociation(cluster.get());
     macros.push_back(*soft_macro);
     cluster->setSoftMacro(std::move(soft_macro));
+
     // merge fences and guides for hard macros within cluster
     if (cluster->getClusterType() == StdCellCluster) {
       continue;
@@ -1440,7 +1441,7 @@ void HierRTLMP::placeChildren(Cluster* parent)
     graphics_->setFences(fences);
   }
 
-  const int num_of_macros_to_place = static_cast<int>(macros.size());
+  const int number_of_sequence_pair_macros = static_cast<int>(macros.size());
 
   for (Cluster* io_cluster : io_clusters) {
     soft_macro_id_map[io_cluster->getName()] = macros.size();
@@ -1630,7 +1631,7 @@ void HierRTLMP::placeChildren(Cluster* parent)
                                               graphics_.get(),
                                               logger_,
                                               block_);
-      sa->setNumberOfMacrosToPlace(num_of_macros_to_place);
+      sa->setNumberOfSequencePairMacros(number_of_sequence_pair_macros);
       sa->setCentralizationAttemptOn(true);
       sa->setFences(fences);
       sa->setGuides(guides);
@@ -1842,7 +1843,7 @@ void HierRTLMP::placeChildrenUsingMinimumTargetUtil(Cluster* parent)
     graphics_->setFences(fences);
   }
 
-  const int macros_to_place = static_cast<int>(macros.size());
+  const int number_of_sequence_pair_macros = static_cast<int>(macros.size());
 
   for (Cluster* io_cluster : io_clusters) {
     soft_macro_id_map[io_cluster->getName()] = macros.size();
@@ -2018,7 +2019,7 @@ void HierRTLMP::placeChildrenUsingMinimumTargetUtil(Cluster* parent)
                                               graphics_.get(),
                                               logger_,
                                               block_);
-      sa->setNumberOfMacrosToPlace(macros_to_place);
+      sa->setNumberOfSequencePairMacros(number_of_sequence_pair_macros);
       sa->setCentralizationAttemptOn(true);
       sa->setFences(fences);
       sa->setGuides(guides);
@@ -2479,15 +2480,18 @@ void HierRTLMP::placeMacros(Cluster* cluster)
   exchange_swap_prob = exchange_swap_prob / action_sum;
   float flip_prob = flip_prob_ / action_sum;
 
-  const int macros_to_place = static_cast<int>(hard_macros.size());
+  const int number_of_sequence_pair_macros
+      = static_cast<int>(hard_macros.size());
 
-  int num_perturb_per_step = (macros_to_place > num_perturb_per_step_ / 10)
-                                 ? macros_to_place
-                                 : num_perturb_per_step_ / 10;
+  int num_perturb_per_step
+      = (number_of_sequence_pair_macros > num_perturb_per_step_ / 10)
+            ? number_of_sequence_pair_macros
+            : num_perturb_per_step_ / 10;
 
   SequencePair initial_seq_pair;
   if (cluster->isArrayOfInterconnectedMacros()) {
-    setArrayTilingSequencePair(cluster, macros_to_place, initial_seq_pair);
+    setArrayTilingSequencePair(
+        cluster, number_of_sequence_pair_macros, initial_seq_pair);
 
     pos_swap_prob = 0.0f;
     neg_swap_prob = 0.0f;
@@ -2496,7 +2500,7 @@ void HierRTLMP::placeMacros(Cluster* cluster)
     flip_prob = 0.05;
 
     // Large arrays need more steps to properly converge.
-    if (num_perturb_per_step > macros_to_place) {
+    if (num_perturb_per_step > number_of_sequence_pair_macros) {
       num_perturb_per_step *= 2;
     }
   }
@@ -2539,7 +2543,7 @@ void HierRTLMP::placeMacros(Cluster* cluster)
                                               graphics_.get(),
                                               logger_,
                                               block_);
-      sa->setNumberOfMacrosToPlace(macros_to_place);
+      sa->setNumberOfSequencePairMacros(number_of_sequence_pair_macros);
       sa->setNets(nets);
       sa->setFences(fences);
       sa->setGuides(guides);