Merge remote-tracking branch 'private/master' into gpl-reduce-TD-iterations

gudeh · gudeh · commit cd5b0c062c63 · 2025-08-22T11:02:04.000Z
diff --git a/src/cts/test/balance_levels.defok b/src/cts/test/balance_levels.defok
@@ -1,5 +1,5 @@
 VERSION 5.8 ;
-DIVIDERCHAR "|" ;
+DIVIDERCHAR "/" ;
 BUSBITCHARS "[]" ;
 DESIGN multi_sink ;
 UNITS DISTANCE MICRONS 2000 ;
diff --git a/src/dbSta/include/db_sta/dbNetwork.hh b/src/dbSta/include/db_sta/dbNetwork.hh
@@ -298,11 +298,26 @@ class dbNetwork : public ConcreteNetwork
   NetTermIterator* termIterator(const Net* net) const override;
   const Net* highestConnectedNet(Net* net) const override;
   bool isSpecial(Net* net);
+
+  // Get the flat net (dbNet) with the Net*.
+  // If the net is a hierarchical net (dbModNet), return nullptr
   dbNet* flatNet(const Net* net) const;
-  Net* getOrFindFlatNet(const Net* net) const;
-  dbNet* getOrFindFlatDbNet(const Net* net) const;
-  Net* getOrFindFlatNet(const Pin* pin) const;
-  dbNet* getOrFindFlatDbNet(const Pin* pin) const;
+
+  // Given a net or pin that may be hierarchical, find the corresponding flat
+  // dbNet by traversing the netlist.
+  // If the net is already a flat net (dbNet), it is returned as is.
+  // If the net is a hierarchical net (dbModNet), find the associated dbNet.
+  dbNet* findFlatDbNet(const Net* net) const;
+  dbNet* findFlatDbNet(const Pin* pin) const;
+
+  // Given a net that may be hierarchical, find the corresponding flat dbNet by
+  // traversing the netlist and return it as Net*.
+  // If the net is already a flat net, it is returned as is.
+  // If the net is a hierarchical net (dbModNet), find the associated dbNet and
+  // return it as Net*.
+  Net* findFlatNet(const Net* net) const;
+  Net* findFlatNet(const Pin* pin) const;
+
   bool hasPort(const Net* net) const;
 
   ////////////////////////////////////////////////////////////////
diff --git a/src/dbSta/src/dbNetwork.cc b/src/dbSta/src/dbNetwork.cc
@@ -2655,7 +2655,7 @@ Net* dbNetwork::mergedInto(Net*)
 
 bool dbNetwork::isSpecial(Net* net)
 {
-  dbNet* db_net = getOrFindFlatDbNet(net);
+  dbNet* db_net = findFlatDbNet(net);
   return (db_net && db_net->isSpecial());
 }
 
@@ -3977,15 +3977,15 @@ void dbNetwork::checkAxioms()
 // If the net is already a flat net, it is returned as is.
 // If the net is a hierarchical net (dbModNet), find the associated dbNet and
 // return it as Net*.
-Net* dbNetwork::getOrFindFlatNet(const Net* net) const
+Net* dbNetwork::findFlatNet(const Net* net) const
 {
-  return dbToSta(getOrFindFlatDbNet(net));
+  return dbToSta(findFlatDbNet(net));
 }
 
 // Given a net that may be hierarchical, find the corresponding flat dbNet.
 // If the net is already a flat net (dbNet), it is returned as is.
 // If the net is a hierarchical net (dbModNet), find the associated dbNet.
-dbNet* dbNetwork::getOrFindFlatDbNet(const Net* net) const
+dbNet* dbNetwork::findFlatDbNet(const Net* net) const
 {
   if (!net) {
     return nullptr;
@@ -4010,14 +4010,14 @@ dbNet* dbNetwork::getOrFindFlatDbNet(const Net* net) const
 
 // Find the flat net connected to the pin.
 // This function handles both internal instance pins and top-level port pins.
-Net* dbNetwork::getOrFindFlatNet(const Pin* pin) const
+Net* dbNetwork::findFlatNet(const Pin* pin) const
 {
-  return dbToSta(getOrFindFlatDbNet(pin));
+  return dbToSta(findFlatDbNet(pin));
 }
 
 // Find the flat net (dbNet) connected to the pin in the OpenDB database.
 // This function handles both internal instance pins and top-level port pins.
-dbNet* dbNetwork::getOrFindFlatDbNet(const Pin* pin) const
+dbNet* dbNetwork::findFlatDbNet(const Pin* pin) const
 {
   dbNet* db_net = nullptr;
   if (isTopLevelPort(pin)) {
diff --git a/src/est/src/EstimateParasitics.cpp b/src/est/src/EstimateParasitics.cpp
@@ -993,7 +993,7 @@ SteinerTree* EstimateParasitics::makeSteinerTree(const Pin* drvr_pin)
   /*
     Handle hierarchy. Make sure all traversal on dbNets.
    */
-  odb::dbNet* db_net = db_network_->getOrFindFlatDbNet(drvr_pin);
+  odb::dbNet* db_net = db_network_->findFlatDbNet(drvr_pin);
   Net* net = db_network_->dbToSta(db_net);
 
   debugPrint(logger_, EST, "steiner", 1, "Net {}", sdc_network->pathName(net));
diff --git a/src/gpl/test/clust02.defok b/src/gpl/test/clust02.defok
@@ -1,5 +1,5 @@
 VERSION 5.8 ;
-DIVIDERCHAR "|" ;
+DIVIDERCHAR "/" ;
 BUSBITCHARS "[]" ;
 DESIGN top ;
 UNITS DISTANCE MICRONS 1000 ;
diff --git a/src/gui/src/staGuiInterface.cpp b/src/gui/src/staGuiInterface.cpp
@@ -724,7 +724,7 @@ sta::Net* ClockTree::getNet(const sta::Pin* pin) const
 {
   sta::Term* term = network_->term(pin);
   sta::Net* net = term ? network_->net(term) : network_->net(pin);
-  return network_->getOrFindFlatNet(net);
+  return network_->findFlatNet(net);
 }
 
 bool ClockTree::isLeaf(const sta::Pin* pin) const
diff --git a/src/mpl/src/SimulatedAnnealingCore.cpp b/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;
 
diff --git a/src/mpl/src/SimulatedAnnealingCore.h b/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
diff --git a/src/mpl/src/clusterEngine.cpp b/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);
   }
 }
 
diff --git a/src/mpl/src/clusterEngine.h b/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,
diff --git a/src/mpl/src/hier_rtlmp.cpp b/src/mpl/src/hier_rtlmp.cpp
@@ -1383,13 +1383,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;
@@ -1429,7 +1430,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();
@@ -1619,7 +1620,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);
@@ -1831,7 +1832,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();
@@ -2007,7 +2008,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);
@@ -2468,15 +2469,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;
@@ -2485,7 +2489,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;
     }
   }
@@ -2528,7 +2532,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);
diff --git a/src/odb/include/odb/db.h b/src/odb/include/odb/db.h
@@ -1330,7 +1330,7 @@ class dbBlock : public dbObject
   static dbBlock* create(dbChip* chip,
                          const char* name,
                          dbTech* tech = nullptr,
-                         char hier_delimiter = 0);
+                         char hier_delimiter = '/');
 
   ///
   /// Create a hierachical/child block. This block has no connectivity.
@@ -1340,7 +1340,7 @@ class dbBlock : public dbObject
   static dbBlock* create(dbBlock* block,
                          const char* name,
                          dbTech* tech = nullptr,
-                         char hier_delimiter = 0);
+                         char hier_delimiter = '/');
 
   ///
   /// Translate a database-id back to a pointer.
@@ -4990,7 +4990,7 @@ class dbLib : public dbObject
   static dbLib* create(dbDatabase* db,
                        const char* name,
                        dbTech* tech,
-                       char hierarchy_delimiter = 0);
+                       char hierarchy_delimiter = '/');
 
   ///
   /// Translate a database-id back to a pointer.
diff --git a/src/odb/src/db/dbBlock.cpp b/src/odb/src/db/dbBlock.cpp
@@ -152,7 +152,7 @@ _dbBlock::_dbBlock(_dbDatabase* db)
   _flags._spare_bits = 0;
   _def_units = 100;
   _dbu_per_micron = 1000;
-  _hier_delimiter = 0;
+  _hier_delimiter = '/';
   _left_bus_delimiter = 0;
   _right_bus_delimiter = 0;
   _num_ext_corners = 0;
diff --git a/src/odb/src/db/dbLib.cpp b/src/odb/src/db/dbLib.cpp
@@ -98,7 +98,7 @@ _dbLib::_dbLib(_dbDatabase* db)
 {
   _lef_units = 0;
   _dbu_per_micron = 1000;
-  _hier_delimiter = 0;
+  _hier_delimiter = '/';
   _left_bus_delimiter = 0;
   _right_bus_delimiter = 0;
   _spare = 0;
diff --git a/src/rsz/src/BufferedNet.cc b/src/rsz/src/BufferedNet.cc
@@ -743,7 +743,7 @@ static BufferedNetPtr makeBufferedNet(
 BufferedNetPtr Resizer::makeBufferedNetGroute(const Pin* drvr_pin,
                                               const Corner* corner)
 {
-  dbNet* db_net = db_network_->getOrFindFlatDbNet(drvr_pin);
+  dbNet* db_net = db_network_->findFlatDbNet(drvr_pin);
   const Net* net = db_network_->dbToSta(db_net);
   assert(db_net != nullptr);
   std::vector<grt::PinGridLocation> pin_grid_locs
diff --git a/src/rsz/src/Resizer.cc b/src/rsz/src/Resizer.cc
@@ -3999,8 +3999,8 @@ void Resizer::cloneClkInverter(Instance* inv)
   inv_cell->bufferPorts(in_port, out_port);
   Pin* in_pin = network_->findPin(inv, in_port);
   Pin* out_pin = network_->findPin(inv, out_port);
-  Net* in_net = db_network_->getOrFindFlatNet(in_pin);
-  dbNet* in_net_db = db_network_->getOrFindFlatDbNet(in_net);
+  Net* in_net = db_network_->findFlatNet(in_pin);
+  dbNet* in_net_db = db_network_->findFlatDbNet(in_net);
   Net* out_net = network_->isTopLevelPort(out_pin)
                      ? network_->net(network_->term(out_pin))
                      : network_->net(out_pin);
diff --git a/src/rsz/src/UnbufferMove.cc b/src/rsz/src/UnbufferMove.cc
@@ -303,8 +303,8 @@ bool UnbufferMove::canRemoveBuffer(Instance* buffer, bool honorDontTouchFixed)
   Pin* out_pin = db_network_->findPin(buffer, out_port);
   Net* in_net = db_network_->net(in_pin);
   Net* out_net = db_network_->net(out_pin);
-  dbNet* in_db_net = db_network_->getOrFindFlatDbNet(in_net);
-  dbNet* out_db_net = db_network_->getOrFindFlatDbNet(out_net);
+  dbNet* in_db_net = db_network_->findFlatDbNet(in_net);
+  dbNet* out_db_net = db_network_->findFlatDbNet(out_net);
   // honor net dont-touch on input net or output net
   if ((in_db_net && in_db_net->isDoNotTouch())
       || (out_db_net && out_db_net->isDoNotTouch())) {
diff --git a/src/rsz/test/buffer_varying_lengths.defok b/src/rsz/test/buffer_varying_lengths.defok
@@ -1,5 +1,5 @@
 VERSION 5.8 ;
-DIVIDERCHAR "|" ;
+DIVIDERCHAR "/" ;
 BUSBITCHARS "[]" ;
 DESIGN top ;
 UNITS DISTANCE MICRONS 2000 ;

Original file line number	Diff line number	Diff line change
`@@ -2655,7 +2655,7 @@ Net* dbNetwork::mergedInto(Net*)`
`2655`	`2655`
`2656`	`2656`	`bool dbNetwork::isSpecial(Net* net)`
`2657`	`2657`	`{`
`2658`		`- dbNet* db_net = getOrFindFlatDbNet(net);`
	`2658`	`+ dbNet* db_net = findFlatDbNet(net);`
`2659`	`2659`	`return (db_net && db_net->isSpecial());`
`2660`	`2660`	`}`
`2661`	`2661`
`@@ -3977,15 +3977,15 @@ void dbNetwork::checkAxioms()`
`3977`	`3977`	`// If the net is already a flat net, it is returned as is.`
`3978`	`3978`	`// If the net is a hierarchical net (dbModNet), find the associated dbNet and`
`3979`	`3979`	`// return it as Net*.`
`3980`		`-Net* dbNetwork::getOrFindFlatNet(const Net* net) const`
	`3980`	`+Net* dbNetwork::findFlatNet(const Net* net) const`
`3981`	`3981`	`{`
`3982`		`- return dbToSta(getOrFindFlatDbNet(net));`
	`3982`	`+ return dbToSta(findFlatDbNet(net));`
`3983`	`3983`	`}`
`3984`	`3984`
`3985`	`3985`	`// Given a net that may be hierarchical, find the corresponding flat dbNet.`
`3986`	`3986`	`// If the net is already a flat net (dbNet), it is returned as is.`
`3987`	`3987`	`// If the net is a hierarchical net (dbModNet), find the associated dbNet.`
`3988`		`-dbNet* dbNetwork::getOrFindFlatDbNet(const Net* net) const`
	`3988`	`+dbNet* dbNetwork::findFlatDbNet(const Net* net) const`
`3989`	`3989`	`{`
`3990`	`3990`	`if (!net) {`
`3991`	`3991`	`return nullptr;`
`@@ -4010,14 +4010,14 @@ dbNet* dbNetwork::getOrFindFlatDbNet(const Net* net) const`
`4010`	`4010`
`4011`	`4011`	`// Find the flat net connected to the pin.`
`4012`	`4012`	`// This function handles both internal instance pins and top-level port pins.`
`4013`		`-Net* dbNetwork::getOrFindFlatNet(const Pin* pin) const`
	`4013`	`+Net* dbNetwork::findFlatNet(const Pin* pin) const`
`4014`	`4014`	`{`
`4015`		`- return dbToSta(getOrFindFlatDbNet(pin));`
	`4015`	`+ return dbToSta(findFlatDbNet(pin));`
`4016`	`4016`	`}`
`4017`	`4017`
`4018`	`4018`	`// Find the flat net (dbNet) connected to the pin in the OpenDB database.`
`4019`	`4019`	`// This function handles both internal instance pins and top-level port pins.`
`4020`		`-dbNet* dbNetwork::getOrFindFlatDbNet(const Pin* pin) const`
	`4020`	`+dbNet* dbNetwork::findFlatDbNet(const Pin* pin) const`
`4021`	`4021`	`{`
`4022`	`4022`	`dbNet* db_net = nullptr;`
`4023`	`4023`	`if (isTopLevelPort(pin)) {`
Original file line number	Diff line number	Diff line change
`@@ -724,7 +724,7 @@ sta::Net* ClockTree::getNet(const sta::Pin* pin) const`
`724`	`724`	`{`
`725`	`725`	`sta::Term* term = network_->term(pin);`
`726`	`726`	`sta::Net* net = term ? network_->net(term) : network_->net(pin);`
`727`		`- return network_->getOrFindFlatNet(net);`
	`727`	`+ return network_->findFlatNet(net);`
`728`	`728`	`}`
`729`	`729`
`730`	`730`	`bool ClockTree::isLeaf(const sta::Pin* pin) const`
Original file line number	Diff line number	Diff line change
`@@ -100,8 +100,9 @@ void SimulatedAnnealingCore<T>::initSequencePair()`
`100`	`100`	`return;`
`101`	`101`	`}`
`102`	`102`
`103`		`- const int sequence_pair_size`
`104`		`- = macros_to_place_ != 0 ? macros_to_place_ : macros_.size();`
	`103`	`+ const int sequence_pair_size = number_of_sequence_pair_macros_ != 0`
	`104`	`+ ? number_of_sequence_pair_macros_`
	`105`	`+ : macros_.size();`
`105`	`106`
`106`	`107`	`int macro_id = 0;`
`107`	`108`
Original file line number	Diff line number	Diff line change
`@@ -171,11 +171,7 @@ void ClusteringEngine::setFloorplanShape()`
`171`	`171`
`172`	`172`	`void ClusteringEngine::searchForFixedInstsInsideFloorplanShape()`
`173`	`173`	`{`
`174`		`- odb::Rect floorplan_shape(`
`175`		`- block_->micronsToDbu(tree_->floorplan_shape.xMin()),`
`176`		`- block_->micronsToDbu(tree_->floorplan_shape.yMin()),`
`177`		`- block_->micronsToDbu(tree_->floorplan_shape.xMax()),`
`178`		`- block_->micronsToDbu(tree_->floorplan_shape.yMax()));`
	`174`	`+ odb::Rect floorplan_shape = micronsToDbu(block_, tree_->floorplan_shape);`
`179`	`175`
`180`	`176`	`for (odb::dbInst* inst : block_->getInsts()) {`
`181`	`177`	`if (inst->isFixed()`
`@@ -2105,7 +2101,7 @@ void ClusteringEngine::getHardMacros(odb::dbModule* module,`
`2105`	`2101`	`}`
`2106`	`2102`
`2107`	`2103`	`void ClusteringEngine::createOneClusterForEachMacro(`
`2108`		`- Cluster* parent,`
	`2104`	`+ Cluster* mixed_leaf_parent,`
`2109`	`2105`	`const std::vector<HardMacro*>& hard_macros,`
`2110`	`2106`	`std::vector<Cluster*>& macro_clusters)`
`2111`	`2107`	`{`
`@@ -2116,7 +2112,7 @@ void ClusteringEngine::createOneClusterForEachMacro(`
`2116`	`2112`	`single_macro_cluster->addLeafMacro(hard_macro->getInst());`
`2117`	`2113`	`macro_clusters.push_back(single_macro_cluster.get());`
`2118`	`2114`
`2119`		`- incorporateNewCluster(std::move(single_macro_cluster), parent);`
	`2115`	`+ incorporateNewCluster(std::move(single_macro_cluster), mixed_leaf_parent);`
`2120`	`2116`	`}`
`2121`	`2117`	`}`
`2122`	`2118`