odb: cache x/y grids in dbTrackGrid

src/gui/src/renderThread.cpp

@@ -325,7 +325,6 @@ void RenderThread::drawTracks(dbTechLayer* layer,
   painter->setBrush(Qt::NoBrush);
 
   bool is_horizontal = layer->getDirection() == dbTechLayerDir::HORIZONTAL;
-  std::vector<int> grids;
   if ((!is_horizontal && viewer_->options_->arePrefTracksVisible())
       || (is_horizontal && viewer_->options_->areNonPrefTracksVisible())) {
     bool show_grid = true;
@@ -336,8 +335,7 @@ void RenderThread::drawTracks(dbTechLayer* layer,
     }
 
     if (show_grid) {
-      grid->getGridX(grids);
-      for (int x : grids) {
+      for (int x : grid->getGridX()) {
         if (restart_) {
           break;
         }
@@ -362,8 +360,7 @@ void RenderThread::drawTracks(dbTechLayer* layer,
     }
 
     if (show_grid) {
-      grid->getGridY(grids);
-      for (int y : grids) {
+      for (int y : grid->getGridY()) {
         if (restart_) {
           break;
         }

src/odb/include/odb/db.h

@@ -3728,11 +3728,13 @@ class dbTrackGrid : public dbObject
   /// Get the "X" track coordinates for a this tech-layer.
   ///
   void getGridX(std::vector<int>& x_grid);
+  const std::vector<int>& getGridX();
 
   ///
   /// Get the "Y" track coordinates for a this tech-layer.
   ///
   void getGridY(std::vector<int>& y_grid);
+  const std::vector<int>& getGridY();
 
   ///
   /// Get the block this grid belongs too.

src/odb/src/db/dbTrackGrid.cpp

@@ -19,6 +19,7 @@
 #include "odb/db.h"
 #include "odb/dbSet.h"
 #include "odb/dbTypes.h"
+#include "odb/odb.h"
 #include "utl/Logger.h"
 
 namespace odb {
@@ -83,72 +84,92 @@ dbTechLayer* dbTrackGrid::getTechLayer()
   return (dbTechLayer*) tech->_layer_tbl->getPtr(grid->_layer);
 }
 
-void dbTrackGrid::getGridX(std::vector<int>& x_grid)
+const std::vector<int>& dbTrackGrid::getGridX()
 {
-  x_grid.clear();
-
   _dbTrackGrid* grid = (_dbTrackGrid*) this;
 
-  uint i;
+  if (grid->grid_x_.empty()) {
+    uint i;
 
-  for (i = 0; i < grid->_x_origin.size(); ++i) {
-    int j;
+    for (i = 0; i < grid->_x_origin.size(); ++i) {
+      int j;
 
-    int x = grid->_x_origin[i];
-    int count = grid->_x_count[i];
-    int step = grid->_x_step[i];
+      int x = grid->_x_origin[i];
+      int count = grid->_x_count[i];
+      int step = grid->_x_step[i];
 
-    for (j = 0; j < count; ++j) {
-      x_grid.push_back(x);
-      x += step;
+      for (j = 0; j < count; ++j) {
+        grid->grid_x_.push_back(x);
+        x += step;
+      }
     }
-  }
 
-  // empty grid
-  if (x_grid.begin() == x_grid.end()) {
-    return;
-  }
+    // empty grid
+    if (grid->grid_x_.begin() == grid->grid_x_.end()) {
+      return grid->grid_x_;
+    }
 
-  // sort coords in asscending order
-  std::sort(x_grid.begin(), x_grid.end());
+    // sort coords in asscending order
+    std::sort(grid->grid_x_.begin(), grid->grid_x_.end());
 
-  // remove any duplicates
-  auto new_end = std::unique(x_grid.begin(), x_grid.end());
-  x_grid.erase(new_end, x_grid.end());
+    // remove any duplicates
+    auto new_end = std::unique(grid->grid_x_.begin(), grid->grid_x_.end());
+    grid->grid_x_.erase(new_end, grid->grid_x_.end());
+  }
+
+  return grid->grid_x_;
 }
 
-void dbTrackGrid::getGridY(std::vector<int>& y_grid)
+void dbTrackGrid::getGridX(std::vector<int>& x_grid)
 {
-  y_grid.clear();
+  const std::vector<int>& grid = getGridX();
+  x_grid.clear();
+  x_grid.reserve(grid.size());
+  x_grid.insert(x_grid.end(), grid.begin(), grid.end());
+}
 
+const std::vector<int>& dbTrackGrid::getGridY()
+{
   _dbTrackGrid* grid = (_dbTrackGrid*) this;
 
-  uint i;
+  if (grid->grid_y_.empty()) {
+    uint i;
 
-  for (i = 0; i < grid->_y_origin.size(); ++i) {
-    int j;
+    for (i = 0; i < grid->_y_origin.size(); ++i) {
+      int j;
 
-    int y = grid->_y_origin[i];
-    int count = grid->_y_count[i];
-    int step = grid->_y_step[i];
+      int y = grid->_y_origin[i];
+      int count = grid->_y_count[i];
+      int step = grid->_y_step[i];
 
-    for (j = 0; j < count; ++j) {
-      y_grid.push_back(y);
-      y += step;
+      for (j = 0; j < count; ++j) {
+        grid->grid_y_.push_back(y);
+        y += step;
+      }
     }
-  }
 
-  // empty grid
-  if (y_grid.begin() == y_grid.end()) {
-    return;
+    // empty grid
+    if (grid->grid_y_.begin() == grid->grid_y_.end()) {
+      return grid->grid_y_;
+    }
+
+    // sort coords in asscending order
+    std::sort(grid->grid_y_.begin(), grid->grid_y_.end());
+
+    // remove any duplicates
+    auto new_end = std::unique(grid->grid_y_.begin(), grid->grid_y_.end());
+    grid->grid_y_.erase(new_end, grid->grid_y_.end());
   }
 
-  // sort coords in asscending order
-  std::sort(y_grid.begin(), y_grid.end());
+  return grid->grid_y_;
+}
 
-  // remove any duplicates
-  auto new_end = std::unique(y_grid.begin(), y_grid.end());
-  y_grid.erase(new_end, y_grid.end());
+void dbTrackGrid::getGridY(std::vector<int>& y_grid)
+{
+  const std::vector<int>& grid = getGridY();
+  y_grid.clear();
+  y_grid.reserve(grid.size());
+  y_grid.insert(y_grid.end(), grid.begin(), grid.end());
 }
 
 dbBlock* dbTrackGrid::getBlock()
@@ -168,6 +189,8 @@ void dbTrackGrid::addGridPatternX(int origin_x,
   grid->_x_step.push_back(step);
   grid->_first_mask.push_back(first_mask);
   grid->_samemask.push_back(samemask);
+
+  grid->grid_x_.clear();
 }
 
 void dbTrackGrid::addGridPatternY(int origin_y,
@@ -182,6 +205,8 @@ void dbTrackGrid::addGridPatternY(int origin_y,
   grid->_y_step.push_back(step);
   grid->_first_mask.push_back(first_mask);
   grid->_samemask.push_back(samemask);
+
+  grid->grid_y_.clear();
 }
 
 int dbTrackGrid::getNumGridPatternsX()

src/odb/src/db/dbTrackGrid.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <vector>
+
 #include "dbCore.h"
 #include "dbDatabase.h"
 #include "dbVector.h"
@@ -31,6 +33,10 @@ class _dbTrackGrid : public _dbObject
   dbVector<bool> _samemask;
   dbId<_dbTechLayer> _next_grid;
 
+  // Transient
+  std::vector<int> grid_x_;
+  std::vector<int> grid_y_;
+
   _dbTrackGrid(_dbDatabase*, const _dbTrackGrid& g);
   _dbTrackGrid(_dbDatabase*);
   ~_dbTrackGrid();

src/pad/src/RDLRouter.cpp

@@ -1206,18 +1206,13 @@ void RDLRouter::makeGraph()
 
   graph_weight_ = boost::get(boost::edge_weight, graph_);
 
-  std::vector<int> x_grid;
-  std::vector<int> y_grid;
-
   odb::dbTrackGrid* tracks = block_->findTrackGrid(layer_);
-  tracks->getGridX(x_grid);
-  tracks->getGridY(y_grid);
 
   // filter grid points based on spacing requirements
   const int pitch = width_ + spacing_ - 1;
   const int start = width_ / 2 + 1;
   x_grid_.clear();
-  for (const auto& x : x_grid) {
+  for (const auto& x : tracks->getGridX()) {
     bool add = false;
     if (x_grid_.empty()) {
       if (x >= start) {
@@ -1234,7 +1229,7 @@ void RDLRouter::makeGraph()
     }
   }
   y_grid_.clear();
-  for (const auto& y : y_grid) {
+  for (const auto& y : tracks->getGridY()) {
     bool add = false;
     if (y_grid_.empty()) {
       if (y >= start) {

src/pdn/src/techlayer.cpp

@@ -47,11 +47,11 @@ void TechLayer::populateGrid(odb::dbBlock* block, odb::dbTechLayerDir dir)
 
   auto* tracks = block->findTrackGrid(layer_);
   if (dir == odb::dbTechLayerDir::HORIZONTAL) {
-    tracks->getGridY(grid_);
+    grid_ = tracks->getGridY();
   } else if (dir == odb::dbTechLayerDir::VERTICAL) {
-    tracks->getGridX(grid_);
+    grid_ = tracks->getGridX();
   } else {
-    tracks->getGridY(grid_);
+    grid_ = tracks->getGridY();
   }
 }