Merge pull request #7144 from osamahammad21/dpl-dpo-remove-dead

DPO: remove dead code "router.h"

Author: maliberty

src/dpo/CMakeLists.txt

@@ -19,7 +19,6 @@ target_sources(dpo
     src/architecture.cxx
     src/color.cxx
     src/network.cxx
-    src/router.cxx
     src/utility.cxx
     src/legalize_shift.cxx
     src/detailed.cxx

src/dpo/include/dpo/Optdp.h

@@ -29,7 +29,6 @@ class PlacementDRC;
 
 namespace dpo {
 
-class RoutingParams;
 class Architecture;
 class Network;
 
@@ -82,8 +81,6 @@ class Optdp
   // My stuff.
   Architecture* arch_ = nullptr;  // Information about rows, etc.
   Network* network_ = nullptr;    // The netlist, cells, etc.
-  RoutingParams* routeinfo_
-      = nullptr;  // Route info we might consider (future).
   Grid* grid_ = nullptr;
 
   // placement DRC enging.

src/dpo/src/Optdp.cpp

@@ -31,7 +31,6 @@
 #include "dpl/PlacementDRC.h"
 #include "legalize_shift.h"
 #include "network.h"
-#include "router.h"
 #include "symmetry.h"
 
 namespace dpo {
@@ -90,7 +89,7 @@ void Optdp::improvePlacement(const int seed,
   const bool disallow_one_site_gaps = !odb::hasOneSiteMaster(db_);
 
   // A manager to track cells.
-  dpo::DetailedMgr mgr(arch_, network_, routeinfo_, grid_, drc_engine_);
+  dpo::DetailedMgr mgr(arch_, network_, grid_, drc_engine_);
   mgr.setLogger(logger_);
   // Various settings.
   mgr.setSeed(seed);
@@ -142,7 +141,6 @@ void Optdp::improvePlacement(const int seed,
   // Cleanup.
   delete network_;
   delete arch_;
-  delete routeinfo_;
   delete drc_engine_;
 
   const double dbu_micron = db_->getTech()->getDbUnitsPerMicron();
@@ -164,7 +162,6 @@ void Optdp::import()
 
   network_ = new Network;
   arch_ = new Architecture;
-  routeinfo_ = new RoutingParams;
   grid_ = new Grid;
 
   // createLayerMap(); // Does nothing right now.

src/dpo/src/architecture.cxx

@@ -18,7 +18,6 @@
 #include "network.h"
 #include "odb/db.h"
 #include "odb/dbTransform.h"
-#include "router.h"
 
 namespace dpo {
 

src/dpo/src/detailed.cxx

@@ -43,7 +43,6 @@ bool Detailed::improve(DetailedMgr& mgr)
 
   arch_ = mgr.getArchitecture();
   network_ = mgr.getNetwork();
-  rt_ = mgr.getRoutingParams();  // Can be NULL.
 
   // Parse the script string and run each command.
   boost::char_separator<char> separators(" \r\t\n", ";");
@@ -145,13 +144,13 @@ void Detailed::doDetailedCommand(std::vector<std::string>& args)
   logger->info(DPO, 303, "Running algorithm for {:s}.", command);
 
   if (strcmp(args[0].c_str(), "mis") == 0) {
-    DetailedMis mis(arch_, network_, rt_);
+    DetailedMis mis(arch_, network_);
     mis.run(mgr_, args);
   } else if (strcmp(args[0].c_str(), "gs") == 0) {
-    DetailedGlobalSwap gs(arch_, network_, rt_);
+    DetailedGlobalSwap gs(arch_, network_);
     gs.run(mgr_, args);
   } else if (strcmp(args[0].c_str(), "vs") == 0) {
-    DetailedVerticalSwap vs(arch_, network_, rt_);
+    DetailedVerticalSwap vs(arch_, network_);
     vs.run(mgr_, args);
   } else if (strcmp(args[0].c_str(), "ro") == 0) {
     DetailedReorderer ro(arch_, network_);

src/dpo/src/detailed.h

@@ -11,7 +11,6 @@
 
 #include "architecture.h"
 #include "network.h"
-#include "router.h"
 
 namespace dpo {
 
@@ -44,7 +43,6 @@ class Detailed
 
   Architecture* arch_ = nullptr;
   Network* network_ = nullptr;
-  RoutingParams* rt_ = nullptr;
 };
 
 }  // namespace dpo

src/dpo/src/detailed_global.cxx

@@ -22,14 +22,11 @@ using utl::DPO;
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
-DetailedGlobalSwap::DetailedGlobalSwap(Architecture* arch,
-                                       Network* network,
-                                       RoutingParams* rt)
+DetailedGlobalSwap::DetailedGlobalSwap(Architecture* arch, Network* network)
     : DetailedGenerator("global swap"),
       mgr_(nullptr),
       arch_(arch),
       network_(network),
-      rt_(rt),
       skipNetsLargerThanThis_(100),
       traversal_(0),
       attempts_(0),
@@ -40,8 +37,7 @@ DetailedGlobalSwap::DetailedGlobalSwap(Architecture* arch,
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
-DetailedGlobalSwap::DetailedGlobalSwap()
-    : DetailedGlobalSwap(nullptr, nullptr, nullptr)
+DetailedGlobalSwap::DetailedGlobalSwap() : DetailedGlobalSwap(nullptr, nullptr)
 {
 }
 
@@ -70,7 +66,6 @@ void DetailedGlobalSwap::run(DetailedMgr* mgrPtr,
   mgr_ = mgrPtr;
   arch_ = mgr_->getArchitecture();
   network_ = mgr_->getNetwork();
-  rt_ = mgr_->getRoutingParams();
 
   int passes = 1;
   double tol = 0.01;
@@ -476,7 +471,6 @@ void DetailedGlobalSwap::init(DetailedMgr* mgr)
   mgr_ = mgr;
   arch_ = mgr->getArchitecture();
   network_ = mgr->getNetwork();
-  rt_ = mgr->getRoutingParams();
 
   traversal_ = 0;
   edgeMask_.resize(network_->getNumEdges());
@@ -493,7 +487,6 @@ bool DetailedGlobalSwap::generate(DetailedMgr* mgr,
   mgr_ = mgr;
   arch_ = mgr->getArchitecture();
   network_ = mgr->getNetwork();
-  rt_ = mgr->getRoutingParams();
 
   Node* ndi = candidates[mgr_->getRandom(candidates.size())];
 

src/dpo/src/detailed_global.h

@@ -15,13 +15,12 @@ namespace dpo {
 class Architecture;
 class DetailedMgr;
 class Network;
-class RoutingParams;
 using dpl::Edge;
 
 class DetailedGlobalSwap : public DetailedGenerator
 {
  public:
-  DetailedGlobalSwap(Architecture* arch, Network* network, RoutingParams* rt);
+  DetailedGlobalSwap(Architecture* arch, Network* network);
   DetailedGlobalSwap();
 
   // Interfaces for scripting.
@@ -46,7 +45,6 @@ class DetailedGlobalSwap : public DetailedGenerator
   DetailedMgr* mgr_;
   Architecture* arch_;
   Network* network_;
-  RoutingParams* rt_;
 
   // Other.
   int skipNetsLargerThanThis_;

src/dpo/src/detailed_manager.cxx

@@ -23,7 +23,6 @@
 #include "dpl/PlacementDRC.h"
 #include "journal.h"
 #include "odb/dbTransform.h"
-#include "router.h"
 #include "utility.h"
 #include "utl/Logger.h"
 
@@ -33,14 +32,9 @@ namespace dpo {
 
 DetailedMgr::DetailedMgr(Architecture* arch,
                          Network* network,
-                         RoutingParams* rt,
                          Grid* grid,
                          PlacementDRC* drc_engine)
-    : arch_(arch),
-      network_(network),
-      rt_(rt),
-      grid_(grid),
-      drc_engine_(drc_engine)
+    : arch_(arch), network_(network), grid_(grid), drc_engine_(drc_engine)
 {
   singleRowHeight_ = arch_->getRow(0)->getHeight();
   numSingleHeightRows_ = arch_->getNumRows();
@@ -192,50 +186,6 @@ void DetailedMgr::findBlockages(const bool includeRouteBlockages)
     }
   }
 
-  if (includeRouteBlockages && rt_ != nullptr) {
-    // Turn M1 and M2 routing blockages into placement blockages.  The idea
-    // here is to be quite conservative and prevent the possibility of pin
-    // access problems.  We *ONLY* consider routing obstacles to be placement
-    // obstacles if they overlap with an *ENTIRE* site.
-
-    for (int layer = 0; layer <= 1 && layer < rt_->num_layers_; layer++) {
-      const std::vector<Rectangle>& rects = rt_->layerBlockages_[layer];
-      for (const auto& rect : rects) {
-        const double xmin = rect.xmin();
-        const double xmax = rect.xmax();
-        const double ymin = rect.ymin();
-        const double ymax = rect.ymax();
-
-        for (int r = 0; r < numSingleHeightRows_; r++) {
-          const double lb = arch_->getMinY() + r * singleRowHeight_;
-          const double ub = lb + singleRowHeight_;
-
-          if (ymax >= ub && ymin <= lb) {
-            // Blockage overlaps with the entire row span in the Y-dir...
-            // Sites are possibly completely covered!
-
-            const double originX = arch_->getRow(r)->getLeft();
-            const double siteSpacing = arch_->getRow(r)->getSiteSpacing();
-
-            const int i0 = (int) std::floor((xmin - originX) / siteSpacing);
-            int i1 = (int) std::floor((xmax - originX) / siteSpacing);
-            if (originX + i1 * siteSpacing != xmax) {
-              ++i1;
-            }
-
-            if (i1 > i0) {
-              blockages_[r].emplace_back(originX + i0 * siteSpacing,
-                                         originX + i1 * siteSpacing,
-                                         0,
-                                         0,
-                                         BlockageType::Routing);
-            }
-          }
-        }
-      }
-    }
-  }
-
   // Sort blockages and merge.
   for (int r = 0; r < numSingleHeightRows_; r++) {
     auto& blockages = blockages_[r];
@@ -1093,53 +1043,6 @@ double DetailedMgr::measureMaximumDisplacement(u_int64_t& maxX,
   return maxL1;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-void DetailedMgr::setupObstaclesForDrc()
-{
-  // Setup rectangular obstacles for short and pin access checks.  Do only as
-  // rectangles per row and per layer.  I had used rtrees, but it wasn't working
-  // any better.
-  obstacles_.resize(arch_->getRows().size());
-
-  for (int row_id = 0; row_id < arch_->getRows().size(); row_id++) {
-    obstacles_[row_id].resize(rt_->num_layers_);
-
-    const double originX = arch_->getRow(row_id)->getLeft();
-    const double siteSpacing = arch_->getRow(row_id)->getSiteSpacing();
-    const int numSites = arch_->getRow(row_id)->getNumSites();
-
-    // Blockages relevant to this row...
-    for (int layer_id = 0; layer_id < rt_->num_layers_; layer_id++) {
-      obstacles_[row_id][layer_id].clear();
-
-      const std::vector<Rectangle>& rects = rt_->layerBlockages_[layer_id];
-      for (const auto& rect : rects) {
-        // Extract obstacles which interfere with this row only.
-        const double xmin = originX;
-        const double xmax = originX + numSites * siteSpacing;
-        const double ymin = arch_->getRow(row_id)->getBottom();
-        const double ymax = arch_->getRow(row_id)->getTop();
-
-        if (rect.xmax() <= xmin) {
-          continue;
-        }
-        if (rect.xmin() >= xmax) {
-          continue;
-        }
-        if (rect.ymax() <= ymin) {
-          continue;
-        }
-        if (rect.ymin() >= ymax) {
-          continue;
-        }
-
-        obstacles_[row_id][layer_id].push_back(rect);
-      }
-    }
-  }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 void DetailedMgr::collectSingleHeightCells()
@@ -1652,76 +1555,12 @@ int DetailedMgr::checkRowAlignment()
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
-double DetailedMgr::getCellSpacing(const Node* ndl,
-                                   const Node* ndr,
-                                   const bool checkPinsOnCells)
+double DetailedMgr::getCellSpacing(const Node* ndl, const Node* ndr)
 {
-  // Compute any required spacing between cells.  This could be from an edge
-  // type rule, or due to adjacent pins on the cells.  Checking pins on cells is
-  // more time consuming.
-
   if (ndl == nullptr || ndr == nullptr) {
     return 0.0;
   }
-  const double spacing1 = arch_->getCellSpacing(ndl, ndl);
-  if (!checkPinsOnCells) {
-    return spacing1;
-  }
-  double spacing2 = 0.0;
-  {
-    const Pin* pinl = nullptr;
-    const Pin* pinr = nullptr;
-
-    // Right-most pin on the left cell.
-    for (const Pin* pin : ndl->getPins()) {
-      if (pinl == nullptr || pin->getOffsetX() > pinl->getOffsetX()) {
-        pinl = pin;
-      }
-    }
-
-    // Left-most pin on the right cell.
-    for (const Pin* pin : ndr->getPins()) {
-      if (pinr == nullptr || pin->getOffsetX() < pinr->getOffsetX()) {
-        pinr = pin;
-      }
-    }
-    // If pins on the same layer, do something.
-    if (pinl != nullptr && pinr != nullptr
-        && pinl->getPinLayer() == pinr->getPinLayer()) {
-      // Determine the spacing requirements between these two pins.   Then,
-      // translate this into a spacing requirement between the two cells.  XXX:
-      // Since it is implicit that the cells are in the same row, we can
-      // determine the widest pin and the parallel run length without knowing
-      // the actual location of the cells...  At least I think so...
-
-      const double xmin1 = pinl->getOffsetX().v - 0.5 * pinl->getPinWidth().v;
-      const double xmax1 = pinl->getOffsetX().v + 0.5 * pinl->getPinWidth().v;
-      const double ymin1 = pinl->getOffsetY().v - 0.5 * pinl->getPinHeight().v;
-      const double ymax1 = pinl->getOffsetY().v + 0.5 * pinl->getPinHeight().v;
-
-      const double xmin2 = pinr->getOffsetX().v - 0.5 * pinr->getPinWidth().v;
-      const double xmax2 = pinr->getOffsetX().v + 0.5 * pinr->getPinWidth().v;
-      const double ymin2 = pinr->getOffsetY().v - 0.5 * pinr->getPinHeight().v;
-      const double ymax2 = pinr->getOffsetY().v + 0.5 * pinr->getPinHeight().v;
-
-      const double ww = std::max(std::min(ymax1 - ymin1, xmax1 - xmin1),
-                                 std::min(ymax2 - ymin2, xmax2 - xmin2));
-      const double py
-          = std::max(0.0, std::min(ymax1, ymax2) - std::max(ymin1, ymin2));
-
-      spacing2 = rt_->get_spacing(pinl->getPinLayer(), ww, py);
-      const double gapl = (0.5 * ndl->getWidth().v) - xmax1;
-      const double gapr = xmin2 - (-0.5 * ndr->getWidth().v);
-      spacing2 = std::max(0.0, spacing2 - gapl - gapr);
-
-      if (spacing2 > spacing1) {
-        // The spacing requirement due to the routing layer is larger than the
-        // spacing requirement due to the edge constraint.  Interesting.
-        ;
-      }
-    }
-  }
-  return std::max(spacing1, spacing2);
+  return arch_->getCellSpacing(ndl, ndl);
 }
 
 ////////////////////////////////////////////////////////////////////////////////