mpl2: IOs abstraction adaptation to ORFS flow - first version (simplified)

src/mpl2/README.md

@@ -25,7 +25,6 @@ rtl_macro_placer
     [-tolerance tolerance]     
     [-max_num_level max_num_level] 
     [-coarsening_ratio coarsening_ratio]
-    [-num_bundled_ios num_bundled_ios]
     [-large_net_threshold large_net_threshold]
     [-signature_net_threshold signature_net_threshold]
     [-halo_width halo_width] 
@@ -61,7 +60,6 @@ rtl_macro_placer
 | `-tolerance` | Add a margin to the minimum and maximum number of macros/std cells in a cluster. For min, we multiply by (1 - `tol`), and for the max (1 + `tol`). This is to improve the robustness of hierarchical clustering. The allowed values are floats `[0, 1)`, and the default value is `0.1`. |
 | `-max_num_level` | Maximum depth of physical hierarchical tree. The default value is `2`, and the allowed values are integers `[0, MAX_INT]`. |
 | `-coarsening_ratio` | The larger the coarsening_ratio, the faster the convergence process. The allowed values are floats, and the default value is `10.0`. |
-| `-num_bundled_ios` | Specifies the number of bundled pins for the left, right, top, and bottom boundaries. The default value is `3`, and the allowed values are integers `[0, MAX_INT]`. |
 | `-large_net_threshold` | Ignore nets with many connections during clustering, such as global nets. The default value is `50`, and the allowed values are integers `[0, MAX_INT]`. |
 | `-signature_net_threshold` | Minimum number of connections between two clusters to be identified as connected. The default value is `50`, and the allowed values are integers `[0, MAX_INT]`. |
 | `-halo_width` | Horizontal/vertical halo around macros (microns). The allowed values are floats, and the default value is `0.0`. |

src/mpl2/include/mpl2/rtl_mp.h

@@ -77,7 +77,6 @@ class MacroPlacer2
              float tolerance,
              int max_num_level,
              float coarsening_ratio,
-             int num_bundled_ios,
              int large_net_threshold,
              int signature_net_threshold,
              float halo_width,

src/mpl2/src/Mpl2Observer.h

@@ -38,6 +38,7 @@
 #include <optional>
 #include <vector>
 
+#include "clusterEngine.h"
 #include "object.h"
 #include "odb/geom.h"
 #include "utl/Logger.h"
@@ -61,7 +62,7 @@ class Mpl2Observer
   virtual void endSA() {}
   virtual void drawResult() {}
 
-  virtual void finishedClustering(Cluster* root) {}
+  virtual void finishedClustering(PhysicalHierarchy* tree) {}
 
   virtual void setMaxLevel(int max_level) {}
   virtual void setMacroBlockages(const std::vector<mpl2::Rect>& macro_blockages)

src/mpl2/src/SACoreHardMacro.cpp

@@ -43,6 +43,7 @@ using utl::MPL;
 // Class SACoreHardMacro
 // constructors
 SACoreHardMacro::SACoreHardMacro(
+    PhysicalHierarchy* tree,
     const Rect& outline,
     const std::vector<HardMacro>& macros,
     // weight for different penalty
@@ -64,7 +65,8 @@ SACoreHardMacro::SACoreHardMacro(
     unsigned seed,
     Mpl2Observer* graphics,
     utl::Logger* logger)
-    : SimulatedAnnealingCore<HardMacro>(outline,
+    : SimulatedAnnealingCore<HardMacro>(tree,
+                                        outline,
                                         macros,
                                         area_weight,
                                         outline_weight,

src/mpl2/src/SACoreHardMacro.h

@@ -49,7 +49,8 @@ namespace mpl2 {
 class SACoreHardMacro : public SimulatedAnnealingCore<HardMacro>
 {
  public:
-  SACoreHardMacro(const Rect& outline,
+  SACoreHardMacro(PhysicalHierarchy* tree,
+                  const Rect& outline,
                   const std::vector<HardMacro>& macros,
                   // weight for different penalty
                   float area_weight,

src/mpl2/src/SACoreSoftMacro.cpp

@@ -43,7 +43,7 @@ using utl::MPL;
 // Class SACoreSoftMacro
 // constructors
 SACoreSoftMacro::SACoreSoftMacro(
-    Cluster* root,
+    PhysicalHierarchy* tree,
     const Rect& outline,
     const std::vector<SoftMacro>& macros,
     // weight for different penalty
@@ -71,7 +71,8 @@ SACoreSoftMacro::SACoreSoftMacro(
     unsigned seed,
     Mpl2Observer* graphics,
     utl::Logger* logger)
-    : SimulatedAnnealingCore<SoftMacro>(outline,
+    : SimulatedAnnealingCore<SoftMacro>(tree,
+                                        outline,
                                         macros,
                                         area_weight,
                                         outline_weight,
@@ -88,7 +89,7 @@ SACoreSoftMacro::SACoreSoftMacro(
                                         seed,
                                         graphics,
                                         logger),
-      root_(root)
+      root_(tree->root.get())
 {
   boundary_weight_ = boundary_weight;
   macro_blockage_weight_ = macro_blockage_weight;

src/mpl2/src/SACoreSoftMacro.h

@@ -50,7 +50,7 @@ class Graphics;
 class SACoreSoftMacro : public SimulatedAnnealingCore<SoftMacro>
 {
  public:
-  SACoreSoftMacro(Cluster* root,
+  SACoreSoftMacro(PhysicalHierarchy* tree,
                   const Rect& outline,
                   const std::vector<SoftMacro>& macros,
                   // weight for different penalty

src/mpl2/src/SimulatedAnnealingCore.cpp

@@ -48,6 +48,7 @@ using std::string;
 // Class SimulatedAnnealingCore
 template <class T>
 SimulatedAnnealingCore<T>::SimulatedAnnealingCore(
+    PhysicalHierarchy* tree,
     const Rect& outline,           // boundary constraints
     const std::vector<T>& macros,  // macros (T = HardMacro or T = SoftMacro)
     // weight for different penalty
@@ -68,7 +69,9 @@ SimulatedAnnealingCore<T>::SimulatedAnnealingCore(
     unsigned seed,
     Mpl2Observer* graphics,
     utl::Logger* logger)
-    : outline_(outline), graphics_(graphics)
+    : outline_(outline),
+      blocked_boundaries_(tree->blocked_boundaries),
+      graphics_(graphics)
 {
   area_weight_ = area_weight;
   outline_weight_ = outline_weight;
@@ -95,6 +98,26 @@ SimulatedAnnealingCore<T>::SimulatedAnnealingCore(
   macros_ = macros;
 }
 
+template <class T>
+void SimulatedAnnealingCore<T>::setBlockedBoundariesForIOs()
+{
+  if (blocked_boundaries_.find(Boundary::L) != blocked_boundaries_.end()) {
+    left_is_blocked_ = true;
+  }
+
+  if (blocked_boundaries_.find(Boundary::R) != blocked_boundaries_.end()) {
+    right_is_blocked_ = true;
+  }
+
+  if (blocked_boundaries_.find(Boundary::B) != blocked_boundaries_.end()) {
+    bottom_is_blocked_ = true;
+  }
+
+  if (blocked_boundaries_.find(Boundary::T) != blocked_boundaries_.end()) {
+    top_is_blocked_ = true;
+  }
+}
+
 template <class T>
 void SimulatedAnnealingCore<T>::initSequencePair()
 {
@@ -272,10 +295,18 @@ void SimulatedAnnealingCore<T>::calWirelength()
   }
 
   for (const auto& net : nets_) {
-    const float x1 = macros_[net.terminals.first].getPinX();
-    const float y1 = macros_[net.terminals.first].getPinY();
-    const float x2 = macros_[net.terminals.second].getPinX();
-    const float y2 = macros_[net.terminals.second].getPinY();
+    T& source = macros_[net.terminals.first];
+    T& target = macros_[net.terminals.second];
+
+    if (target.isIOCluster()) {
+      addBoundaryDistToWirelength(source, target, net.weight);
+      continue;
+    }
+
+    const float x1 = source.getPinX();
+    const float y1 = source.getPinY();
+    const float x2 = target.getPinX();
+    const float y2 = target.getPinY();
     wirelength_ += net.weight * (std::abs(x2 - x1) + std::abs(y2 - y1));
   }
 
@@ -288,6 +319,71 @@ void SimulatedAnnealingCore<T>::calWirelength()
   }
 }
 
+template <class T>
+void SimulatedAnnealingCore<T>::addBoundaryDistToWirelength(
+    const T& macro,
+    const T& io,
+    const float net_weight)
+{
+  Cluster* io_cluster = io.getCluster();
+  const Rect die = io_cluster->getBBox();
+  const float die_hpwl = die.getWidth() + die.getHeight();
+
+  if (isOutsideTheOutline(macro)) {
+    wirelength_ += net_weight * die_hpwl;
+    return;
+  }
+
+  const float x1 = macro.getPinX();
+  const float y1 = macro.getPinY();
+
+  Boundary constraint_boundary = io_cluster->getConstraintBoundary();
+
+  if (constraint_boundary == NONE) {
+    float dist_to_left = die_hpwl;
+    if (!left_is_blocked_) {
+      dist_to_left = std::abs(x1 - die.xMin());
+    }
+
+    float dist_to_right = die_hpwl;
+    if (!right_is_blocked_) {
+      dist_to_right = std::abs(x1 - die.xMax());
+    }
+
+    float dist_to_bottom = die_hpwl;
+    if (!bottom_is_blocked_) {
+      dist_to_right = std::abs(y1 - die.yMin());
+    }
+
+    float dist_to_top = die_hpwl;
+    if (!top_is_blocked_) {
+      dist_to_top = std::abs(y1 - die.yMax());
+    }
+
+    wirelength_
+        += net_weight
+           * std::min(
+               {dist_to_left, dist_to_right, dist_to_bottom, dist_to_top});
+  } else if (constraint_boundary == Boundary::L && !left_is_blocked_
+             || constraint_boundary == Boundary::R && !right_is_blocked_) {
+    const float x2 = io.getPinX();
+    wirelength_ += net_weight * std::abs(x2 - x1);
+  } else if (constraint_boundary == Boundary::T && !top_is_blocked_
+             || constraint_boundary == Boundary::B && !bottom_is_blocked_) {
+    const float y2 = io.getPinY();
+    wirelength_ += net_weight * std::abs(y2 - y1);
+  }
+}
+
+// We consider the macro outside the outline based on the location of
+// the pin to avoid too many checks.
+template <class T>
+bool SimulatedAnnealingCore<T>::isOutsideTheOutline(const T& macro) const
+{
+  return macro.getPinX() > outline_.getWidth()
+         || macro.getPinY() > outline_.getHeight();
+}
+
 template <class T>
 void SimulatedAnnealingCore<T>::calFencePenalty()
 {

src/mpl2/src/SimulatedAnnealingCore.h

@@ -38,6 +38,7 @@
 #include <vector>
 
 #include "Mpl2Observer.h"
+#include "clusterEngine.h"
 
 namespace utl {
 class Logger;
@@ -68,6 +69,7 @@ class SimulatedAnnealingCore
 {
  public:
   SimulatedAnnealingCore(
+      PhysicalHierarchy* tree,
       const Rect& outline,           // boundary constraints
       const std::vector<T>& macros,  // macros (T = HardMacro or T = SoftMacro)
       // weight for different penalty
@@ -89,6 +91,7 @@ class SimulatedAnnealingCore
       Mpl2Observer* graphics,
       utl::Logger* logger);
 
+  void setBlockedBoundariesForIOs();
   void setNumberOfMacrosToPlace(int macros_to_place)
   {
     macros_to_place_ = macros_to_place;
@@ -137,6 +140,10 @@ class SimulatedAnnealingCore
   virtual void calPenalty() = 0;
   void calOutlinePenalty();
   void calWirelength();
+  void addBoundaryDistToWirelength(const T& macro,
+                                   const T& io,
+                                   float net_weight);
+  bool isOutsideTheOutline(const T& macro) const;
   void calGuidancePenalty();
   void calFencePenalty();
 
@@ -161,6 +168,9 @@ class SimulatedAnnealingCore
   // boundary constraints
   Rect outline_;
 
+  // Boundaries blocked for IO pins
+  std::set<Boundary> blocked_boundaries_;
+
   // Number of macros that will actually be part of the sequence pair
   int macros_to_place_ = 0;
 
@@ -245,6 +255,13 @@ class SimulatedAnnealingCore
   bool has_initial_sequence_pair_ = false;
   bool centralization_on_ = false;
   bool centralization_was_reverted_ = false;
+
+  // Blocked boundaries data is kept in bools to avoid overhead
+  // during SA steps.
+  bool left_is_blocked_ = false;
+  bool right_is_blocked_ = false;
+  bool bottom_is_blocked_ = false;
+  bool top_is_blocked_ = false;
 };
 
 // SACore wrapper function