mpl: support timing-driven macro placement

src/OpenRoad.cc

@@ -235,8 +235,8 @@ void OpenRoad::init(Tcl_Interp* tcl_interp,
                                   estimate_parasitics_);
   tapcell_ = new tap::Tapcell(db_, logger_);
   partitionMgr_ = new par::PartitionMgr(db_, getDbNetwork(), sta_, logger_);
-  macro_placer_
-      = new mpl::MacroPlacer(getDbNetwork(), db_, sta_, logger_, partitionMgr_);
+  macro_placer_ = new mpl::MacroPlacer(
+      getDbNetwork(), db_, sta_, logger_, partitionMgr_, resizer_);
   extractor_ = new rcx::Ext(db_, logger_, getVersion());
   distributer_ = new dst::Distributed(logger_);
   detailed_router_ = new drt::TritonRoute(

src/mpl/BUILD

@@ -42,6 +42,7 @@ cc_library(
         "//src/dbSta:dbNetwork",
         "//src/odb",
         "//src/par",
+        "//src/rsz",
         "//src/sta:opensta_lib",
         "//src/utl",
         "@boost.polygon",
@@ -78,6 +79,7 @@ cc_library(
         "//:ord",
         "//src/gui",
         "//src/odb",
+        "//src/rsz",
         "//src/utl",
         "@boost.stacktrace",
         "@tk_tcl//:tcl",

src/mpl/CMakeLists.txt

@@ -31,6 +31,7 @@ target_link_libraries(mpl_lib
     ortools::ortools
     dl
     par_lib
+    rsz_lib
 )
 
 swig_lib(NAME      mpl

src/mpl/include/mpl/rtl_mp.h

@@ -27,6 +27,10 @@ namespace par {
 class PartitionMgr;
 }
 
+namespace rsz {
+class Resizer;
+}
+
 namespace mpl {
 
 class HierRTLMP;
@@ -39,7 +43,8 @@ class MacroPlacer
               odb::dbDatabase* db,
               sta::dbSta* sta,
               utl::Logger* logger,
-              par::PartitionMgr* tritonpart);
+              par::PartitionMgr* tritonpart,
+              rsz::Resizer* resizer);
   ~MacroPlacer();
 
   bool place(int num_threads,
@@ -66,6 +71,7 @@ class MacroPlacer
              float target_dead_space,
              float min_ar,
              const char* report_directory,
+             bool timing_driven,
              bool keep_clustering_data);
 
   void placeMacro(odb::dbInst* inst,

src/mpl/src/MplObserver.h

@@ -45,6 +45,7 @@ class MplObserver
   {
   }
   virtual void setNets(const BundledNetList& nets) {}
+  virtual void setCriticalNets(const BundledNetList& critical_nets) {}
   virtual void setShowBundledNets(bool show_bundled_nets) {}
   virtual void setShowClustersIds(bool show_clusters_ids) {}
   virtual void setSkipSteps(bool skip_steps) {}
@@ -78,6 +79,7 @@ class MplObserver
   virtual void setNotchPenalty(const PenaltyData& penalty) {}
   virtual void setOutlinePenalty(const PenaltyData& penalty) {}
   virtual void setWirelengthPenalty(const PenaltyData& penalty) {}
+  virtual void setCriticalWireLengthPenalty(const PenaltyData& penalty) {}
   virtual void penaltyCalculated(float norm_cost) {}
 
   virtual void eraseDrawing() {}

src/mpl/src/SACoreHardMacro.cpp

@@ -81,6 +81,10 @@ float SACoreHardMacro::calNormCost() const
   if (norm_wirelength_ > 0.0) {
     cost += core_weights_.wirelength * wirelength_ / norm_wirelength_;
   }
+  if (norm_critical_wirelength_ > 0.0) {
+    cost += core_weights_.critical_wirelength * critical_wirelength_
+            / norm_critical_wirelength_;
+  }
   if (norm_guidance_penalty_ > 0.0) {
     cost += core_weights_.guidance * guidance_penalty_ / norm_guidance_penalty_;
   }
@@ -94,6 +98,7 @@ void SACoreHardMacro::calPenalty()
 {
   calOutlinePenalty();
   calWirelength();
+  calCriticalWireLength();
   calGuidancePenalty();
   calFencePenalty();
   if (graphics_) {
@@ -191,6 +196,7 @@ void SACoreHardMacro::initialize()
   std::vector<float> area_penalty_list;
   std::vector<float> outline_penalty_list;
   std::vector<float> wirelength_list;
+  std::vector<float> critical_wirelength_list;
   std::vector<float> guidance_penalty_list;
   std::vector<float> fence_penalty_list;
   std::vector<float> width_list;
@@ -214,6 +220,7 @@ void SACoreHardMacro::initialize()
     area_penalty_list.push_back(getAreaPenalty());
     outline_penalty_list.push_back(outline_penalty_);
     wirelength_list.push_back(wirelength_);
+    critical_wirelength_list.push_back(critical_wirelength_);
     guidance_penalty_list.push_back(guidance_penalty_);
     fence_penalty_list.push_back(fence_penalty_);
   }
@@ -222,6 +229,7 @@ void SACoreHardMacro::initialize()
   norm_area_penalty_ = calAverage(area_penalty_list);
   norm_outline_penalty_ = calAverage(outline_penalty_list);
   norm_wirelength_ = calAverage(wirelength_list);
+  norm_critical_wirelength_ = calAverage(critical_wirelength_list);
   norm_guidance_penalty_ = calAverage(guidance_penalty_list);
   norm_fence_penalty_ = calAverage(fence_penalty_list);
 
@@ -237,6 +245,10 @@ void SACoreHardMacro::initialize()
     norm_wirelength_ = 1.0;
   }
 
+  if (norm_critical_wirelength_ <= 1e-4) {
+    norm_critical_wirelength_ = 1.0;
+  }
+
   if (norm_guidance_penalty_ <= 1e-4) {
     norm_guidance_penalty_ = 1.0;
   }
@@ -252,6 +264,7 @@ void SACoreHardMacro::initialize()
     height_ = height_list[i];
     outline_penalty_ = outline_penalty_list[i];
     wirelength_ = wirelength_list[i];
+    critical_wirelength_ = critical_wirelength_list[i];
     guidance_penalty_ = guidance_penalty_list[i];
     fence_penalty_ = fence_penalty_list[i];
     cost_list.push_back(calNormCost());

src/mpl/src/SACoreSoftMacro.cpp

@@ -160,6 +160,10 @@ float SACoreSoftMacro::calNormCost() const
   if (norm_wirelength_ > 0.0) {
     cost += core_weights_.wirelength * wirelength_ / norm_wirelength_;
   }
+  if (norm_critical_wirelength_ > 0.0) {
+    cost += core_weights_.critical_wirelength * critical_wirelength_
+            / norm_critical_wirelength_;
+  }
   if (norm_guidance_penalty_ > 0.0) {
     cost += core_weights_.guidance * guidance_penalty_ / norm_guidance_penalty_;
   }
@@ -188,6 +192,7 @@ void SACoreSoftMacro::calPenalty()
 {
   calOutlinePenalty();
   calWirelength();
+  calCriticalWireLength();
   calGuidancePenalty();
   calFencePenalty();
   calBoundaryPenalty();
@@ -299,6 +304,7 @@ void SACoreSoftMacro::initialize()
 
   std::vector<float> outline_penalty_list;
   std::vector<float> wirelength_list;
+  std::vector<float> critical_wirelength_list;
   std::vector<float> guidance_penalty_list;
   std::vector<float> fence_penalty_list;
   std::vector<float> boundary_penalty_list;
@@ -326,6 +332,7 @@ void SACoreSoftMacro::initialize()
     area_penalty_list.push_back(getAreaPenalty());
     outline_penalty_list.push_back(outline_penalty_);
     wirelength_list.push_back(wirelength_);
+    critical_wirelength_list.push_back(critical_wirelength_);
     guidance_penalty_list.push_back(guidance_penalty_);
     fence_penalty_list.push_back(fence_penalty_);
     boundary_penalty_list.push_back(boundary_penalty_);
@@ -338,6 +345,7 @@ void SACoreSoftMacro::initialize()
   norm_area_penalty_ = calAverage(area_penalty_list);
   norm_outline_penalty_ = calAverage(outline_penalty_list);
   norm_wirelength_ = calAverage(wirelength_list);
+  norm_critical_wirelength_ = calAverage(critical_wirelength_list);
   norm_guidance_penalty_ = calAverage(guidance_penalty_list);
   norm_fence_penalty_ = calAverage(fence_penalty_list);
   norm_boundary_penalty_ = calAverage(boundary_penalty_list);
@@ -359,6 +367,10 @@ void SACoreSoftMacro::initialize()
     norm_wirelength_ = 1.0;
   }
 
+  if (norm_critical_wirelength_ <= 1e-4) {
+    norm_critical_wirelength_ = 1.0;
+  }
+
   if (norm_guidance_penalty_ <= 1e-4) {
     norm_guidance_penalty_ = 1.0;
   }
@@ -390,6 +402,7 @@ void SACoreSoftMacro::initialize()
     height_ = height_list[i];
     outline_penalty_ = outline_penalty_list[i];
     wirelength_ = wirelength_list[i];
+    critical_wirelength_ = critical_wirelength_list[i];
     guidance_penalty_ = guidance_penalty_list[i];
     fence_penalty_ = fence_penalty_list[i];
     boundary_penalty_ = boundary_penalty_list[i];

src/mpl/src/SimulatedAnnealingCore.cpp

@@ -123,6 +123,13 @@ void SimulatedAnnealingCore<T>::setNets(const BundledNetList& nets)
   nets_ = nets;
 }
 
+template <class T>
+void SimulatedAnnealingCore<T>::setCriticalNets(
+    const BundledNetList& critical_nets)
+{
+  critical_nets_ = critical_nets;
+}
+
 template <class T>
 void SimulatedAnnealingCore<T>::setFences(
     const std::map<int, odb::Rect>& fences)
@@ -284,6 +291,24 @@ void SimulatedAnnealingCore<T>::calWirelength()
   }
 }
 
+template <class T>
+void SimulatedAnnealingCore<T>::calCriticalWireLength()
+{
+  if (core_weights_.critical_wirelength <= 0.0) {
+    return;
+  }
+
+  critical_wirelength_ = computeNetsWireLength(critical_nets_);
+
+  if (graphics_) {
+    graphics_->setCriticalWireLengthPenalty(
+        {.name = "Critical Wire Length",
+         .weight = core_weights_.critical_wirelength,
+         .value = critical_wirelength_,
+         .normalization_factor = norm_critical_wirelength_});
+  }
+}
+
 template <class T>
 float SimulatedAnnealingCore<T>::computeNetsWireLength(
     const BundledNetList& nets) const
@@ -645,6 +670,10 @@ void SimulatedAnnealingCore<T>::reportCoreWeights() const
 
   report(
       {"Wire Length", core_weights_.wirelength, wirelength_, norm_wirelength_});
+  report({"Critical Wire Length",
+          core_weights_.critical_wirelength,
+          critical_wirelength_,
+          norm_critical_wirelength_});
   report({"Guidance",
           core_weights_.guidance,
           guidance_penalty_,

src/mpl/src/SimulatedAnnealingCore.h

@@ -65,6 +65,7 @@ class SimulatedAnnealingCore
     number_of_sequence_pair_macros_ = number_of_sequence_pair_macros;
   };
   void setNets(const BundledNetList& nets);
+  void setCriticalNets(const BundledNetList& critical_nets);
   void setFences(const std::map<int, odb::Rect>& fences);
   void setGuides(const std::map<int, odb::Rect>& guides);
   void setInitialSequencePair(const SequencePair& sequence_pair);
@@ -118,6 +119,7 @@ class SimulatedAnnealingCore
   virtual void calPenalty() = 0;
   void calOutlinePenalty();
   void calWirelength();
+  void calCriticalWireLength();
   float computeNetsWireLength(const BundledNetList& nets) const;
   int64_t computeWLForClusterOfUnplacedIOPins(const T& macro,
                                               const T& unplaced_ios,
@@ -155,6 +157,7 @@ class SimulatedAnnealingCore
   int number_of_sequence_pair_macros_ = 0;
 
   BundledNetList nets_;
+  BundledNetList critical_nets_;
   std::map<int, odb::Rect> fences_;  // Macro Id -> Fence
   std::map<int, odb::Rect> guides_;  // Macro Id -> Guide
 
@@ -189,6 +192,7 @@ class SimulatedAnnealingCore
   int pre_height_ = 0;
 
   float wirelength_ = 0.0;
+  float critical_wirelength_ = 0.0;
   float outline_penalty_ = 0.0;
   float guidance_penalty_ = 0.0;
   float fence_penalty_ = 0.0;
@@ -199,6 +203,7 @@ class SimulatedAnnealingCore
   float pre_fence_penalty_ = 0.0;
 
   float norm_wirelength_ = 0;
+  float norm_critical_wirelength_ = 0.0;
   float norm_outline_penalty_ = 0.0;
   float norm_guidance_penalty_ = 0.0;
   float norm_fence_penalty_ = 0.0;

src/mpl/src/clusterEngine.cpp

@@ -82,6 +82,11 @@ void ClusteringEngine::setTree(PhysicalHierarchy* tree)
   tree_ = tree;
 }
 
+void ClusteringEngine::setResizer(rsz::Resizer* resizer)
+{
+  resizer_ = resizer;
+}
+
 // Check if macro placement is both needed and feasible.
 // Also report some design data relevant for the user and
 // initialize the tree with data from the design.
@@ -114,6 +119,14 @@ void ClusteringEngine::init()
 
   tree_->io_pads = getIOPads();
 
+  if (resizer_) {
+    critical_nets_ = resizer_->resizeWorstSlackNets();
+
+    if (critical_nets_.empty()) {
+      logger_->info(MPL, 66, "No critical nets found.");
+    }
+  }
+
   reportDesignData();
 }
 
@@ -1046,12 +1059,32 @@ void ClusteringEngine::buildDataFlowConnections()
   }
 }
 
+void ClusteringEngine::buildCriticalConnections()
+{
+  for (const sta::Net* sta_net : critical_nets_) {
+    odb::dbNet* db_net = network_->staToDb(sta_net);
+
+    if (!isValidNet(db_net)) {
+      continue;
+    }
+
+    Net net = buildNet(db_net);
+    connectClusters(net, true);
+  }
+}
+
 void ClusteringEngine::connect(Cluster* a,
                                Cluster* b,
-                               const float connection_weight) const
+                               const float connection_weight,
+                               const bool critical_connection) const
 {
-  a->addConnection(b, connection_weight);
-  b->addConnection(a, connection_weight);
+  if (critical_connection) {
+    a->addCriticalConnection(b, connection_weight);
+    b->addCriticalConnection(a, connection_weight);
+  } else {
+    a->addConnection(b, connection_weight);
+    b->addConnection(a, connection_weight);
+  }
 }
 
 float ClusteringEngine::computeConnWeight(const int hops)
@@ -1980,6 +2013,7 @@ void ClusteringEngine::rebuildConnections()
   clearConnections();
   buildNetListConnections();
   buildDataFlowConnections();
+  buildCriticalConnections();
 }
 
 void ClusteringEngine::clearConnections()
@@ -2031,7 +2065,8 @@ ClusteringEngine::Net ClusteringEngine::buildNet(odb::dbNet* db_net) const
   return net;
 }
 
-void ClusteringEngine::connectClusters(const Net& net)
+void ClusteringEngine::connectClusters(const Net& net,
+                                       const bool critical_connections)
 {
   if (net.driver_id == -1 || net.loads_ids.empty()
       || net.loads_ids.size() >= tree_->large_net_threshold) {
@@ -2044,7 +2079,7 @@ void ClusteringEngine::connectClusters(const Net& net)
   for (const int load_cluster_id : net.loads_ids) {
     if (load_cluster_id != net.driver_id) {
       Cluster* load = tree_->maps.id_to_cluster.at(load_cluster_id);
-      connect(driver, load, connection_weight);
+      connect(driver, load, connection_weight, critical_connections);
     }
   }
 }