Merge pull request The-OpenROAD-Project#9310 from The-OpenROAD-Project-staging/mbff-row-col

gpl: just use the bit count and avoid row/col computation

Author: maliberty

src/gpl/src/mbff.cpp

@@ -178,16 +178,6 @@ float MBFF::GetDistAR(const Point& a, const Point& b, const float AR)
   return (abs(a.x - b.x) / AR + abs(a.y - b.y));
 }
 
-int MBFF::GetRows(const int slot_cnt, const Mask& array_mask)
-{
-  const int idx = GetBitIdx(slot_cnt);
-
-  const std::vector<float>& ys = slot_to_tray_y_[array_mask][idx];
-  const std::set<float> vals(ys.begin(), ys.end());
-
-  return vals.size();
-}
-
 int MBFF::GetBitCnt(const int bit_idx)
 {
   return (1 << bit_idx);
@@ -1322,15 +1312,14 @@ double MBFF::RunILP(const std::vector<Flop>& flops,
 }
 
 void MBFF::GetSlots(const Point& tray,
-                    const int rows,
-                    const int cols,
+                    const int bit_cnt,
                     std::vector<Point>& slots,
                     const Mask& array_mask)
 {
   slots.clear();
-  const int idx = GetBitIdx(rows * cols);
+  const int idx = GetBitIdx(bit_cnt);
   const Point center = GetTrayCenter(array_mask, idx);
-  for (int i = 0; i < rows * cols; i++) {
+  for (int i = 0; i < bit_cnt; i++) {
     slots.push_back({tray.x + slot_to_tray_x_[array_mask][idx][i] - center.x,
                      tray.y + slot_to_tray_y_[array_mask][idx][i] - center.y});
   }
@@ -1541,17 +1530,15 @@ void MBFF::RunCapacitatedKMeans(const std::vector<Flop>& flops,
 {
   cluster.clear();
   const int num_flops = flops.size();
-  const int rows = GetRows(sz, array_mask);
-  const int cols = sz / rows;
   const int num_trays = (num_flops + (sz - 1)) / sz;
 
   for (int i = 0; i < iter; i++) {
     MinCostFlow(flops, trays, sz, cluster);
     const float delta = RunLP(flops, trays, cluster);
 
     for (int j = 0; j < num_trays; j++) {
-      GetSlots(trays[j].pt, rows, cols, trays[j].slots, array_mask);
-      for (int k = 0; k < rows * cols; k++) {
+      GetSlots(trays[j].pt, sz, trays[j].slots, array_mask);
+      for (int k = 0; k < sz; k++) {
         trays[j].cand[k] = -1;
       }
     }
@@ -1600,18 +1587,16 @@ void MBFF::RunMultistart(
   for (int i = 1; i < num_sizes_; i++) {
     if (best_master_[array_mask][i] != nullptr) {
       for (int j = 0; j < 5; j++) {
-        const int rows = GetRows(GetBitCnt(i), array_mask);
-        const int cols = GetBitCnt(i) / rows;
+        const int bit_cnt = GetBitCnt(i);
         const int num_trays = (num_flops + (GetBitCnt(i) - 1)) / GetBitCnt(i);
 
         for (int k = 0; k < num_trays; k++) {
           GetSlots(start_trays[i][j][k].pt,
-                   rows,
-                   cols,
+                   bit_cnt,
                    start_trays[i][j][k].slots,
                    array_mask);
-          start_trays[i][j][k].cand.reserve(rows * cols);
-          for (int idx = 0; idx < rows * cols; idx++) {
+          start_trays[i][j][k].cand.reserve(bit_cnt);
+          for (int idx = 0; idx < bit_cnt; idx++) {
             start_trays[i][j][k].cand.emplace_back(-1);
           }
         }
@@ -1620,14 +1605,13 @@ void MBFF::RunMultistart(
   }
 
   for (const auto& [bit_idx, tray_idx] : ind) {
-    const int rows = GetRows(GetBitCnt(bit_idx), array_mask);
-    const int cols = GetBitCnt(bit_idx) / rows;
+    const int bit_cnt = GetBitCnt(bit_idx);
 
     std::vector<std::pair<int, int>> tmp_cluster;
 
     RunCapacitatedKMeans(flops,
                          start_trays[bit_idx][tray_idx],
-                         rows * cols,
+                         bit_cnt,
                          8,
                          tmp_cluster,
                          array_mask);
@@ -2042,17 +2026,17 @@ float MBFF::RunClustering(const std::vector<Flop>& flops,
   for (int t = 0; t < num_pointsets; t++) {
     all_start_trays[t].resize(num_sizes_);
     for (int i = 1; i < num_sizes_; i++) {
-      if (best_master_[array_mask][i] != nullptr) {
-        const int rows = GetRows(GetBitCnt(i), array_mask);
-        const int cols = GetBitCnt(i) / rows;
-        const float AR = (cols * single_bit_width_ * norm_area_[i])
-                         / (rows * single_bit_height_);
+      odb::dbMaster* master = best_master_[array_mask][i];
+      if (master != nullptr) {
+        const float aspect_ratio
+            = master->getWidth() / static_cast<float>(master->getHeight());
         const int num_trays
             = (pointsets[t].size() + (GetBitCnt(i) - 1)) / GetBitCnt(i);
         all_start_trays[t][i].resize(5);
         for (int j = 0; j < 5; j++) {
           // running in parallel ==> not reproducible
-          GetStartTrays(pointsets[t], num_trays, AR, all_start_trays[t][i][j]);
+          GetStartTrays(
+              pointsets[t], num_trays, aspect_ratio, all_start_trays[t][i][j]);
         }
       }
     }
@@ -2071,28 +2055,21 @@ float MBFF::RunClustering(const std::vector<Flop>& flops,
     const int num_flops = pointsets[t].size();
     for (int i = 1; i < num_sizes_; i++) {
       if (best_master_[array_mask][i] != nullptr) {
-        const int rows = GetRows(GetBitCnt(i), array_mask),
-                  cols = GetBitCnt(i) / rows;
+        const int bit_cnt = GetBitCnt(i);
         const int num_trays = (num_flops + (GetBitCnt(i) - 1)) / GetBitCnt(i);
 
         for (int j = 0; j < num_trays; j++) {
-          GetSlots(cur_trays[i][j].pt,
-                   rows,
-                   cols,
-                   cur_trays[i][j].slots,
-                   array_mask);
+          GetSlots(
+              cur_trays[i][j].pt, bit_cnt, cur_trays[i][j].slots, array_mask);
         }
 
         std::vector<std::pair<int, int>> cluster;
         RunCapacitatedKMeans(
             pointsets[t], cur_trays[i], GetBitCnt(i), 35, cluster, array_mask);
         MinCostFlow(pointsets[t], cur_trays[i], GetBitCnt(i), cluster);
         for (int j = 0; j < num_trays; j++) {
-          GetSlots(cur_trays[i][j].pt,
-                   rows,
-                   cols,
-                   cur_trays[i][j].slots,
-                   array_mask);
+          GetSlots(
+              cur_trays[i][j].pt, bit_cnt, cur_trays[i][j].slots, array_mask);
         }
       }
     }

src/gpl/src/mbff.h

@@ -96,7 +96,6 @@ class MBFF
   const sta::LibertyCell* getLibertyCell(const sta::Cell* cell);
   float GetDist(const Point& a, const Point& b);
   float GetDistAR(const Point& a, const Point& b, float AR);
-  int GetRows(int slot_cnt, const Mask& array_mask);
   int GetBitCnt(int bit_idx);
   int GetBitIdx(int bit_cnt);
 
@@ -147,8 +146,7 @@ class MBFF
   Point GetTrayCenter(const Mask& array_mask, int idx);
   // get slots w.r.t. tray center
   void GetSlots(const Point& tray,
-                int rows,
-                int cols,
+                int bit_cnt,
                 std::vector<Point>& slots,
                 const Mask& array_mask);