Merge pull request #8729 from AcKoucher/mpl-macro-arrays

mpl: fix convergence problems with large macro arrays

Author: maliberty

src/mpl/src/SACoreHardMacro.cpp

@@ -200,7 +200,13 @@ void SACoreHardMacro::initialize()
   graphics_ = nullptr;
 
   for (int i = 0; i < num_perturb_per_step_; i++) {
+    saveState();
     perturb();
+    if (!invalid_states_allowed_ && !isValid()) {
+      restoreState();
+      continue;
+    }
+
     // store current penalties
     width_list.push_back(width_);
     height_list.push_back(height_);

src/mpl/src/SACoreSoftMacro.cpp

@@ -314,8 +314,13 @@ void SACoreSoftMacro::initialize()
   graphics_ = nullptr;
 
   for (int i = 0; i < num_perturb_per_step_; i++) {
+    saveState();
     perturb();
-    // store current penalties
+    if (!invalid_states_allowed_ && !isValid()) {
+      restoreState();
+      continue;
+    }
+
     width_list.push_back(width_);
     height_list.push_back(height_);
     area_penalty_list.push_back(width_ * height_ / outline_.getWidth()

src/mpl/src/SimulatedAnnealingCore.cpp

@@ -725,6 +725,11 @@ void SimulatedAnnealingCore<T>::fastSA()
       cost = calNormCost();
 
       const bool is_valid = isValid();
+      if (!invalid_states_allowed_ && !is_valid) {
+        restoreState();
+        continue;
+      }
+
       const bool improved = cost < pre_cost || best_result_.empty();
       if ((!is_best_result_valid_ || is_valid) && improved) {
         updateBestResult(cost);

src/mpl/src/SimulatedAnnealingCore.h

@@ -67,6 +67,7 @@ class SimulatedAnnealingCore
   void setFences(const std::map<int, Rect>& fences);
   void setGuides(const std::map<int, Rect>& guides);
   void setInitialSequencePair(const SequencePair& sequence_pair);
+  void disallowInvalidStates() { invalid_states_allowed_ = false; }
 
   virtual bool isValid() const;
   bool fitsIn(const Rect& outline) const;
@@ -220,6 +221,7 @@ class SimulatedAnnealingCore
   static constexpr float acc_tolerance_ = 0.001;
 
   bool has_initial_sequence_pair_ = false;
+  bool invalid_states_allowed_{true};
 };
 
 // SACore wrapper function

src/mpl/src/clusterEngine.cpp

@@ -2087,13 +2087,16 @@ void ClusteringEngine::breakMixedLeaf(Cluster* mixed_leaf)
       continue;  // this macro cluster has been merged
     }
 
+    Cluster* movable_macro_cluster = movable_macro_clusters[i];
+    movable_macro_cluster->setAsMacroArray();
+
     if (interconn_class[i] != -1) {
-      movable_macro_clusters[i]->setAsArrayOfInterconnectedMacros();
+      movable_macro_cluster->setAsArrayOfInterconnectedMacros();
     }
 
-    movable_macro_clusters[i]->setClusterType(HardMacroCluster);
-    setClusterMetrics(movable_macro_clusters[i]);
-    virtual_conn_clusters.push_back(movable_macro_clusters[i]->getId());
+    movable_macro_cluster->setClusterType(HardMacroCluster);
+    setClusterMetrics(movable_macro_cluster);
+    virtual_conn_clusters.push_back(movable_macro_cluster->getId());
   }
 
   // Deal with the fixed macros.

src/mpl/src/hier_rtlmp.cpp

@@ -2151,14 +2151,21 @@ void HierRTLMP::placeMacros(Cluster* cluster)
                                    : minimum_perturbations_per_step;
 
   SequencePair initial_seq_pair;
-  if (cluster->isArrayOfInterconnectedMacros()) {
-    setArrayTilingSequencePair(
-        cluster, number_of_sequence_pair_macros, initial_seq_pair);
+  bool invalid_states_allowed = true;
+  if (cluster->isMacroArray()) {
+    bool array_has_empty_space = false;
+    initial_seq_pair = computeArraySequencePair(cluster, array_has_empty_space);
 
-    pos_swap_prob = 0.0f;
-    neg_swap_prob = 0.0f;
-    double_swap_prob = 0.0f;
-    exchange_swap_prob = 1.0f;
+    if (array_has_empty_space) {
+      invalid_states_allowed = false;
+    } else {
+      // We don't need to explore different shapes, so we just swap
+      // macros until we find the best wire length.
+      pos_swap_prob = 0.0f;
+      neg_swap_prob = 0.0f;
+      double_swap_prob = 0.0f;
+      exchange_swap_prob = 1.0f;
+    }
 
     // Large arrays need more steps to properly converge.
     if (large_macro_cluster) {
@@ -2208,6 +2215,9 @@ void HierRTLMP::placeMacros(Cluster* cluster)
       sa->setFences(fences);
       sa->setGuides(guides);
       sa->setInitialSequencePair(initial_seq_pair);
+      if (!invalid_states_allowed) {
+        sa->disallowInvalidStates();
+      }
 
       sa_batch.push_back(std::move(sa));
 
@@ -2292,26 +2302,33 @@ void HierRTLMP::placeMacros(Cluster* cluster)
 //
 // Obs: Doing this will still keep the IO clusters at the end
 // of the sequence pair, which is needed for the way SA handles it.
-void HierRTLMP::setArrayTilingSequencePair(Cluster* cluster,
-                                           const int macros_to_place,
-                                           SequencePair& initial_seq_pair)
+SequencePair HierRTLMP::computeArraySequencePair(Cluster* cluster,
+                                                 bool& array_has_empty_space)
 {
-  // Set positive sequence
-  for (int i = 0; i < macros_to_place; ++i) {
-    initial_seq_pair.pos_sequence.push_back(i);
+  SequencePair sequence_pair;
+  const std::vector<HardMacro*>& hard_macros = cluster->getHardMacros();
+  const int number_of_macros = static_cast<int>(hard_macros.size());
+
+  for (int id = 0; id < number_of_macros; ++id) {
+    sequence_pair.pos_sequence.push_back(id);
   }
 
-  // Set negative sequence
-  const int columns
-      = cluster->getWidth() / cluster->getHardMacros().front()->getWidth();
-  const int rows
-      = cluster->getHeight() / cluster->getHardMacros().front()->getHeight();
+  const HardMacro* hard_macro = hard_macros.front();
+  const int columns = std::round(cluster->getWidth() / hard_macro->getWidth());
+  const int rows = std::round(cluster->getHeight() / hard_macro->getHeight());
 
   for (int i = 1; i <= columns; ++i) {
     for (int j = 1; j <= rows; j++) {
-      initial_seq_pair.neg_sequence.push_back(rows * i - j);
+      const int macro_id = (rows * i) - j;
+      if (macro_id < number_of_macros) {
+        sequence_pair.neg_sequence.push_back(macro_id);
+      } else {
+        array_has_empty_space = true;
+      }
     }
   }
+
+  return sequence_pair;
 }
 
 void HierRTLMP::computeFencesAndGuides(

src/mpl/src/hier_rtlmp.h

@@ -213,9 +213,8 @@ class HierRTLMP
   std::vector<BundledNet> computeBundledNets(
       const UniqueClusterVector& macro_clusters,
       const std::map<int, int>& cluster_to_macro);
-  void setArrayTilingSequencePair(Cluster* cluster,
-                                  int macros_to_place,
-                                  SequencePair& initial_seq_pair);
+  SequencePair computeArraySequencePair(Cluster* cluster,
+                                        bool& array_has_empty_space);
 
   // Orientation Improvement
   void generateTemporaryStdCellsPlacement(Cluster* cluster);

src/mpl/src/object.h

@@ -171,6 +171,8 @@ class Cluster
 
   void setAsArrayOfInterconnectedMacros();
   bool isArrayOfInterconnectedMacros() const;
+  void setAsMacroArray() { is_macro_array_ = true; }
+  bool isMacroArray() const { return is_macro_array_; }
   bool isEmpty() const;
   bool correspondsToLogicalModule() const;
 
@@ -247,6 +249,7 @@ class Cluster
   bool is_io_pad_cluster_{false};
   bool is_io_bundle_{false};
   bool is_array_of_interconnected_macros_ = false;
+  bool is_macro_array_{false};
   bool is_fixed_macro_{false};
 
   std::unique_ptr<SoftMacro> soft_macro_;