Merge pull request #8099 from AcKoucher/mpl-fixed-macros-packing

mpl: add support for partial automatic macro placement

Author: maliberty

src/mpl/src/MplObserver.h

@@ -74,6 +74,7 @@ class MplObserver
   virtual void setFencePenalty(const PenaltyData& penalty) {}
   virtual void setGuidancePenalty(const PenaltyData& penalty) {}
   virtual void setMacroBlockagePenalty(const PenaltyData& penalty) {}
+  virtual void setFixedMacrosPenalty(const PenaltyData& penalty) {}
   virtual void setNotchPenalty(const PenaltyData& penalty) {}
   virtual void setOutlinePenalty(const PenaltyData& penalty) {}
   virtual void setWirelengthPenalty(const PenaltyData& penalty) {}

src/mpl/src/SACoreSoftMacro.cpp

@@ -76,6 +76,16 @@ SACoreSoftMacro::SACoreSoftMacro(PhysicalHierarchy* tree,
   logger_ = logger;
 }
 
+void SACoreSoftMacro::findFixedMacros()
+{
+  for (const int macro_id : pos_seq_) {
+    const SoftMacro& macro = macros_[macro_id];
+    if (macro.isFixed()) {
+      fixed_macros_.push_back(macro.getBBox());
+    }
+  }
+}
+
 void SACoreSoftMacro::run()
 {
   if (graphics_) {
@@ -93,6 +103,15 @@ void SACoreSoftMacro::run()
   }
 }
 
+bool SACoreSoftMacro::isValid() const
+{
+  if (!fixed_macros_.empty() && fixed_macros_penalty_ > 0.0f) {
+    return false;
+  }
+
+  return resultFitsInOutline();
+}
+
 // acessors functions
 float SACoreSoftMacro::getBoundaryPenalty() const
 {
@@ -152,6 +171,10 @@ float SACoreSoftMacro::calNormCost() const
     cost += macro_blockage_weight_ * macro_blockage_penalty_
             / norm_macro_blockage_penalty_;
   }
+  if (norm_fixed_macros_penalty_ > 0.0) {
+    cost += fixed_macros_weight_ * fixed_macros_penalty_
+            / norm_fixed_macros_penalty_;
+  }
   if (norm_notch_penalty_ > 0.0) {
     cost += notch_weight_ * notch_penalty_ / norm_notch_penalty_;
   }
@@ -167,6 +190,7 @@ void SACoreSoftMacro::calPenalty()
   calBoundaryPenalty();
   calMacroBlockagePenalty();
   calNotchPenalty();
+  calFixedMacrosPenalty();
   if (graphics_) {
     graphics_->setAreaPenalty(
         {"Area", core_weights_.area, getAreaPenalty(), norm_area_penalty_});
@@ -268,6 +292,7 @@ void SACoreSoftMacro::restoreState()
 void SACoreSoftMacro::initialize()
 {
   initSequencePair();
+  findFixedMacros();
 
   std::vector<float> outline_penalty_list;
   std::vector<float> wirelength_list;
@@ -277,6 +302,7 @@ void SACoreSoftMacro::initialize()
   std::vector<float> macro_blockage_penalty_list;
   std::vector<float> notch_penalty_list;
   std::vector<float> area_penalty_list;
+  std::vector<float> fixed_macros_penalty_list;
   std::vector<float> width_list;
   std::vector<float> height_list;
 
@@ -298,6 +324,7 @@ void SACoreSoftMacro::initialize()
     boundary_penalty_list.push_back(boundary_penalty_);
     macro_blockage_penalty_list.push_back(macro_blockage_penalty_);
     notch_penalty_list.push_back(notch_penalty_);
+    fixed_macros_penalty_list.push_back(fixed_macros_penalty_);
   }
   graphics_ = save_graphics;
 
@@ -309,6 +336,7 @@ void SACoreSoftMacro::initialize()
   norm_boundary_penalty_ = calAverage(boundary_penalty_list);
   norm_macro_blockage_penalty_ = calAverage(macro_blockage_penalty_list);
   norm_notch_penalty_ = calAverage(notch_penalty_list);
+  norm_fixed_macros_penalty_ = calAverage(fixed_macros_penalty_list);
 
   // Reset penalites if lower than threshold
 
@@ -344,6 +372,10 @@ void SACoreSoftMacro::initialize()
     norm_notch_penalty_ = 1.0;
   }
 
+  if (norm_fixed_macros_penalty_ <= 1e-4) {
+    norm_fixed_macros_penalty_ = 1.0;
+  }
+
   // Calculate initial temperature
   std::vector<float> cost_list;
   for (int i = 0; i < outline_penalty_list.size(); i++) {
@@ -356,6 +388,7 @@ void SACoreSoftMacro::initialize()
     boundary_penalty_ = boundary_penalty_list[i];
     macro_blockage_penalty_ = macro_blockage_penalty_list[i];
     notch_penalty_ = notch_penalty_list[i];
+    fixed_macros_penalty_ = fixed_macros_penalty_list[i];
     cost_list.push_back(calNormCost());
   }
   float delta_cost = 0.0;
@@ -383,12 +416,17 @@ void SACoreSoftMacro::calBoundaryPenalty()
     return;
   }
 
-  int tot_num_macros = 0;
+  int number_of_movable_macros = 0;
   for (const auto& macro_id : pos_seq_) {
-    tot_num_macros += macros_[macro_id].getNumMacro();
+    const SoftMacro& soft_macro = macros_[macro_id];
+    if (soft_macro.isFixed()) {
+      continue;
+    }
+
+    number_of_movable_macros += soft_macro.getNumMacro();
   }
 
-  if (tot_num_macros <= 0) {
+  if (number_of_movable_macros == 0) {
     return;
   }
 
@@ -397,23 +435,28 @@ void SACoreSoftMacro::calBoundaryPenalty()
   float x_dist_from_root = 0.0f, y_dist_from_root = 0.0f;
 
   for (const auto& macro_id : pos_seq_) {
-    if (macros_[macro_id].getNumMacro() > 0) {
-      global_lx = macros_[macro_id].getX() + outline_.xMin() - root_->getX();
-      global_ly = macros_[macro_id].getY() + outline_.yMin() - root_->getY();
-      global_ux = global_lx + macros_[macro_id].getWidth();
-      global_uy = global_ly + macros_[macro_id].getHeight();
+    const SoftMacro& soft_macro = macros_[macro_id];
+    if (soft_macro.isFixed()) {
+      continue;
+    }
+
+    if (soft_macro.getNumMacro() > 0) {
+      global_lx = soft_macro.getX() + outline_.xMin() - root_->getX();
+      global_ly = soft_macro.getY() + outline_.yMin() - root_->getY();
+      global_ux = global_lx + soft_macro.getWidth();
+      global_uy = global_ly + soft_macro.getHeight();
 
       x_dist_from_root
           = std::min(global_lx, std::abs(root_->getWidth() - global_ux));
       y_dist_from_root
           = std::min(global_ly, std::abs(root_->getHeight() - global_uy));
 
       boundary_penalty_ += std::min(x_dist_from_root, y_dist_from_root)
-                           * macros_[macro_id].getNumMacro();
+                           * soft_macro.getNumMacro();
     }
   }
   // normalization
-  boundary_penalty_ = boundary_penalty_ / tot_num_macros;
+  boundary_penalty_ = boundary_penalty_ / number_of_movable_macros;
   if (graphics_) {
     graphics_->setBoundaryPenalty({"Boundary",
                                    boundary_weight_,
@@ -474,6 +517,42 @@ void SACoreSoftMacro::calMacroBlockagePenalty()
   }
 }
 
+void SACoreSoftMacro::calFixedMacrosPenalty()
+{
+  if (fixed_macros_.empty()) {
+    return;
+  }
+
+  fixed_macros_penalty_ = 0.0f;
+
+  for (const Rect& fixed_macro : fixed_macros_) {
+    for (const int macro_id : pos_seq_) {
+      const SoftMacro& macro = macros_[macro_id];
+
+      // Skip the current fixed macro itself and unneeded computation.
+      if (macro.isFixed()) {
+        continue;
+      }
+
+      Tiling overlap_shape = computeOverlapShape(fixed_macro, macro.getBBox());
+
+      // If any of the dimensions is negative, then there's no overlap.
+      if (overlap_shape.width() < 0 || overlap_shape.height() < 0) {
+        continue;
+      }
+
+      fixed_macros_penalty_ += overlap_shape.width() * overlap_shape.height();
+    }
+  }
+
+  if (graphics_) {
+    graphics_->setFixedMacrosPenalty({"Fixed Macros",
+                                      fixed_macros_weight_,
+                                      fixed_macros_penalty_,
+                                      norm_fixed_macros_penalty_});
+  }
+}
+
 // Align macro clusters to reduce notch
 void SACoreSoftMacro::alignMacroClusters()
 {

src/mpl/src/SACoreSoftMacro.h

@@ -47,6 +47,7 @@ class SACoreSoftMacro : public SimulatedAnnealingCore<SoftMacro>
                   odb::dbBlock* block);
 
   void run() override;
+  bool isValid() const override;
 
   // accessors
   float getBoundaryPenalty() const;
@@ -87,14 +88,18 @@ class SACoreSoftMacro : public SimulatedAnnealingCore<SoftMacro>
   float calSingleNotchPenalty(float width, float height);
   void calNotchPenalty();
   void calMacroBlockagePenalty();
+  void calFixedMacrosPenalty();
 
   // Only for Cluster Placement:
   void attemptCentralization(float pre_cost);
   void moveFloorplan(const std::pair<float, float>& offset);
 
   Tiling computeOverlapShape(const Rect& rect_a, const Rect& rect_b) const;
 
+  void findFixedMacros();
+
   std::vector<Rect> blockages_;
+  std::vector<Rect> fixed_macros_;
 
   Cluster* root_;
 
@@ -111,10 +116,12 @@ class SACoreSoftMacro : public SimulatedAnnealingCore<SoftMacro>
   float boundary_weight_ = 0.0;
   float macro_blockage_weight_ = 0.0;
   float notch_weight_ = 0.0;
+  const float fixed_macros_weight_ = 100.0;
 
   float boundary_penalty_ = 0.0;
   float notch_penalty_ = 0.0;
   float macro_blockage_penalty_ = 0.0;
+  float fixed_macros_penalty_ = 0.0;
 
   float pre_boundary_penalty_ = 0.0;
   float pre_notch_penalty_ = 0.0;
@@ -123,6 +130,7 @@ class SACoreSoftMacro : public SimulatedAnnealingCore<SoftMacro>
   float norm_boundary_penalty_ = 0.0;
   float norm_notch_penalty_ = 0.0;
   float norm_macro_blockage_penalty_ = 0.0;
+  float norm_fixed_macros_penalty_ = 0.0;
 
   // action prob
   float resize_prob_ = 0.0;

src/mpl/src/SimulatedAnnealingCore.cpp

@@ -153,8 +153,7 @@ void SimulatedAnnealingCore<T>::setInitialSequencePair(
 template <class T>
 bool SimulatedAnnealingCore<T>::isValid() const
 {
-  return (width_ <= std::ceil(outline_.getWidth()))
-         && (height_ <= std::ceil(outline_.getHeight()));
+  return resultFitsInOutline();
 }
 
 template <class T>
@@ -459,11 +458,13 @@ void SimulatedAnnealingCore<T>::packFloorplan()
   for (int i = 0; i < pos_seq_.size(); i++) {
     const int macro_id = pos_seq_[i];
     const int neg_seq_pos = sequence_pair_pos[macro_id].second;
+    T& macro = macros_[macro_id];
 
-    macros_[macro_id].setX(accumulated_length[neg_seq_pos]);
+    if (!macro.isFixed()) {
+      macro.setX(accumulated_length[neg_seq_pos]);
+    }
 
-    const float current_length
-        = macros_[macro_id].getX() + macros_[macro_id].getWidth();
+    const float current_length = macro.getX() + macro.getWidth();
 
     for (int j = neg_seq_pos; j < neg_seq_.size(); j++) {
       if (current_length > accumulated_length[j]) {
@@ -494,11 +495,13 @@ void SimulatedAnnealingCore<T>::packFloorplan()
   for (int i = 0; i < pos_seq_.size(); i++) {
     const int macro_id = reversed_pos_seq[i];
     const int neg_seq_pos = sequence_pair_pos[macro_id].second;
+    T& macro = macros_[macro_id];
 
-    macros_[macro_id].setY(accumulated_length[neg_seq_pos]);
+    if (!macro.isFixed()) {
+      macro.setY(accumulated_length[neg_seq_pos]);
+    }
 
-    const float current_height
-        = macros_[macro_id].getY() + macros_[macro_id].getHeight();
+    const float current_height = macro.getY() + macro.getHeight();
 
     for (int j = neg_seq_pos; j < neg_seq_.size(); j++) {
       if (current_height > accumulated_length[j]) {
@@ -765,6 +768,13 @@ void SimulatedAnnealingCore<T>::fastSA()
   }
 }
 
+template <class T>
+bool SimulatedAnnealingCore<T>::resultFitsInOutline() const
+{
+  return (width_ <= std::ceil(outline_.getWidth()))
+         && (height_ <= std::ceil(outline_.getHeight()));
+}
+
 template <class T>
 void SimulatedAnnealingCore<T>::updateBestResult(const float cost)
 {

src/mpl/src/SimulatedAnnealingCore.h

@@ -68,7 +68,7 @@ class SimulatedAnnealingCore
   void setGuides(const std::map<int, Rect>& guides);
   void setInitialSequencePair(const SequencePair& sequence_pair);
 
-  bool isValid() const;
+  virtual bool isValid() const;
   bool fitsIn(const Rect& outline) const;
   void writeCostFile(const std::string& file_name) const;
   float getNormCost() const;
@@ -102,6 +102,7 @@ class SimulatedAnnealingCore
   };
 
   void fastSA();
+  bool resultFitsInOutline() const;
 
   void setAvailableRegionsForUnconstrainedPins(
       const BoundaryRegionList& regions);