drt: add lef58_area markers and add test case

Signed-off-by: osamahammad21 <osama@precisioninno.com>

Author: osamahammad21

src/drt/src/gc/FlexGC_impl.h

@@ -534,13 +534,16 @@ class FlexGCWorker::Impl
                               frMinimumcutConstraint* con);
   void checkMinimumCut_main(gcRect* rect);
   void checkMinimumCut();
-  void checkMetalShape_lef58Area(gcPin* pin);
+  void checkMetalShape_lef58Area(gcPin* pin, bool allow_patching);
   bool checkMetalShape_lef58Area_exceptRectangle(
       gcPolygon* poly,
       odb::dbTechLayerAreaRule* db_rule);
   bool checkMetalShape_lef58Area_rectWidth(gcPolygon* poly,
                                            odb::dbTechLayerAreaRule* db_rule);
   void checkMetalShape_addPatch(gcPin* pin, int min_area);
+  void checkMetalShape_addMarker(gcPin* pin,
+                                 frConstraint* con,
+                                 const odb::Rect& bbox);
   void checkMetalShape_patchOwner_helper(drPatchWire* patch,
                                          const std::vector<drNet*>* dr_nets);
 

src/drt/src/gc/FlexGC_main.cpp

@@ -1644,16 +1644,7 @@ void FlexGCWorker::Impl::checkMetalShape_minArea(gcPin* pin,
   if (allow_patching) {
     checkMetalShape_addPatch(pin, reqArea);
   } else {
-    auto net = poly->getNet();
-    auto marker = std::make_unique<frMarker>();
-    marker->setBBox(bbox2);
-    marker->setLayerNum(layerNum);
-    marker->setConstraint(con);
-    marker->addSrc(net->getOwner());
-    marker->addVictim(net->getOwner(), std::make_tuple(layerNum, bbox2, false));
-    marker->addAggressor(net->getOwner(),
-                         std::make_tuple(layerNum, bbox2, false));
-    addMarker(std::move(marker));
+    checkMetalShape_addMarker(pin, con, bbox2);
   }
 }
 
@@ -2095,9 +2086,15 @@ void FlexGCWorker::Impl::checkMetalShape_minEnclosedArea(gcPin* pin)
   }
 }
 
-void FlexGCWorker::Impl::checkMetalShape_lef58Area(gcPin* pin)
+void FlexGCWorker::Impl::checkMetalShape_lef58Area(gcPin* pin,
+                                                   bool allow_patching)
 {
-  if (ignoreMinArea_ || !targetNet_) {
+  if (ignoreMinArea_) {
+    return;
+  }
+  // Patching requires a target net (and an associated drWorker); marking does
+  // not.
+  if (allow_patching && !targetNet_) {
     return;
   }
 
@@ -2113,7 +2110,7 @@ void FlexGCWorker::Impl::checkMetalShape_lef58Area(gcPin* pin)
   gtl::extents(bbox, *pin->getPolygon());
   const odb::Rect bbox2(
       gtl::xl(bbox), gtl::yl(bbox), gtl::xh(bbox), gtl::yh(bbox));
-  if (!drWorker_->getDrcBox().contains(bbox2)) {
+  if (!drcBox_.contains(bbox2)) {
     return;
   }
   const bool is_rect = poly->size() == 4;
@@ -2125,7 +2122,11 @@ void FlexGCWorker::Impl::checkMetalShape_lef58Area(gcPin* pin)
         // we found a rectwidth constraint that is satisfied
         const auto min_area = db_rule->getArea();
         if (curr_area < min_area) {
-          checkMetalShape_addPatch(pin, min_area);
+          if (allow_patching) {
+            checkMetalShape_addPatch(pin, min_area);
+          } else {
+            checkMetalShape_addMarker(pin, con, bbox2);
+          }
         }
         return;
       }
@@ -2142,7 +2143,11 @@ void FlexGCWorker::Impl::checkMetalShape_lef58Area(gcPin* pin)
     }
     if (!db_rule->isExceptRectangle()
         || checkMetalShape_lef58Area_exceptRectangle(poly, db_rule)) {
-      checkMetalShape_addPatch(pin, min_area);
+      if (allow_patching) {
+        checkMetalShape_addPatch(pin, min_area);
+      } else {
+        checkMetalShape_addMarker(pin, con, bbox2);
+      }
       break;
     }
   }
@@ -2283,6 +2288,24 @@ void FlexGCWorker::Impl::checkMetalShape_addPatch(gcPin* pin, int min_area)
   pwires_.push_back(std::move(patch));
 }
 
+void FlexGCWorker::Impl::checkMetalShape_addMarker(gcPin* pin,
+                                                   frConstraint* con,
+                                                   const odb::Rect& bbox)
+{
+  auto poly = pin->getPolygon();
+  auto layer_num = poly->getLayerNum();
+  auto net = poly->getNet();
+  auto marker = std::make_unique<frMarker>();
+  marker->setBBox(bbox);
+  marker->setLayerNum(layer_num);
+  marker->setConstraint(con);
+  marker->addSrc(net->getOwner());
+  marker->addVictim(net->getOwner(), std::make_tuple(layer_num, bbox, false));
+  marker->addAggressor(net->getOwner(),
+                       std::make_tuple(layer_num, bbox, false));
+  addMarker(std::move(marker));
+}
+
 void FlexGCWorker::Impl::checkMetalShape_patchOwner_helper(
     drPatchWire* patch,
     const std::vector<drNet*>* dr_nets)
@@ -2353,9 +2376,7 @@ void FlexGCWorker::Impl::checkMetalShape_main(gcPin* pin, bool allow_patching)
   checkMetalShape_minEnclosedArea(pin);
 
   // lef58 area
-  if (allow_patching) {
-    checkMetalShape_lef58Area(pin);
-  }
+  checkMetalShape_lef58Area(pin, allow_patching);
 }
 
 void FlexGCWorker::Impl::checkMetalShape(bool allow_patching)

src/drt/test/fixture.cpp

@@ -344,6 +344,33 @@ void Fixture::makeMinEnclosedAreaConstraint(frLayerNum layer_num)
   tech->addUConstraint(std::move(con));
 }
 
+odb::dbTechLayerAreaRule* Fixture::makeLef58AreaConstraint(
+    frLayerNum layer_num,
+    int64_t area,
+    int rect_width,
+    bool except_rectangle)
+{
+  frTechObject* tech = design->getTech();
+  frLayer* layer = tech->getLayer(layer_num);
+  odb::dbTechLayer* db_layer = db_tech->findLayer(layer->getName().c_str());
+
+  auto rule = odb::dbTechLayerAreaRule::create(db_layer);
+  rule->setArea(area);
+  if (rect_width > 0) {
+    rule->setRectWidth(rect_width);
+  }
+  rule->setExceptRectangle(except_rectangle);
+
+  auto con = std::make_unique<frLef58AreaConstraint>(rule);
+  if (rule->getRectWidth() > 0) {
+    layer->addLef58AreaConstraintRectWidth(con.get());
+  } else {
+    layer->addLef58AreaConstraint(con.get());
+  }
+  tech->addUConstraint(std::move(con));
+  return rule;
+}
+
 void Fixture::makeSpacingEndOfLineConstraint(frLayerNum layer_num,
                                              frCoord par_space,
                                              frCoord par_within,

src/drt/test/fixture.h

@@ -92,6 +92,12 @@ class Fixture : public ::testing::Test
 
   void makeMinEnclosedAreaConstraint(frLayerNum layer_num);
 
+  odb::dbTechLayerAreaRule* makeLef58AreaConstraint(frLayerNum layer_num,
+                                                    int64_t area,
+                                                    int rect_width = -1,
+                                                    bool except_rectangle
+                                                    = false);
+
   void makeSpacingEndOfLineConstraint(frLayerNum layer_num,
                                       frCoord par_space = -1,
                                       frCoord par_within = -1,

src/drt/test/gcTest.cpp

@@ -600,6 +600,36 @@ TEST_F(GCFixture, min_enclosed_area)
              odb::Rect(50, 50, 150, 150));
 }
 
+using Lef58AreaFixture = FixtureWithParam<bool>;
+
+TEST_P(Lef58AreaFixture, lef58_area)
+{
+  const bool legal = GetParam();
+  // The wire below provides 200 x 100 = 20000 DBU^2.  Require just under that
+  // when legal and just over it when illegal.
+  makeLef58AreaConstraint(2, /* area */ legal ? 20000 : 30000);
+
+  frNet* n1 = makeNet("n1");
+
+  makePathseg(n1, 2, {0, 100}, {200, 100});
+
+  runGC();
+
+  // Test the results
+  auto& markers = worker.getMarkers();
+  if (legal) {
+    EXPECT_EQ(markers.size(), 0);
+  } else {
+    EXPECT_EQ(markers.size(), 1);
+    testMarker(markers[0].get(),
+               2,
+               frConstraintTypeEnum::frcLef58AreaConstraint,
+               odb::Rect(0, 50, 200, 150));
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(Lef58AreaSuite, Lef58AreaFixture, testing::Bool());
+
 // Check for a spacing table influence violation.
 TEST_F(GCFixture, spacing_table_infl_vertical)
 {