Merge pull request #10794 from The-OpenROAD-Project-staging/tap_overlap

tap: prevent overlapping endcap edges in single-height rows between macros

Author: maliberty

src/tap/include/tap/tapcell.h

@@ -213,6 +213,12 @@ class Tapcell
   int placeEndcapEdgeHorizontal(const Edge& edge,
                                 const CornerMap& corners,
                                 const EndcapCellOptions& options);
+  int fillEndcapEdge(odb::dbRow* row,
+                     int x_start,
+                     int x_end,
+                     const std::vector<odb::dbMaster*>& masters,
+                     EdgeType edge_type,
+                     const std::string& prefix);
   int placeEndcapEdgeVertical(const Edge& edge,
                               const CornerMap& corners,
                               const EndcapCellOptions& options);
@@ -234,6 +240,11 @@ class Tapcell
   std::string tap_prefix_;
   std::string endcap_prefix_;
   std::vector<Edge> filled_edges_;
+  // x-ranges already filled by horizontal endcap edges, per row.
+  odb::PtrMap<odb::dbRow, std::vector<std::pair<int, int>>>
+      filled_horizontal_edges_;
+  // corner cells placed so far, per row, persisted across areas/holes.
+  CornerMap placed_corners_;
 };
 
 }  // namespace tap

src/tap/src/tapcell.cpp

@@ -238,6 +238,36 @@ static void findStartEnd(int x,
   }
 }
 
+// Subtract the blocker intervals from [start, end), returning the open gaps.
+static std::vector<std::pair<int, int>> computeOpenSpans(
+    const int start,
+    const int end,
+    std::vector<std::pair<int, int>> blockers)
+{
+  std::ranges::sort(blockers);
+
+  std::vector<std::pair<int, int>> open_spans;
+  int cursor = start;
+  for (const auto& [b_start, b_end] : blockers) {
+    // blockers are sorted by start, so none of the rest can open a span
+    if (b_start >= end) {
+      break;
+    }
+    if (b_end <= cursor) {
+      continue;
+    }
+    if (b_start > cursor) {
+      open_spans.emplace_back(cursor, b_start);
+    }
+    cursor = b_end;
+  }
+  if (cursor < end) {
+    open_spans.emplace_back(cursor, end);
+  }
+
+  return open_spans;
+}
+
 std::optional<int> Tapcell::findValidLocation(
     int x,
     int width,
@@ -524,6 +554,8 @@ void Tapcell::placeEndcaps(const EndcapCellOptions& options)
   }
 
   filled_edges_.clear();
+  filled_horizontal_edges_.clear();
+  placed_corners_.clear();
 }
 
 std::vector<Tapcell::Edge> Tapcell::getBoundaryEdges(const Polygon& area,
@@ -873,18 +905,19 @@ std::pair<int, int> Tapcell::placeEndcaps(const Tapcell::Polygon90& area,
   int corner_count = 0;
   int endcaps = 0;
 
-  CornerMap corners;
-  // insert corners first
+  // insert corners first. placed_corners_ persists across areas/holes so that
+  // edges and corners of one macro's hole see the corners already placed by an
+  // adjacent macro's hole in the same row.
   for (const auto& corner : getBoundaryCorners(area, outer)) {
     for (const auto& [row, insts] : placeEndcapCorner(corner, options)) {
-      corners[row].insert(insts.begin(), insts.end());
+      placed_corners_[row].insert(insts.begin(), insts.end());
       corner_count += insts.size();
     }
   }
 
   for (const auto& edge : getBoundaryEdges(area, outer)) {
     if (std::ranges::find(filled_edges_, edge) == filled_edges_.end()) {
-      endcaps += placeEndcapEdge(edge, corners, options);
+      endcaps += placeEndcapEdge(edge, placed_corners_, options);
       filled_edges_.push_back(edge);
     }
   }
@@ -1048,6 +1081,32 @@ Tapcell::CornerMap Tapcell::placeEndcapCorner(const Tapcell::Corner& corner,
     return {};
   }
 
+  // Skip corners overlapping one already placed in this row, e.g. the inner
+  // top and bottom corners of a single-height row between macros.
+  auto placed = placed_corners_.find(row);
+  if (placed != placed_corners_.end()) {
+    const odb::Rect cell(
+        ll.getX(), ll.getY(), ll.getX() + width, ll.getY() + height);
+    for (auto* other : placed->second) {
+      if (cell.overlaps(other->getBBox()->getBox())) {
+        return {};
+      }
+    }
+  }
+
+  // Skip corners overlapping a horizontal edge already placed in this row: an
+  // adjacent macro's hole may have filled the row before this corner.
+  auto filled = filled_horizontal_edges_.find(row);
+  if (filled != filled_horizontal_edges_.end()) {
+    const int x_start = ll.getX();
+    const int x_end = ll.getX() + width;
+    for (const auto& [e_start, e_end] : filled->second) {
+      if (x_end > e_start && x_start < e_end) {
+        return {};
+      }
+    }
+  }
+
   auto inst = makeInstance(db_->getChip()->getBlock(),
                            master,
                            orient,
@@ -1166,59 +1225,93 @@ int Tapcell::placeEndcapEdgeHorizontal(const Tapcell::Edge& edge,
     }
   }
 
-  odb::Point ll = row->getBBox().ll();
-  ll.setX(e0.getX());
+  // Fill only x-ranges not already covered by another horizontal edge in this
+  // row, so a single-height row between macros gets one edge, not overlaps.
+  std::vector<std::pair<int, int>>& occupied = filled_horizontal_edges_[row];
 
+  // Also skip the corner cells in this row that land within the span.
+  std::vector<std::pair<int, int>> blockers(occupied);
+  if (check_row != corners.end()) {
+    for (auto* inst : check_row->second) {
+      const auto bbox = inst->getBBox()->getBox();
+      blockers.emplace_back(bbox.xMin(), bbox.xMax());
+    }
+  }
+
+  for (const auto& [span_start, span_end] :
+       computeOpenSpans(e0.getX(), e1.getX(), std::move(blockers))) {
+    insts += fillEndcapEdge(
+        row, span_start, span_end, masters, edge.type, options.prefix);
+    occupied.emplace_back(span_start, span_end);
+  }
+
+  return insts;
+}
+
+int Tapcell::fillEndcapEdge(odb::dbRow* row,
+                            const int x_start,
+                            const int x_end,
+                            const std::vector<odb::dbMaster*>& masters,
+                            const EdgeType edge_type,
+                            const std::string& prefix)
+{
+  // Consider only masters that can be legally placed in this row's
+  // orientation. masters is sorted widest first, so the last valid one is the
+  // narrowest, used as a fallback when none divides the span evenly.
   auto pick_next_master
-      = [&e1, &masters](const odb::Point& ll) -> odb::dbMaster* {
-    int remaining = e1.getX() - ll.getX();
+      = [this, x_end, &masters, row](int x) -> odb::dbMaster* {
+    const int remaining = x_end - x;
+    odb::dbMaster* fallback = nullptr;
     for (auto* master : masters) {
+      if (!checkSymmetry(master, row->getOrient())) {
+        continue;
+      }
+      fallback = master;
       if (remaining % master->getWidth() == 0) {
         return master;
       }
     }
-    // pick smallest if none will divide evenly
-    return masters[masters.size() - 1];
+    return fallback;
   };
 
-  while (ll.getX() < e1.getX()) {
-    auto* master = pick_next_master(ll);
-
-    debugPrint(logger_,
-               utl::TAP,
-               "Endcap",
-               3,
-               "From {} -> {}: picked {}",
-               ll.getX(),
-               e1.getX(),
-               master->getName());
-
-    if (!checkSymmetry(master, row->getOrient())) {
-      continue;
-    }
+  const int row_lly = row->getBBox().yMin();
+  int insts = 0;
+  int x = x_start;
+  while (x < x_end) {
+    auto* master = pick_next_master(x);
 
-    if (ll.getX() + master->getWidth() > e1.getX()) {
+    // No symmetric master fits the remaining space: the boundary cannot be
+    // filled without leaving a gap.
+    if (master == nullptr || x + master->getWidth() > x_end) {
       const double dbus = row->getBlock()->getDbUnitsPerMicron();
       logger_->error(
           utl::TAP,
           20,
           "Unable to fill {} boundary in {} from {:.4f}um to {:.4f}um",
-          toString(edge.type),
+          toString(edge_type),
           row->getName(),
-          ll.getX() / dbus,
-          e1.getX() / dbus);
+          x / dbus,
+          x_end / dbus);
     }
 
-    makeInstance(db_->getChip()->getBlock(),
-                 master,
-                 row->getOrient(),
-                 ll.getX(),
-                 ll.getY(),
-                 fmt::format("{}EDGE_{}_{}_",
-                             options.prefix,
-                             row->getName(),
-                             toString(edge.type)));
-    ll.addX(master->getWidth());
+    debugPrint(logger_,
+               utl::TAP,
+               "Endcap",
+               3,
+               "From {} -> {}: picked {}",
+               x,
+               x_end,
+               master->getName());
+
+    makeInstance(
+        db_->getChip()->getBlock(),
+        master,
+        row->getOrient(),
+        x,
+        row_lly,
+        fmt::format(
+            "{}EDGE_{}_{}_", prefix, row->getName(), toString(edge_type)));
+    x += master->getWidth();
     insts++;
   }
 

src/tap/test/BUILD

@@ -45,6 +45,8 @@ COMPULSORY_TESTS = [
     "no_endcap",
     "overlap_cover",
     "region1",
+    "single_row_macros",
+    "single_row_macros_offset",
     "symmetry",
 ]
 
@@ -159,6 +161,8 @@ filegroup(
             "gcd_sky130_separate": ["gcd_sky130.defok"],
             "multiple_calls": ["gcd_ripup.def"],
             "overlap_cover": ["sky130hs_data/cover.lef"],
+            "single_row_macros": [],
+            "single_row_macros_offset": [],
         }.get(
             test_name,
             ["boundary_macros.def"],

src/tap/test/CMakeLists.txt

@@ -38,6 +38,8 @@ or_integration_tests(
     no_endcap
     overlap_cover
     region1
+    single_row_macros
+    single_row_macros_offset
     symmetry
 )
 

src/tap/test/single_row_macros.def

@@ -0,0 +1,92 @@
+VERSION 5.8 ;
+DIVIDERCHAR "/" ;
+BUSBITCHARS "[]" ;
+DESIGN single_row_macros ;
+UNITS DISTANCE MICRONS 2000 ;
+DIEAREA ( 0 0 ) ( 145540 226800 ) ;
+ROW ROW_0 FreePDK45_38x28_10R_NP_162NW_34O 0 0 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_1 FreePDK45_38x28_10R_NP_162NW_34O 0 2800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_2 FreePDK45_38x28_10R_NP_162NW_34O 0 5600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_3 FreePDK45_38x28_10R_NP_162NW_34O 0 8400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_4 FreePDK45_38x28_10R_NP_162NW_34O 0 11200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_5 FreePDK45_38x28_10R_NP_162NW_34O 0 14000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_6 FreePDK45_38x28_10R_NP_162NW_34O 0 16800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_7 FreePDK45_38x28_10R_NP_162NW_34O 0 19600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_8 FreePDK45_38x28_10R_NP_162NW_34O 0 22400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_9 FreePDK45_38x28_10R_NP_162NW_34O 0 25200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_10 FreePDK45_38x28_10R_NP_162NW_34O 0 28000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_11 FreePDK45_38x28_10R_NP_162NW_34O 0 30800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_12 FreePDK45_38x28_10R_NP_162NW_34O 0 33600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_13 FreePDK45_38x28_10R_NP_162NW_34O 0 36400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_14 FreePDK45_38x28_10R_NP_162NW_34O 0 39200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_15 FreePDK45_38x28_10R_NP_162NW_34O 0 42000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_16 FreePDK45_38x28_10R_NP_162NW_34O 0 44800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_17 FreePDK45_38x28_10R_NP_162NW_34O 0 47600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_18 FreePDK45_38x28_10R_NP_162NW_34O 0 50400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_19 FreePDK45_38x28_10R_NP_162NW_34O 0 53200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_20 FreePDK45_38x28_10R_NP_162NW_34O 0 56000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_21 FreePDK45_38x28_10R_NP_162NW_34O 0 58800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_22 FreePDK45_38x28_10R_NP_162NW_34O 0 61600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_23 FreePDK45_38x28_10R_NP_162NW_34O 0 64400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_24 FreePDK45_38x28_10R_NP_162NW_34O 0 67200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_25 FreePDK45_38x28_10R_NP_162NW_34O 0 70000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_26 FreePDK45_38x28_10R_NP_162NW_34O 0 72800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_27 FreePDK45_38x28_10R_NP_162NW_34O 0 75600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_28 FreePDK45_38x28_10R_NP_162NW_34O 0 78400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_29 FreePDK45_38x28_10R_NP_162NW_34O 0 81200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_30 FreePDK45_38x28_10R_NP_162NW_34O 0 84000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_31 FreePDK45_38x28_10R_NP_162NW_34O 0 86800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_32 FreePDK45_38x28_10R_NP_162NW_34O 0 89600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_33 FreePDK45_38x28_10R_NP_162NW_34O 0 92400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_34 FreePDK45_38x28_10R_NP_162NW_34O 0 95200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_35 FreePDK45_38x28_10R_NP_162NW_34O 0 98000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_36 FreePDK45_38x28_10R_NP_162NW_34O 0 100800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_37 FreePDK45_38x28_10R_NP_162NW_34O 0 103600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_38 FreePDK45_38x28_10R_NP_162NW_34O 0 106400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_39 FreePDK45_38x28_10R_NP_162NW_34O 0 109200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_40 FreePDK45_38x28_10R_NP_162NW_34O 0 112000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_41 FreePDK45_38x28_10R_NP_162NW_34O 0 114800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_42 FreePDK45_38x28_10R_NP_162NW_34O 0 117600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_43 FreePDK45_38x28_10R_NP_162NW_34O 0 120400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_44 FreePDK45_38x28_10R_NP_162NW_34O 0 123200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_45 FreePDK45_38x28_10R_NP_162NW_34O 0 126000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_46 FreePDK45_38x28_10R_NP_162NW_34O 0 128800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_47 FreePDK45_38x28_10R_NP_162NW_34O 0 131600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_48 FreePDK45_38x28_10R_NP_162NW_34O 0 134400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_49 FreePDK45_38x28_10R_NP_162NW_34O 0 137200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_50 FreePDK45_38x28_10R_NP_162NW_34O 0 140000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_51 FreePDK45_38x28_10R_NP_162NW_34O 0 142800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_52 FreePDK45_38x28_10R_NP_162NW_34O 0 145600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_53 FreePDK45_38x28_10R_NP_162NW_34O 0 148400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_54 FreePDK45_38x28_10R_NP_162NW_34O 0 151200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_55 FreePDK45_38x28_10R_NP_162NW_34O 0 154000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_56 FreePDK45_38x28_10R_NP_162NW_34O 0 156800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_57 FreePDK45_38x28_10R_NP_162NW_34O 0 159600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_58 FreePDK45_38x28_10R_NP_162NW_34O 0 162400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_59 FreePDK45_38x28_10R_NP_162NW_34O 0 165200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_60 FreePDK45_38x28_10R_NP_162NW_34O 0 168000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_61 FreePDK45_38x28_10R_NP_162NW_34O 0 170800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_62 FreePDK45_38x28_10R_NP_162NW_34O 0 173600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_63 FreePDK45_38x28_10R_NP_162NW_34O 0 176400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_64 FreePDK45_38x28_10R_NP_162NW_34O 0 179200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_65 FreePDK45_38x28_10R_NP_162NW_34O 0 182000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_66 FreePDK45_38x28_10R_NP_162NW_34O 0 184800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_67 FreePDK45_38x28_10R_NP_162NW_34O 0 187600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_68 FreePDK45_38x28_10R_NP_162NW_34O 0 190400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_69 FreePDK45_38x28_10R_NP_162NW_34O 0 193200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_70 FreePDK45_38x28_10R_NP_162NW_34O 0 196000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_71 FreePDK45_38x28_10R_NP_162NW_34O 0 198800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_72 FreePDK45_38x28_10R_NP_162NW_34O 0 201600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_73 FreePDK45_38x28_10R_NP_162NW_34O 0 204400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_74 FreePDK45_38x28_10R_NP_162NW_34O 0 207200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_75 FreePDK45_38x28_10R_NP_162NW_34O 0 210000 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_76 FreePDK45_38x28_10R_NP_162NW_34O 0 212800 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_77 FreePDK45_38x28_10R_NP_162NW_34O 0 215600 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_78 FreePDK45_38x28_10R_NP_162NW_34O 0 218400 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_79 FreePDK45_38x28_10R_NP_162NW_34O 0 221200 N DO 383 BY 1 STEP 380 0 ;
+ROW ROW_80 FreePDK45_38x28_10R_NP_162NW_34O 0 224000 N DO 383 BY 1 STEP 380 0 ;
+COMPONENTS 2 ;
+    - macro_bot fakeram45_64x7 + FIXED ( 19000 0 ) N ;
+    - macro_top fakeram45_64x7 + FIXED ( 19000 114800 ) N ;
+END COMPONENTS
+END DESIGN