mpl:

   1) Improve naming;
   2) Fix outline offset done in available regions for unconstrained pins.

Signed-off-by: Arthur Koucher <arthurkoucher@precisioninno.com>

Author: AcKoucher

src/mpl/src/MplObserver.h

@@ -62,7 +62,10 @@ class MplObserver
       const std::vector<odb::Rect>& blocked_regions_for_pins)
   {
   }
-  virtual void setAvailableRegionsForPins(const BoundaryRegionList& regions) {}
+  virtual void setAvailableRegionsForUnconstrainedPins(
+      const BoundaryRegionList& regions)
+  {
+  }
 
   virtual void setAreaPenalty(const PenaltyData& penalty) {}
   virtual void setBoundaryPenalty(const PenaltyData& penalty) {}

src/mpl/src/SimulatedAnnealingCore.cpp

@@ -61,7 +61,8 @@ SimulatedAnnealingCore<T>::SimulatedAnnealingCore(PhysicalHierarchy* tree,
   macros_ = macros;
 
   setDieArea(tree->die_area);
-  setAvailableRegionForPins(tree->available_regions_for_pins);
+  setAvailableRegionsForUnconstrainedPins(
+      tree->available_regions_for_unconstrained_pins);
 
   io_cluster_to_constraint_ = tree->io_cluster_to_constraint;
 }
@@ -75,14 +76,14 @@ void SimulatedAnnealingCore<T>::setDieArea(const Rect& die_area)
 }
 
 template <class T>
-void SimulatedAnnealingCore<T>::setAvailableRegionForPins(
+void SimulatedAnnealingCore<T>::setAvailableRegionsForUnconstrainedPins(
     const BoundaryRegionList& regions)
 {
-  available_regions_for_pins_ = regions;
+  available_regions_for_unconstrained_pins_ = regions;
 
-  for (BoundaryRegion& region : available_regions_for_pins_) {
+  for (BoundaryRegion& region : available_regions_for_unconstrained_pins_) {
     region.line.addX(-block_->micronsToDbu(outline_.xMin()));
-    region.line.addY(-block_->micronsToDbu(outline_.xMin()));
+    region.line.addY(-block_->micronsToDbu(outline_.yMin()));
   }
 }
 
@@ -318,15 +319,15 @@ void SimulatedAnnealingCore<T>::computeWLForClusterOfUnplacedIOPins(
                                   block_->micronsToDbu(macro.getPinY()));
   double smallest_distance;
   if (unplaced_ios.getCluster()->isClusterOfUnconstrainedIOPins()) {
-    if (available_regions_for_pins_.empty()) {
+    if (available_regions_for_unconstrained_pins_.empty()) {
       logger_->critical(
           utl::MPL,
           47,
           "There's no available region for the unconstrained pins!");
     }
 
     smallest_distance = computeDistToNearestRegion(
-        macro_location, available_regions_for_pins_, nullptr);
+        macro_location, available_regions_for_unconstrained_pins_, nullptr);
   } else {
     Cluster* cluster = unplaced_ios.getCluster();
     const BoundaryRegion& constraint = io_cluster_to_constraint_.at(cluster);

src/mpl/src/SimulatedAnnealingCore.h

@@ -98,7 +98,8 @@ class SimulatedAnnealingCore
 
   void fastSA();
 
-  void setAvailableRegionForPins(const BoundaryRegionList& regions);
+  void setAvailableRegionsForUnconstrainedPins(
+      const BoundaryRegionList& regions);
   void initSequencePair();
   void setDieArea(const Rect& die_area);
   void updateBestValidResult();
@@ -137,7 +138,7 @@ class SimulatedAnnealingCore
   Rect outline_;
   Rect die_area_;  // Offset to the current outline.
 
-  BoundaryRegionList available_regions_for_pins_;
+  BoundaryRegionList available_regions_for_unconstrained_pins_;
   ClusterToBoundaryRegionMap io_cluster_to_constraint_;
 
   // Number of macros that will actually be part of the sequence pair

src/mpl/src/clusterEngine.h

@@ -90,7 +90,7 @@ struct PhysicalHierarchy
   std::unique_ptr<Cluster> root;
   PhysicalHierarchyMaps maps;
 
-  BoundaryRegionList available_regions_for_pins;
+  BoundaryRegionList available_regions_for_unconstrained_pins;
   ClusterToBoundaryRegionMap io_cluster_to_constraint;
 
   float halo_width{0.0f};

src/mpl/src/graphics.cpp

@@ -593,7 +593,8 @@ void Graphics::drawDistToRegion(gui::Painter& painter,
 
   odb::Point to;
   if (io.getCluster()->isClusterOfUnconstrainedIOPins()) {
-    computeDistToNearestRegion(from, available_regions_for_pins_, &to);
+    computeDistToNearestRegion(
+        from, available_regions_for_unconstrained_pins_, &to);
   } else {
     computeDistToNearestRegion(
         from, {io_cluster_to_constraint_.at(io.getCluster())}, &to);
@@ -719,9 +720,10 @@ void Graphics::setBlockedRegionsForPins(
   blocked_regions_for_pins_ = blocked_regions_for_pins;
 }
 
-void Graphics::setAvailableRegionsForPins(const BoundaryRegionList& regions)
+void Graphics::setAvailableRegionsForUnconstrainedPins(
+    const BoundaryRegionList& regions)
 {
-  available_regions_for_pins_ = regions;
+  available_regions_for_unconstrained_pins_ = regions;
 }
 
 void Graphics::eraseDrawing()

src/mpl/src/graphics.h

@@ -65,7 +65,8 @@ class Graphics : public gui::Renderer, public MplObserver
       const ClusterToBoundaryRegionMap& io_cluster_to_constraint) override;
   void setBlockedRegionsForPins(
       const std::vector<odb::Rect>& blocked_regions_for_pins) override;
-  void setAvailableRegionsForPins(const BoundaryRegionList& regions) override;
+  void setAvailableRegionsForUnconstrainedPins(
+      const BoundaryRegionList& regions) override;
 
   void eraseDrawing() override;
 
@@ -108,7 +109,7 @@ class Graphics : public gui::Renderer, public MplObserver
   int target_cluster_id_{-1};
   std::vector<std::vector<odb::Rect>> outlines_;
   std::vector<odb::Rect> blocked_regions_for_pins_;
-  BoundaryRegionList available_regions_for_pins_;
+  BoundaryRegionList available_regions_for_unconstrained_pins_;
   ClusterToBoundaryRegionMap io_cluster_to_constraint_;
 
   // In Soft SA, we're shaping/placing the children of a certain parent,

src/mpl/src/hier_rtlmp.cpp

@@ -317,7 +317,7 @@ void HierRTLMP::runCoarseShaping()
 
   calculateChildrenTilings(tree_->root.get());
 
-  searchForAvailableRegionsForPins();
+  searchAvailableRegionsForUnconstrainedPins();
   createPinAccessBlockages();
   setPlacementBlockages();
 }
@@ -872,7 +872,7 @@ void HierRTLMP::setTightPackingTilings(Cluster* macro_array)
   macro_array->setTilings(tight_packing_tilings);
 }
 
-void HierRTLMP::searchForAvailableRegionsForPins()
+void HierRTLMP::searchAvailableRegionsForUnconstrainedPins()
 {
   if (treeHasConstrainedIOs()) {
     return;
@@ -886,15 +886,17 @@ void HierRTLMP::searchForAvailableRegionsForPins()
   std::vector<odb::Rect> available_regions
       = computeAvailableRegions(boundary_to_blocked_regions);
 
-  tree_->available_regions_for_pins.reserve(available_regions.size());
+  tree_->available_regions_for_unconstrained_pins.reserve(
+      available_regions.size());
   for (const odb::Rect& region : available_regions) {
-    tree_->available_regions_for_pins.emplace_back(
+    tree_->available_regions_for_unconstrained_pins.emplace_back(
         rectToLine(block_, region, logger_), getBoundary(block_, region));
   }
 
   if (graphics_) {
     graphics_->setBlockedRegionsForPins(blocked_regions_for_pins);
-    graphics_->setAvailableRegionsForPins(tree_->available_regions_for_pins);
+    graphics_->setAvailableRegionsForUnconstrainedPins(
+        tree_->available_regions_for_unconstrained_pins);
   }
 }
 
@@ -923,7 +925,7 @@ void HierRTLMP::createPinAccessBlockages()
 
   computePinAccessDepthLimits();
 
-  if (!tree_->available_regions_for_pins.empty()) {
+  if (!tree_->available_regions_for_unconstrained_pins.empty()) {
     createBlockagesForAvailableRegions();
   } else {
     createBlockagesForConstraintRegions();
@@ -953,14 +955,16 @@ bool HierRTLMP::treeHasConstrainedIOs() const
 void HierRTLMP::createBlockagesForAvailableRegions()
 {
   double io_span = 0.0;
-  for (const BoundaryRegion& region : tree_->available_regions_for_pins) {
+  for (const BoundaryRegion& region :
+       tree_->available_regions_for_unconstrained_pins) {
     io_span += std::sqrt(
         odb::Point::squaredDistance(region.line.pt0(), region.line.pt1()));
   }
 
   const float depth = computePinAccessBaseDepth(block_->dbuToMicrons(io_span));
 
-  for (const BoundaryRegion region : tree_->available_regions_for_pins) {
+  for (const BoundaryRegion region :
+       tree_->available_regions_for_unconstrained_pins) {
     createPinAccessBlockage(region, depth);
   }
 }
@@ -2754,9 +2758,10 @@ float HierRTLMP::calculateRealMacroWirelength(odb::dbInst* macro)
           computeDistToNearestRegion(
               macro_pin->getBBox().center(), {constraint}, &nearest_point);
         } else {
-          computeDistToNearestRegion(macro_pin->getBBox().center(),
-                                     tree_->available_regions_for_pins,
-                                     &nearest_point);
+          computeDistToNearestRegion(
+              macro_pin->getBBox().center(),
+              tree_->available_regions_for_unconstrained_pins,
+              &nearest_point);
         }
         odb::Rect point_rect(nearest_point, nearest_point);
         net_box.merge(point_rect);

src/mpl/src/hier_rtlmp.h

@@ -148,7 +148,7 @@ class HierRTLMP
   void calculateMacroTilings(Cluster* cluster);
   IntervalList computeWidthIntervals(const TilingList& tilings);
   void setTightPackingTilings(Cluster* macro_array);
-  void searchForAvailableRegionsForPins();
+  void searchAvailableRegionsForUnconstrainedPins();
   BoundaryToRegionsMap getBoundaryToBlockedRegionsMap(
       const std::vector<odb::Rect>& blocked_regions_for_pins) const;
   std::vector<odb::Rect> computeAvailableRegions(