pdn: make addShape use unique_ptr

gadfort · gadfort · commit 953f4d764031 · 2025-11-03T09:42:05.000-05:00
Signed-off-by: Peter Gadfort &lt;peter.gadfort@gmail.com&gt;
diff --git a/src/pdn/src/grid_component.cpp b/src/pdn/src/grid_component.cpp
@@ -61,20 +61,20 @@ std::string GridComponent::typeToString(Type type)
   return "Unknown";
 }
 
-ShapePtr GridComponent::addShape(Shape* shape)
+ShapePtr GridComponent::addShape(std::unique_ptr<Shape> shape)
 {
   debugPrint(getLogger(),
              utl::PDN,
              "Shape",
              3,
              "Adding shape {}.",
              shape->getReportText());
-  auto shape_ptr = std::shared_ptr<Shape>(shape);
-  if (!shape_ptr->isValid()) {
+  if (!shape->isValid()) {
     // do not add invalid shapes
     return nullptr;
   }
 
+  auto shape_ptr = std::shared_ptr<Shape>(shape.release());
   shape_ptr->setGridComponent(this);
   const odb::Rect& shape_rect = shape_ptr->getRect();
 
@@ -209,7 +209,7 @@ void GridComponent::replaceShape(
   removeShape(shape);
 
   for (auto& new_shape : replacements) {
-    const auto& new_shape_ptr = addShape(new_shape.release());
+    const auto& new_shape_ptr = addShape(std::move(new_shape));
 
     if (new_shape_ptr == nullptr) {
       continue;
diff --git a/src/pdn/src/grid_component.h b/src/pdn/src/grid_component.h
@@ -102,7 +102,7 @@ class GridComponent
                          int width,
                          int spacing,
                          const odb::dbTechLayerDir& direction) const;
-  ShapePtr addShape(Shape* shape);
+  ShapePtr addShape(std::unique_ptr<Shape> shape);
 
   virtual bool areIntersectionsAllowed() const { return false; }
 
diff --git a/src/pdn/src/rings.cpp b/src/pdn/src/rings.cpp
@@ -249,10 +249,11 @@ void Rings::makeShapes(const Shape::ShapeTreeMap& other_shapes)
       int y_start = core.yMin() - width;
       int y_end = core.yMin();
       for (auto net : nets) {
-        addShape(new Shape(layer,
-                           net,
-                           odb::Rect(x_start, y_start, x_end, y_end),
-                           odb::dbWireShapeType::RING));
+        addShape(
+            std::make_unique<Shape>(layer,
+                                    net,
+                                    odb::Rect(x_start, y_start, x_end, y_end),
+                                    odb::dbWireShapeType::RING));
         if (!extend_to_boundary_) {
           x_start -= other_pitch;
           x_end += other_pitch;
@@ -268,10 +269,11 @@ void Rings::makeShapes(const Shape::ShapeTreeMap& other_shapes)
       y_start = core.yMax();
       y_end = y_start + width;
       for (auto net : nets) {
-        addShape(new Shape(layer,
-                           net,
-                           odb::Rect(x_start, y_start, x_end, y_end),
-                           odb::dbWireShapeType::RING));
+        addShape(
+            std::make_unique<Shape>(layer,
+                                    net,
+                                    odb::Rect(x_start, y_start, x_end, y_end),
+                                    odb::dbWireShapeType::RING));
         if (!extend_to_boundary_) {
           x_start -= other_pitch;
           x_end += other_pitch;
@@ -290,10 +292,11 @@ void Rings::makeShapes(const Shape::ShapeTreeMap& other_shapes)
         y_end = boundary.yMax();
       }
       for (auto net : nets) {
-        addShape(new Shape(layer,
-                           net,
-                           odb::Rect(x_start, y_start, x_end, y_end),
-                           odb::dbWireShapeType::RING));
+        addShape(
+            std::make_unique<Shape>(layer,
+                                    net,
+                                    odb::Rect(x_start, y_start, x_end, y_end),
+                                    odb::dbWireShapeType::RING));
         x_start -= pitch;
         x_end -= pitch;
         if (!extend_to_boundary_) {
@@ -309,10 +312,11 @@ void Rings::makeShapes(const Shape::ShapeTreeMap& other_shapes)
         y_end = core.yMax() + other_width;
       }
       for (auto net : nets) {
-        addShape(new Shape(layer,
-                           net,
-                           odb::Rect(x_start, y_start, x_end, y_end),
-                           odb::dbWireShapeType::RING));
+        addShape(
+            std::make_unique<Shape>(layer,
+                                    net,
+                                    odb::Rect(x_start, y_start, x_end, y_end),
+                                    odb::dbWireShapeType::RING));
         x_start += pitch;
         x_end += pitch;
         if (!extend_to_boundary_) {
diff --git a/src/pdn/src/straps.cpp b/src/pdn/src/straps.cpp
@@ -337,8 +337,8 @@ void Straps::makeStraps(int x_start,
         }
       }
 
-      addShape(
-          new Shape(layer_, net, strap_rect, odb::dbWireShapeType::STRIPE));
+      addShape(std::make_unique<Shape>(
+          layer_, net, strap_rect, odb::dbWireShapeType::STRIPE));
     }
     strap_count++;
     if (number_of_straps_ != 0 && strap_count == number_of_straps_) {
@@ -462,15 +462,15 @@ void FollowPins::makeShapes(const Shape::ShapeTreeMap& other_shapes)
     const int ground_y_bot
         = (power_on_top ? bbox.yMin() : bbox.yMax()) - width / 2;
 
-    auto* power_strap = new FollowPinShape(
+    auto power_strap = std::make_unique<FollowPinShape>(
         layer, power, odb::Rect(x0, power_y_bot, x1, power_y_bot + width));
     power_strap->addRow(row);
-    addShape(power_strap);
+    addShape(std::move(power_strap));
 
-    auto* ground_strap = new FollowPinShape(
+    auto ground_strap = std::make_unique<FollowPinShape>(
         layer, ground, odb::Rect(x0, ground_y_bot, x1, ground_y_bot + width));
     ground_strap->addRow(row);
-    addShape(ground_strap);
+    addShape(std::move(ground_strap));
   }
 }
 
@@ -1072,14 +1072,17 @@ void PadDirectConnectionStraps::makeShapesFacingCore(
         }
       }
 
-      auto* shape
-          = new Shape(layer, net, shape_rect, odb::dbWireShapeType::STRIPE);
+      auto shape = std::make_unique<Shape>(
+          layer, net, shape_rect, odb::dbWireShapeType::STRIPE);
       // use intersection of pin_rect to ensure max width limitation is
       // preserved
       shape->addITermConnection(pin_rect.intersect(shape_rect));
-      addShape(shape);
+      const auto added = addShape(std::move(shape));
+      if (added == nullptr) {
+        continue;
+      }
 
-      target_shapes_[shape] = closest_shape.get();
+      target_shapes_[added.get()] = closest_shape.get();
     }
   }
 }
@@ -1210,15 +1213,19 @@ void PadDirectConnectionStraps::makeShapesOverPads(
     return;
   }
 
-  auto* shape = new Shape(
+  auto shape = std::make_unique<Shape>(
       getLayer(), iterm_->getNet(), shape_rect, odb::dbWireShapeType::STRIPE);
 
   if (getDirection() != getLayer()->getDirection()) {
     shape->setAllowsNonPreferredDirectionChange();
   }
-  addShape(shape);
-  target_shapes_[shape] = closest_shape.get();
-  target_pin_shape_[shape] = org_pin_shape;
+  const auto added = addShape(std::move(shape));
+  if (added == nullptr) {
+    return;
+  }
+
+  target_shapes_[added.get()] = closest_shape.get();
+  target_pin_shape_[added.get()] = org_pin_shape;
 }
 
 bool PadDirectConnectionStraps::snapRectToClosestShape(
@@ -1495,7 +1502,7 @@ bool PadDirectConnectionStraps::refineShape(
       new_rect.set_xhi(check_loc + getWidth());
     }
 
-    std::unique_ptr<Shape> new_shape(shape->copy());
+    std::unique_ptr<Shape> new_shape = shape->copy();
     new_shape->setRect(new_rect);
 
     debugPrint(
@@ -1513,7 +1520,7 @@ bool PadDirectConnectionStraps::refineShape(
             new_shape.get(), all_shapes, all_obstructions, true)) {
       continue;
     }
-    const ShapePtr& added_shape = addShape(new_shape.release());
+    const ShapePtr& added_shape = addShape(std::move(new_shape));
     if (added_shape != nullptr) {
       added_shape->clearITermConnections();
       added_shape->addITermConnection(

Original file line number	Diff line number	Diff line change
`@@ -337,8 +337,8 @@ void Straps::makeStraps(int x_start,`
`337`	`337`	`}`
`338`	`338`	`}`
`339`	`339`
`340`		`- addShape(`
`341`		`- new Shape(layer_, net, strap_rect, odb::dbWireShapeType::STRIPE));`
	`340`	`+ addShape(std::make_unique<Shape>(`
	`341`	`+ layer_, net, strap_rect, odb::dbWireShapeType::STRIPE));`
`342`	`342`	`}`
`343`	`343`	`strap_count++;`
`344`	`344`	`if (number_of_straps_ != 0 && strap_count == number_of_straps_) {`
`@@ -462,15 +462,15 @@ void FollowPins::makeShapes(const Shape::ShapeTreeMap& other_shapes)`
`462`	`462`	`const int ground_y_bot`
`463`	`463`	`= (power_on_top ? bbox.yMin() : bbox.yMax()) - width / 2;`
`464`	`464`
`465`		`- auto* power_strap = new FollowPinShape(`
	`465`	`+ auto power_strap = std::make_unique<FollowPinShape>(`
`466`	`466`	`layer, power, odb::Rect(x0, power_y_bot, x1, power_y_bot + width));`
`467`	`467`	`power_strap->addRow(row);`
`468`		`- addShape(power_strap);`
	`468`	`+ addShape(std::move(power_strap));`
`469`	`469`
`470`		`- auto* ground_strap = new FollowPinShape(`
	`470`	`+ auto ground_strap = std::make_unique<FollowPinShape>(`
`471`	`471`	`layer, ground, odb::Rect(x0, ground_y_bot, x1, ground_y_bot + width));`
`472`	`472`	`ground_strap->addRow(row);`
`473`		`- addShape(ground_strap);`
	`473`	`+ addShape(std::move(ground_strap));`
`474`	`474`	`}`
`475`	`475`	`}`
`476`	`476`
`@@ -1072,14 +1072,17 @@ void PadDirectConnectionStraps::makeShapesFacingCore(`
`1072`	`1072`	`}`
`1073`	`1073`	`}`
`1074`	`1074`
`1075`		`- auto* shape`
`1076`		`- = new Shape(layer, net, shape_rect, odb::dbWireShapeType::STRIPE);`
	`1075`	`+ auto shape = std::make_unique<Shape>(`
	`1076`	`+ layer, net, shape_rect, odb::dbWireShapeType::STRIPE);`
`1077`	`1077`	`// use intersection of pin_rect to ensure max width limitation is`
`1078`	`1078`	`// preserved`
`1079`	`1079`	`shape->addITermConnection(pin_rect.intersect(shape_rect));`
`1080`		`- addShape(shape);`
	`1080`	`+ const auto added = addShape(std::move(shape));`
	`1081`	`+ if (added == nullptr) {`
	`1082`	`+ continue;`
	`1083`	`+ }`
`1081`	`1084`
`1082`		`- target_shapes_[shape] = closest_shape.get();`
	`1085`	`+ target_shapes_[added.get()] = closest_shape.get();`
`1083`	`1086`	`}`
`1084`	`1087`	`}`
`1085`	`1088`	`}`
`@@ -1210,15 +1213,19 @@ void PadDirectConnectionStraps::makeShapesOverPads(`
`1210`	`1213`	`return;`
`1211`	`1214`	`}`
`1212`	`1215`
`1213`		`- auto* shape = new Shape(`
	`1216`	`+ auto shape = std::make_unique<Shape>(`
`1214`	`1217`	`getLayer(), iterm_->getNet(), shape_rect, odb::dbWireShapeType::STRIPE);`
`1215`	`1218`
`1216`	`1219`	`if (getDirection() != getLayer()->getDirection()) {`
`1217`	`1220`	`shape->setAllowsNonPreferredDirectionChange();`
`1218`	`1221`	`}`
`1219`		`- addShape(shape);`
`1220`		`- target_shapes_[shape] = closest_shape.get();`
`1221`		`- target_pin_shape_[shape] = org_pin_shape;`
	`1222`	`+ const auto added = addShape(std::move(shape));`
	`1223`	`+ if (added == nullptr) {`
	`1224`	`+ return;`
	`1225`	`+ }`
	`1226`	`+`
	`1227`	`+ target_shapes_[added.get()] = closest_shape.get();`
	`1228`	`+ target_pin_shape_[added.get()] = org_pin_shape;`
`1222`	`1229`	`}`
`1223`	`1230`
`1224`	`1231`	`bool PadDirectConnectionStraps::snapRectToClosestShape(`
`@@ -1495,7 +1502,7 @@ bool PadDirectConnectionStraps::refineShape(`
`1495`	`1502`	`new_rect.set_xhi(check_loc + getWidth());`
`1496`	`1503`	`}`
`1497`	`1504`
`1498`		`- std::unique_ptr<Shape> new_shape(shape->copy());`
	`1505`	`+ std::unique_ptr<Shape> new_shape = shape->copy();`
`1499`	`1506`	`new_shape->setRect(new_rect);`
`1500`	`1507`
`1501`	`1508`	`debugPrint(`
`@@ -1513,7 +1520,7 @@ bool PadDirectConnectionStraps::refineShape(`
`1513`	`1520`	`new_shape.get(), all_shapes, all_obstructions, true)) {`
`1514`	`1521`	`continue;`
`1515`	`1522`	`}`
`1516`		`- const ShapePtr& added_shape = addShape(new_shape.release());`
	`1523`	`+ const ShapePtr& added_shape = addShape(std::move(new_shape));`
`1517`	`1524`	`if (added_shape != nullptr) {`
`1518`	`1525`	`added_shape->clearITermConnections();`
`1519`	`1526`	`added_shape->addITermConnection(`