mpl: IOs abstraction adaptation to ORFS flow - second version (enhanced)

src/mpl/src/MplObserver.h

@@ -54,6 +54,18 @@ class MplObserver
   virtual void setOutline(const odb::Rect& outline) {}
   virtual void setGuides(const std::map<int, Rect>& guides) {}
   virtual void setFences(const std::map<int, Rect>& fences) {}
+  virtual void setIOConstraintsMap(
+      const ClusterToBoundaryRegionMap& io_cluster_to_constraint)
+  {
+  }
+  virtual void setBlockedRegionsForPins(
+      const std::vector<odb::Rect>& blocked_regions_for_pins)
+  {
+  }
+  virtual void setAvailableRegionsForUnconstrainedPins(
+      const BoundaryRegionList& regions)
+  {
+  }
 
   virtual void setAreaPenalty(const PenaltyData& penalty) {}
   virtual void setBoundaryPenalty(const PenaltyData& penalty) {}

src/mpl/src/SACoreHardMacro.cpp

@@ -31,7 +31,8 @@ SACoreHardMacro::SACoreHardMacro(PhysicalHierarchy* tree,
                                  int num_perturb_per_step,
                                  unsigned seed,
                                  MplObserver* graphics,
-                                 utl::Logger* logger)
+                                 utl::Logger* logger,
+                                 odb::dbBlock* block)
     : SimulatedAnnealingCore<HardMacro>(tree,
                                         outline,
                                         macros,
@@ -45,7 +46,8 @@ SACoreHardMacro::SACoreHardMacro(PhysicalHierarchy* tree,
                                         num_perturb_per_step,
                                         seed,
                                         graphics,
-                                        logger)
+                                        logger,
+                                        block)
 {
   flip_prob_ = flip_prob;
 }

src/mpl/src/SACoreHardMacro.h

@@ -34,7 +34,8 @@ class SACoreHardMacro : public SimulatedAnnealingCore<HardMacro>
                   int num_perturb_per_step,
                   unsigned seed,
                   MplObserver* graphics,
-                  utl::Logger* logger);
+                  utl::Logger* logger,
+                  odb::dbBlock* block);
 
   void run() override;
 

src/mpl/src/SACoreSoftMacro.cpp

@@ -42,7 +42,8 @@ SACoreSoftMacro::SACoreSoftMacro(PhysicalHierarchy* tree,
                                  int num_perturb_per_step,
                                  unsigned seed,
                                  MplObserver* graphics,
-                                 utl::Logger* logger)
+                                 utl::Logger* logger,
+                                 odb::dbBlock* block)
     : SimulatedAnnealingCore<SoftMacro>(tree,
                                         outline,
                                         macros,
@@ -56,7 +57,8 @@ SACoreSoftMacro::SACoreSoftMacro(PhysicalHierarchy* tree,
                                         num_perturb_per_step,
                                         seed,
                                         graphics,
-                                        logger),
+                                        logger,
+                                        block),
       root_(tree->root.get())
 {
   boundary_weight_ = boundary_weight;

src/mpl/src/SACoreSoftMacro.h

@@ -42,7 +42,8 @@ class SACoreSoftMacro : public SimulatedAnnealingCore<SoftMacro>
                   int num_perturb_per_step,
                   unsigned seed,
                   MplObserver* graphics,
-                  utl::Logger* logger);
+                  utl::Logger* logger,
+                  odb::dbBlock* block);
 
   void run() override;
 

src/mpl/src/SimulatedAnnealingCore.cpp

@@ -36,10 +36,9 @@ SimulatedAnnealingCore<T>::SimulatedAnnealingCore(PhysicalHierarchy* tree,
                                                   int num_perturb_per_step,
                                                   unsigned seed,
                                                   MplObserver* graphics,
-                                                  utl::Logger* logger)
-    : outline_(outline),
-      blocked_boundaries_(tree->blocked_boundaries),
-      graphics_(graphics)
+                                                  utl::Logger* logger,
+                                                  odb::dbBlock* block)
+    : outline_(outline), graphics_(graphics), block_(block)
 {
   core_weights_ = weights;
 
@@ -62,7 +61,10 @@ SimulatedAnnealingCore<T>::SimulatedAnnealingCore(PhysicalHierarchy* tree,
   macros_ = macros;
 
   setDieArea(tree->die_area);
-  setBlockedBoundariesForIOs();
+  setAvailableRegionsForUnconstrainedPins(
+      tree->available_regions_for_unconstrained_pins);
+
+  io_cluster_to_constraint_ = tree->io_cluster_to_constraint;
 }
 
 template <class T>
@@ -74,22 +76,14 @@ void SimulatedAnnealingCore<T>::setDieArea(const Rect& die_area)
 }
 
 template <class T>
-void SimulatedAnnealingCore<T>::setBlockedBoundariesForIOs()
+void SimulatedAnnealingCore<T>::setAvailableRegionsForUnconstrainedPins(
+    const BoundaryRegionList& regions)
 {
-  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;
-  }
+  available_regions_for_unconstrained_pins_ = regions;
 
-  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;
+  for (BoundaryRegion& region : available_regions_for_unconstrained_pins_) {
+    region.line.addX(-block_->micronsToDbu(outline_.xMin()));
+    region.line.addY(-block_->micronsToDbu(outline_.yMin()));
   }
 }
 
@@ -284,7 +278,7 @@ void SimulatedAnnealingCore<T>::calWirelength()
     T& target = macros_[net.terminals.second];
 
     if (target.isClusterOfUnplacedIOPins()) {
-      addBoundaryDistToWirelength(source, target, net.weight);
+      computeWLForClusterOfUnplacedIOPins(source, target, net.weight);
       continue;
     }
 
@@ -308,7 +302,7 @@ void SimulatedAnnealingCore<T>::calWirelength()
 }
 
 template <class T>
-void SimulatedAnnealingCore<T>::addBoundaryDistToWirelength(
+void SimulatedAnnealingCore<T>::computeWLForClusterOfUnplacedIOPins(
     const T& macro,
     const T& unplaced_ios,
     const float net_weight)
@@ -321,46 +315,27 @@ void SimulatedAnnealingCore<T>::addBoundaryDistToWirelength(
     return;
   }
 
-  const float x1 = macro.getPinX();
-  const float y1 = macro.getPinY();
-
-  Boundary constraint_boundary
-      = unplaced_ios.getCluster()->getConstraintBoundary();
-
-  if (constraint_boundary == NONE) {
-    float dist_to_left = max_dist;
-    if (!left_is_blocked_) {
-      dist_to_left = std::abs(x1 - die_area_.xMin());
+  const odb::Point macro_location(block_->micronsToDbu(macro.getPinX()),
+                                  block_->micronsToDbu(macro.getPinY()));
+  double smallest_distance;
+  if (unplaced_ios.getCluster()->isClusterOfUnconstrainedIOPins()) {
+    if (available_regions_for_unconstrained_pins_.empty()) {
+      logger_->critical(
+          utl::MPL,
+          47,
+          "There's no available region for the unconstrained pins!");
     }
 
-    float dist_to_right = max_dist;
-    if (!right_is_blocked_) {
-      dist_to_right = std::abs(x1 - die_area_.xMax());
-    }
-
-    float dist_to_bottom = max_dist;
-    if (!bottom_is_blocked_) {
-      dist_to_right = std::abs(y1 - die_area_.yMin());
-    }
-
-    float dist_to_top = max_dist;
-    if (!top_is_blocked_) {
-      dist_to_top = std::abs(y1 - die_area_.yMax());
-    }
-
-    wirelength_
-        += net_weight
-           * std::min(
-               {dist_to_left, dist_to_right, dist_to_bottom, dist_to_top});
-  } else if (constraint_boundary == Boundary::L
-             || constraint_boundary == Boundary::R) {
-    const float x2 = unplaced_ios.getPinX();
-    wirelength_ += net_weight * std::abs(x2 - x1);
-  } else if (constraint_boundary == Boundary::T
-             || constraint_boundary == Boundary::B) {
-    const float y2 = unplaced_ios.getPinY();
-    wirelength_ += net_weight * std::abs(y2 - y1);
+    smallest_distance = computeDistToNearestRegion(
+        macro_location, available_regions_for_unconstrained_pins_, nullptr);
+  } else {
+    Cluster* cluster = unplaced_ios.getCluster();
+    const BoundaryRegion& constraint = io_cluster_to_constraint_.at(cluster);
+    smallest_distance
+        = computeDistToNearestRegion(macro_location, {constraint}, nullptr);
   }
+
+  wirelength_ += net_weight * block_->dbuToMicrons(smallest_distance);
 }
 
 // We consider the macro outside the outline based on the location of

src/mpl/src/SimulatedAnnealingCore.h

@@ -52,7 +52,8 @@ class SimulatedAnnealingCore
                          int num_perturb_per_step,
                          unsigned seed,
                          MplObserver* graphics,
-                         utl::Logger* logger);
+                         utl::Logger* logger,
+                         odb::dbBlock* block);
 
   virtual ~SimulatedAnnealingCore() = default;
 
@@ -97,19 +98,20 @@ class SimulatedAnnealingCore
 
   void fastSA();
 
+  void setAvailableRegionsForUnconstrainedPins(
+      const BoundaryRegionList& regions);
   void initSequencePair();
   void setDieArea(const Rect& die_area);
-  void setBlockedBoundariesForIOs();
   void updateBestValidResult();
   void useBestValidResult();
 
   virtual float calNormCost() const = 0;
   virtual void calPenalty() = 0;
   void calOutlinePenalty();
   void calWirelength();
-  void addBoundaryDistToWirelength(const T& macro,
-                                   const T& unplaced_ios,
-                                   float net_weight);
+  void computeWLForClusterOfUnplacedIOPins(const T& macro,
+                                           const T& unplaced_ios,
+                                           float net_weight);
   bool isOutsideTheOutline(const T& macro) const;
   void calGuidancePenalty();
   void calFencePenalty();
@@ -136,8 +138,8 @@ class SimulatedAnnealingCore
   Rect outline_;
   Rect die_area_;  // Offset to the current outline.
 
-  // Boundaries blocked for IO pins
-  std::set<Boundary> blocked_boundaries_;
+  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;
@@ -203,6 +205,7 @@ class SimulatedAnnealingCore
 
   utl::Logger* logger_ = nullptr;
   MplObserver* graphics_ = nullptr;
+  odb::dbBlock* block_;
 
   Result best_valid_result_;
 
@@ -213,13 +216,6 @@ class SimulatedAnnealingCore
   static constexpr float acc_tolerance_ = 0.001;
 
   bool has_initial_sequence_pair_ = 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