Merge pull request #7982 from The-OpenROAD-Project-staging/grt-mem-opt

gui: save memory in Segment

Author: maliberty

src/grt/include/grt/GlobalRouter.h

@@ -333,7 +333,7 @@ class GlobalRouter
   std::vector<Pin*> getAllPorts();
   void computeTrackConsumption(const Net* net,
                                int& track_consumption,
-                               std::vector<int>*& edge_costs_per_layer);
+                               std::vector<int8_t>*& edge_costs_per_layer);
 
   // aux functions
   std::vector<odb::Point> findOnGridPositions(const Pin& pin,

src/grt/src/GlobalRouter.cpp

@@ -1162,7 +1162,7 @@ void GlobalRouter::makeFastrouteNet(Net* net)
   findFastRoutePins(net, pins_on_grid, root_idx);
 
   bool is_clock = (net->getSignalType() == odb::dbSigType::CLOCK);
-  std::vector<int>* edge_cost_per_layer;
+  std::vector<int8_t>* edge_cost_per_layer;
   int edge_cost_for_net;
   computeTrackConsumption(net, edge_cost_for_net, edge_cost_per_layer);
 
@@ -1250,7 +1250,7 @@ void GlobalRouter::getCapacityReductionData(CapacityReductionData& cap_red_data)
 void GlobalRouter::computeTrackConsumption(
     const Net* net,
     int& track_consumption,
-    std::vector<int>*& edge_costs_per_layer)
+    std::vector<int8_t>*& edge_costs_per_layer)
 {
   edge_costs_per_layer = nullptr;
   track_consumption = 1;
@@ -1262,7 +1262,7 @@ void GlobalRouter::computeTrackConsumption(
   odb::dbTechNonDefaultRule* ndr = db_net->getNonDefaultRule();
   if (ndr) {
     int num_layers = grid_->getNumLayers();
-    edge_costs_per_layer = new std::vector<int>(num_layers + 1, 1);
+    edge_costs_per_layer = new std::vector<int8_t>(num_layers + 1, 1);
     std::vector<odb::dbTechLayerRule*> layer_rules;
     ndr->getLayerRules(layer_rules);
 
@@ -1280,6 +1280,13 @@ void GlobalRouter::computeTrackConsumption(
       int ndr_pitch = ndr_width / 2 + ndr_spacing + default_width / 2;
 
       int consumption = std::ceil((float) ndr_pitch / default_pitch);
+      if (consumption > std::numeric_limits<int8_t>::max()) {
+        logger_->error(GRT,
+                       272,
+                       "NDR consumption {} exceeds {} and is unsupported",
+                       consumption,
+                       std::numeric_limits<int8_t>::max());
+      }
       (*edge_costs_per_layer)[layerIdx - 1] = consumption;
 
       track_consumption = std::max(track_consumption, consumption);

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

@@ -47,12 +47,11 @@ enum class EdgeDirection
 
 struct Segment  // A Segment is a 2-pin connection
 {
-  bool xFirst;  // route x-direction first (only for L route)
-  bool HVH;     // TRUE = HVH or false = VHV (only for Z route)
-
   int16_t x1, y1, x2, y2;  // coordinates of two endpoints
-  int netID;               // the netID of the net this segment belonging to
-  int16_t Zpoint;  // The coordinates of Z point (x for HVH and y for VHV)
+  int16_t Zpoint;   // The coordinates of Z point (x for HVH and y for VHV)
+  int8_t cost;      // the netID of the net this segment belonging to
+  bool xFirst : 1;  // route x-direction first (only for L route)
+  bool HVH : 1;     // TRUE = HVH or false = VHV (only for Z route)
 };
 
 struct FrNet  // A Net is a set of connected MazePoints
@@ -67,7 +66,7 @@ struct FrNet  // A Net is a set of connected MazePoints
   int getMaxLayer() const { return max_layer_; }
   int getMinLayer() const { return min_layer_; }
   int getNumPins() const { return pin_x_.size(); }
-  int getLayerEdgeCost(int layer) const;
+  int8_t getLayerEdgeCost(int layer) const;
 
   int getPinX(int idx) const { return pin_x_[idx]; }
   int getPinY(int idx) const { return pin_y_[idx]; }
@@ -84,7 +83,7 @@ struct FrNet  // A Net is a set of connected MazePoints
              int min_layer,
              int max_layer,
              float slack,
-             std::vector<int>* edge_cost_per_layer);
+             std::vector<int8_t>* edge_cost_per_layer);
   void setMaxLayer(int max_layer) { max_layer_ = max_layer; }
   void setMinLayer(int min_layer) { min_layer_ = min_layer; }
   void setSlack(float slack) { slack_ = slack; }
@@ -103,7 +102,7 @@ struct FrNet  // A Net is a set of connected MazePoints
   int max_layer_;
   float slack_;
   // Non-null when an NDR has been applied to the net.
-  std::unique_ptr<std::vector<int>> edge_cost_per_layer_;
+  std::unique_ptr<std::vector<int8_t>> edge_cost_per_layer_;
 };
 
 struct Edge  // An Edge is the routing track holder between two adjacent

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

@@ -108,7 +108,7 @@ class FastRouteCore
                 int min_layer,
                 int max_layer,
                 float slack,
-                std::vector<int>* edge_cost_per_layer);
+                std::vector<int8_t>* edge_cost_per_layer);
   void deleteNet(odb::dbNet* db_net);
   void removeNet(odb::dbNet* db_net);
   void mergeNet(odb::dbNet* removed_net, odb::dbNet* preserved_net);

src/grt/src/fastroute/src/FastRoute.cpp

@@ -235,7 +235,7 @@ FrNet* FastRouteCore::addNet(odb::dbNet* db_net,
                              int min_layer,
                              int max_layer,
                              float slack,
-                             std::vector<int>* edge_cost_per_layer)
+                             std::vector<int8_t>* edge_cost_per_layer)
 {
   int netID;
   bool exists;
@@ -1582,7 +1582,7 @@ void FastRouteCore::StTreeVisualization(const StTree& stree,
 
 ////////////////////////////////////////////////////////////////
 
-int FrNet::getLayerEdgeCost(int layer) const
+int8_t FrNet::getLayerEdgeCost(int layer) const
 {
   if (edge_cost_per_layer_) {
     return (*edge_cost_per_layer_)[layer];
@@ -1605,7 +1605,7 @@ void FrNet::reset(odb::dbNet* db_net,
                   int min_layer,
                   int max_layer,
                   float slack,
-                  std::vector<int>* edge_cost_per_layer)
+                  std::vector<int8_t>* edge_cost_per_layer)
 {
   db_net_ = db_net;
   is_critical_ = false;

src/grt/src/fastroute/src/RSMT.cpp

@@ -732,7 +732,7 @@ void FastRouteCore::gen_brk_RSMT(const bool congestionDriven,
           seg.y2 = y1;
         }
 
-        seg.netID = netID;
+        seg.cost = nets_[netID]->getEdgeCost();
       }
     }  // loop j
 

src/grt/src/fastroute/src/RipUp.cpp

@@ -17,7 +17,7 @@ using utl::GRT;
 // rip-up a L segment
 void FastRouteCore::ripupSegL(const Segment* seg)
 {
-  const int edgeCost = nets_[seg->netID]->getEdgeCost();
+  const int8_t edgeCost = seg->cost;
 
   const auto [ymin, ymax] = std::minmax(seg->y1, seg->y2);
 

src/grt/src/fastroute/src/route.cpp

@@ -19,7 +19,7 @@ using utl::GRT;
 // possible L for L segments
 void FastRouteCore::estimateOneSeg(const Segment* seg)
 {
-  const int edgeCost = nets_[seg->netID]->getEdgeCost();
+  const int8_t edgeCost = seg->cost;
 
   const auto [ymin, ymax] = std::minmax(seg->y1, seg->y2);
 
@@ -39,7 +39,7 @@ void FastRouteCore::estimateOneSeg(const Segment* seg)
 
 void FastRouteCore::routeSegV(const Segment* seg)
 {
-  const int edgeCost = nets_[seg->netID]->getEdgeCost();
+  const int8_t edgeCost = seg->cost;
 
   const auto [ymin, ymax] = std::minmax(seg->y1, seg->y2);
 
@@ -48,15 +48,15 @@ void FastRouteCore::routeSegV(const Segment* seg)
 
 void FastRouteCore::routeSegH(const Segment* seg)
 {
-  const int edgeCost = nets_[seg->netID]->getEdgeCost();
+  const int8_t edgeCost = seg->cost;
 
   graph2d_.addEstUsageH({seg->x1, seg->x2}, seg->y1, edgeCost);
 }
 
 // L-route, based on previous L route
 void FastRouteCore::routeSegL(Segment* seg)
 {
-  const int edgeCost = nets_[seg->netID]->getEdgeCost();
+  const int8_t edgeCost = seg->cost;
 
   const auto [ymin, ymax] = std::minmax(seg->y1, seg->y2);
 
@@ -137,7 +137,7 @@ void FastRouteCore::routeSegLFirstTime(Segment* seg)
     }
   }
 
-  const int edgeCost = nets_[seg->netID]->getEdgeCost();
+  const int8_t edgeCost = seg->cost;
 
   if (costL1 < costL2) {
     // two parts (x1, y1)-(x1, y2) and (x1, y2)-(x2, y2)