Merge branch 'master' into drt_msg

Author: eder-matheus

CMakeLists.txt

@@ -176,3 +176,8 @@ if(BUILD_MAN)
   install(DIRECTORY ${OPENROAD_HOME}/docs/cat DESTINATION ${OPENROAD_SHARE}/man)
   install(DIRECTORY ${OPENROAD_HOME}/docs/html DESTINATION ${OPENROAD_SHARE}/man)
 endif()
+
+####################################################################
+# Add a configuration for ReleaseWithAsserts
+set(CMAKE_CXX_FLAGS_RELEASEWITHASSERTS "${CMAKE_CXX_FLAGS_RELEASE} -UNDEBUG" CACHE STRING "" FORCE)
+set(CMAKE_C_FLAGS_RELEASEWITHASSERTS "${CMAKE_C_FLAGS_RELEASE} -UNDEBUG" CACHE STRING "" FORCE)

src/dbSta/include/db_sta/dbNetwork.hh

@@ -291,6 +291,7 @@ class dbNetwork : public ConcreteNetwork
   const Net* highestConnectedNet(Net* net) const override;
   bool isSpecial(Net* net);
   dbNet* flatNet(const Net* net) const;
+  Net* getFlatNet(Net* net) const;
 
   ////////////////////////////////////////////////////////////////
   // Edit functions

src/dbSta/src/dbNetwork.cc

@@ -2635,7 +2635,9 @@ void dbNetwork::staToDb(const Instance* instance,
 
 dbNet* dbNetwork::staToDb(const Net* net) const
 {
-  return reinterpret_cast<dbNet*>(const_cast<Net*>(net));
+  dbNet* db_net = reinterpret_cast<dbNet*>(const_cast<Net*>(net));
+  assert(!db_net || db_net->getObjectType() == odb::dbNetObj);
+  return db_net;
 }
 
 dbNet* dbNetwork::flatNet(const Net* net) const
@@ -2732,7 +2734,9 @@ void dbNetwork::staToDb(const Pin* pin,
 
 dbBTerm* dbNetwork::staToDb(const Term* term) const
 {
-  return reinterpret_cast<dbBTerm*>(const_cast<Term*>(term));
+  dbBTerm* bterm = reinterpret_cast<dbBTerm*>(const_cast<Term*>(term));
+  assert(!bterm || bterm->getObjectType() == odb::dbBTermObj);
+  return bterm;
 }
 
 void dbNetwork::staToDb(const Term* term,
@@ -2780,20 +2784,26 @@ void dbNetwork::staToDb(const Cell* cell,
 dbMaster* dbNetwork::staToDb(const Cell* cell) const
 {
   const ConcreteCell* ccell = reinterpret_cast<const ConcreteCell*>(cell);
-  return reinterpret_cast<dbMaster*>(ccell->extCell());
+  auto master = reinterpret_cast<dbMaster*>(ccell->extCell());
+  assert(!master || master->getObjectType() == odb::dbMasterObj);
+  return master;
 }
 
 // called only on db cells.
 dbMaster* dbNetwork::staToDb(const LibertyCell* cell) const
 {
   const ConcreteCell* ccell = cell;
-  return reinterpret_cast<dbMaster*>(ccell->extCell());
+  auto master = reinterpret_cast<dbMaster*>(ccell->extCell());
+  assert(!master || master->getObjectType() == odb::dbMasterObj);
+  return master;
 }
 
 dbMTerm* dbNetwork::staToDb(const Port* port) const
 {
   const ConcretePort* cport = reinterpret_cast<const ConcretePort*>(port);
-  return reinterpret_cast<dbMTerm*>(cport->extPort());
+  auto mterm = reinterpret_cast<dbMTerm*>(cport->extPort());
+  assert(!mterm || mterm->getObjectType() == odb::dbMTermObj);
+  return mterm;
 }
 
 dbBTerm* dbNetwork::isTopPort(const Port* port) const
@@ -2841,7 +2851,9 @@ void dbNetwork::staToDb(const Port* port,
 
 dbMTerm* dbNetwork::staToDb(const LibertyPort* port) const
 {
-  return reinterpret_cast<dbMTerm*>(port->extPort());
+  auto mterm = reinterpret_cast<dbMTerm*>(port->extPort());
+  assert(!mterm || mterm->getObjectType() == odb::dbMTermObj);
+  return mterm;
 }
 
 void dbNetwork::staToDb(PortDirection* dir,
@@ -4159,4 +4171,19 @@ void dbNetwork::AxiomCheck()
   }
 }
 
+Net* dbNetwork::getFlatNet(Net* net) const
+{
+  if (!net) {
+    return nullptr;
+  }
+  // Convert net to a flat net, if not already
+  dbNet* db_net;
+  dbModNet* db_mod_net;
+  staToDb(net, db_net, db_mod_net);
+  if (db_mod_net) {
+    db_net = findRelatedDbNet(db_mod_net);
+  }
+  return dbToSta(db_net);
+}
+
 }  // namespace sta

src/gpl/test/macro03.ok

@@ -103,17 +103,13 @@ Iteration | Overflow |     HPWL (um) |  HPWL(%) |   Penalty | Group
       438 |   0.0993 |  7.432882e+09 |          |  7.49e-08 |      
 ---------------------------------------------------------------
 [INFO GPL-1001] Global placement finished at iteration 438
-[INFO GPL-1003] Routability mode iteration count: 0
 [INFO GPL-1002] Placed Cell Area            431269.9937
 [INFO GPL-1003] Available Free Area         2022140.5120
 [INFO GPL-1004] Minimum Feasible Density        0.2200 (cell_area / free_area)
 [INFO GPL-1006]   Suggested Target Densities:
 [INFO GPL-1007]     - For 90% usage of free space: 0.2370
 [INFO GPL-1008]     - For 80% usage of free space: 0.2666
 [INFO GPL-1009]     - For 50% usage of free space: 0.4265
-[INFO GPL-1011] Original area (um^2): 431269.99
-[INFO GPL-1012] Total routability artificial inflation: 0.00 (+0.00%)
-[INFO GPL-1013] Total timing-driven delta area: 0.00 (+0.00%)
 [INFO GPL-1014] Final placement area: 431269.99 (+0.00%)
 No differences found.
 final hpwl: 8738338844

src/grt/BUILD

@@ -42,6 +42,7 @@ cc_library(
     srcs = [
         "src/fastroute/src/FastRoute.cpp",
         "src/fastroute/src/FastRouteRenderer.cpp",
+        "src/fastroute/src/graph2d.cpp",
         "src/fastroute/src/RSMT.cpp",
         "src/fastroute/src/RipUp.cpp",
         "src/fastroute/src/maze.cpp",
@@ -53,6 +54,7 @@ cc_library(
         "src/fastroute/include/AbstractMakeWireParasitics.h",
         "src/fastroute/include/FastRoute.h",
         "src/fastroute/include/FastRouteRenderer.h",
+        "src/fastroute/include/Graph2D.h",
     ],
     includes = [
         "src/fastroute/include",

src/grt/src/fastroute/CMakeLists.txt

@@ -9,6 +9,7 @@ add_library(FastRoute4.1
   src/maze3D.cpp
   src/route.cpp
   src/utility.cpp
+  src/graph2d.cpp
 )
 
 target_compile_options(FastRoute4.1

src/grt/src/fastroute/include/DataType.h

@@ -153,6 +153,13 @@ struct TreeNode
   int stackAlias;
 };
 
+struct GPoint3D
+{
+  int16_t x = 0;
+  int16_t y = 0;
+  int16_t layer = 0;
+};
+
 struct Route
 {
   RouteType type;  // type of route: LRoute, ZRoute, MazeRoute
@@ -171,9 +178,7 @@ struct Route
 
   // valid for MazeRoute: a list of grids (n=routelen+1) the route
   // passes, (x1, y1) is the first one, but (x2, y2) is the lastone
-  std::vector<int16_t> gridsX;
-  std::vector<int16_t> gridsY;
-  std::vector<int16_t> gridsL;
+  std::vector<GPoint3D> grids;
 
   // valid for MazeRoute: the number of edges in the route
   int routelen;
@@ -189,6 +194,7 @@ struct TreeEdge
   int n1, n1a;
   int n2, n2a;
   Route route;
+  void convertToMazerouteNet(const TreeNode& p1, const TreeNode& p2);
 };
 
 struct StTree

src/grt/src/fastroute/include/FastRoute.h

@@ -16,6 +16,7 @@
 
 #include "AbstractMakeWireParasitics.h"
 #include "DataType.h"
+#include "Graph2D.h"
 #include "grt/GRoute.h"
 #include "odb/geom.h"
 #include "stt/SteinerTreeBuilder.h"
@@ -250,7 +251,6 @@ class FastRouteCore
                      const CostParams& cost_params,
                      float& slack_th);
   void convertToMazeroute();
-  void updateCongestionHistory(int up_type, bool stop_decreasing, int& max_adj);
   int getOverflow2D(int* maxOverflow);
   int getOverflow2Dmaze(int* maxOverflow, int* tUsage);
   int getOverflow3D();
@@ -259,9 +259,6 @@ class FastRouteCore
                          int& posY,
                          int dir,
                          int& radius);
-  void str_accu(int rnd);
-  void InitLastUsage(int upType);
-  void InitEstUsage();
   void SaveLastRouteLen();
   void checkAndFixEmbeddedTree(const int net_id);
   bool areEdgesOverlapping(const int net_id,
@@ -274,8 +271,7 @@ class FastRouteCore
   void routeLShape(const TreeNode& startpoint,
                    const TreeNode& endpoint,
                    std::vector<std::pair<short, short>>& blocked_positions,
-                   std::vector<short>& new_route_x,
-                   std::vector<short>& new_route_y);
+                   std::vector<GPoint3D>& new_route);
   void convertToMazerouteNet(const int netID);
   void setupHeap(const int netID,
                  const int edgeID,
@@ -349,9 +345,7 @@ class FastRouteCore
                   int n2,
                   std::vector<TreeEdge>& treeedges,
                   int edge_n1n2,
-                  std::vector<int>& gridsX_n1n2,
-                  std::vector<int>& gridsY_n1n2,
-                  std::vector<int>& gridsL_n1n2);
+                  std::vector<GPoint3D>& grids_n1n2);
   void updateRouteType13D(int netID,
                           std::vector<TreeNode>& treenodes,
                           int n1,
@@ -500,7 +494,7 @@ class FastRouteCore
    */
   bool checkRoute2DTree(int netID);
   void removeLoops();
-  void netedgeOrderDec(int netID);
+  void netedgeOrderDec(int netID, std::vector<OrderNetEdge>& net_eo);
   void printTree2D(int netID);
   void printEdge2D(int netID, int edgeID);
   void printEdge3D(int netID, int edgeID);
@@ -603,19 +597,17 @@ class FastRouteCore
 
   std::vector<FrNet*> nets_;
   std::unordered_map<odb::dbNet*, int> db_net_id_map_;  // db net -> net id
-  std::vector<OrderNetEdge> net_eo_;
-  std::vector<std::vector<int>>
-      gxs_;  // the copy of xs for nets, used for second FLUTE
-  std::vector<std::vector<int>>
-      gys_;  // the copy of xs for nets, used for second FLUTE
-  std::vector<std::vector<int>>
-      gs_;  // the copy of vertical sequence for nets, used for second FLUTE
+  // the copy of xs for nets, used for second FLUTE
+  std::vector<std::vector<int>> gxs_;
+  // the copy of xs for nets, used for second FLUTE
+  std::vector<std::vector<int>> gys_;
+  // the copy of vertical sequence for nets, used for second FLUTE
+  std::vector<std::vector<int>> gs_;
   std::vector<std::vector<Segment>> seglist_;  // indexed by netID, segID
   std::vector<OrderNetPin> tree_order_pv_;
   std::vector<OrderTree> tree_order_cong_;
 
-  multi_array<Edge, 2> v_edges_;       // The way it is indexed is (Y, X)
-  multi_array<Edge, 2> h_edges_;       // The way it is indexed is (Y, X)
+  Graph2D graph2d_;
   multi_array<Edge3D, 3> h_edges_3D_;  // The way it is indexed is (Layer, Y, X)
   multi_array<Edge3D, 3> v_edges_3D_;  // The way it is indexed is (Layer, Y, X)
   multi_array<int, 2> corr_edge_;
@@ -642,8 +634,6 @@ class FastRouteCore
   std::unordered_map<Tile, interval_set<int>, boost::hash<Tile>>
       horizontal_blocked_intervals_;
 
-  std::set<std::pair<int, int>> h_used_ggrid_;
-  std::set<std::pair<int, int>> v_used_ggrid_;
   std::vector<int> net_ids_;
 
   // Maze 3D variables

src/grt/src/fastroute/include/Graph2D.h

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2019-2025, The OpenROAD Authors
+
+#pragma once
+
+#include <boost/multi_array.hpp>
+#include <cstdint>
+#include <functional>
+#include <set>
+#include <utility>
+#include <vector>
+
+#include "DataType.h"
+
+namespace grt {
+
+using boost::multi_array;
+
+class Graph2D
+{
+ public:
+  struct Interval
+  {
+    const int lo;
+    const int hi;
+  };
+
+  void init(int x_grid, int y_grid, int h_capacity, int v_capacity);
+  void InitEstUsage();
+  void InitLastUsage(int upType);
+  void clear();
+  void clearUsed();
+  bool hasEdges() const;
+
+  uint16_t getUsageH(int x, int y) const;
+  uint16_t getUsageV(int x, int y) const;
+  int16_t getLastUsageH(int x, int y) const;
+  int16_t getLastUsageV(int x, int y) const;
+  double getEstUsageH(int x, int y) const;
+  double getEstUsageV(int x, int y) const;
+  uint16_t getUsageRedH(int x, int y) const;
+  uint16_t getUsageRedV(int x, int y) const;
+  double getEstUsageRedH(int x, int y) const;
+  double getEstUsageRedV(int x, int y) const;
+  int getOverflowH(int x, int y) const;
+  int getOverflowV(int x, int y) const;
+  uint16_t getCapH(int x, int y) const;
+  uint16_t getCapV(int x, int y) const;
+
+  const std::set<std::pair<int, int>>& getUsedGridsH() const;
+  const std::set<std::pair<int, int>>& getUsedGridsV() const;
+
+  void addCapH(int x, int y, int cap);
+  void addCapV(int x, int y, int cap);
+  void addEstUsageH(const Interval& xi, int y, double usage);
+  void addEstUsageH(int x, int y, double usage);
+  void addEstUsageToUsage();
+  void addEstUsageV(int x, const Interval& yi, double usage);
+  void addEstUsageV(int x, int y, double usage);
+  void addRedH(int x, int y, int red);
+  void addRedV(int x, int y, int red);
+  void addUsageH(const Interval& xi, int y, int used);
+  void addUsageH(int x, int y, int used);
+  void addUsageV(int x, const Interval& yi, int used);
+  void addUsageV(int x, int y, int used);
+
+  void updateCongestionHistory(int up_type,
+                               int ahth,
+                               bool stop_decreasing,
+                               int& max_adj);
+  void str_accu(int rnd);
+
+ private:
+  void foreachEdge(const std::function<void(Edge&)>& func);
+
+  multi_array<Edge, 2> v_edges_;  // The way it is indexed is (X, Y)
+  multi_array<Edge, 2> h_edges_;  // The way it is indexed is (X, Y)
+
+  std::set<std::pair<int, int>> h_used_ggrid_;
+  std::set<std::pair<int, int>> v_used_ggrid_;
+};
+
+}  // namespace grt