pdn: use unique_ptr during copies and replacements

gadfort · gadfort · commit 0cdaba98202e · 2025-11-03T09:30:18.000-05:00
Signed-off-by: Peter Gadfort &lt;peter.gadfort@gmail.com&gt;
diff --git a/src/pdn/src/PdnGen.cc b/src/pdn/src/PdnGen.cc
@@ -195,7 +195,7 @@ void PdnGen::trimShapes()
         const bool is_pin_layer
             = pin_layers.find(shape->getLayer()) != pin_layers.end();
 
-        Shape* new_shape = nullptr;
+        std::unique_ptr<Shape> new_shape = nullptr;
         const odb::Rect new_rect = shape->getMinimumRect();
         if (new_rect == shape->getRect()) {  // no change to shape
           continue;
@@ -221,7 +221,7 @@ void PdnGen::trimShapes()
           }
         } else {
           if (!is_pin_layer) {
-            component->replaceShape(shape.get(), {new_shape});
+            component->replaceShape(shape.get(), std::move(new_shape));
           }
         }
       }
diff --git a/src/pdn/src/grid.cpp b/src/pdn/src/grid.cpp
@@ -292,7 +292,7 @@ bool Grid::repairVias(const Shape::ShapeTreeMap& global_shapes,
     return !shape->belongsTo(this);
   };
 
-  std::map<Shape*, Shape*> replace_shapes;
+  std::map<Shape*, std::unique_ptr<Shape>> replace_shapes;
   for (const auto& via : vias_) {
     // ensure shapes belong to something
     const auto& lower_shape = via->getLowerShape();
@@ -313,28 +313,28 @@ bool Grid::repairVias(const Shape::ShapeTreeMap& global_shapes,
     }
 
     if (lower_belongs_to_grid && lower_shape->isModifiable()) {
-      auto* new_lower
+      auto new_lower
           = lower_shape->extendTo(upper_shape->getRect(),
                                   obstructions[lower_shape->getLayer()],
                                   obs_filter);
       if (new_lower != nullptr) {
-        replace_shapes[lower_shape.get()] = new_lower;
+        replace_shapes[lower_shape.get()] = std::move(new_lower);
       }
     }
     if (upper_belongs_to_grid && upper_shape->isModifiable()) {
-      auto* new_upper
+      auto new_upper
           = upper_shape->extendTo(lower_shape->getRect(),
                                   obstructions[upper_shape->getLayer()],
                                   obs_filter);
       if (new_upper != nullptr) {
-        replace_shapes[upper_shape.get()] = new_upper;
+        replace_shapes[upper_shape.get()] = std::move(new_upper);
       }
     }
   }
 
-  for (const auto& [old_shape, new_shape] : replace_shapes) {
+  for (auto& [old_shape, new_shape] : replace_shapes) {
     auto* component = old_shape->getGridComponent();
-    component->replaceShape(old_shape, {new_shape});
+    component->replaceShape(old_shape, std::move(new_shape));
   }
 
   debugPrint(getLogger(),
diff --git a/src/pdn/src/grid_component.cpp b/src/pdn/src/grid_component.cpp
@@ -193,14 +193,23 @@ void GridComponent::removeShape(Shape* shape)
 }
 
 void GridComponent::replaceShape(Shape* shape,
-                                 const std::vector<Shape*>& replacements)
+                                 std::unique_ptr<Shape> replacement)
+{
+  std::vector<std::unique_ptr<Shape>> replacements;
+  replacements.push_back(std::move(replacement));
+  replaceShape(shape, replacements);
+}
+
+void GridComponent::replaceShape(
+    Shape* shape,
+    std::vector<std::unique_ptr<Shape>>& replacements)
 {
   auto vias = shape->getVias();
 
   removeShape(shape);
 
-  for (auto* new_shape : replacements) {
-    const auto& new_shape_ptr = addShape(new_shape);
+  for (auto& new_shape : replacements) {
+    const auto& new_shape_ptr = addShape(new_shape.release());
 
     if (new_shape_ptr == nullptr) {
       continue;
@@ -217,6 +226,8 @@ void GridComponent::replaceShape(Shape* shape,
       }
     }
   }
+
+  replacements.clear();
 }
 
 void GridComponent::getObstructions(
@@ -283,17 +294,17 @@ void GridComponent::cutShapes(const Shape::ObstructionTreeMap& obstructions)
       continue;
     }
     const auto& obs = obstructions.at(layer);
-    std::map<Shape*, std::vector<Shape*>> replacement_shapes;
+    std::map<Shape*, std::vector<std::unique_ptr<Shape>>> replacement_shapes;
     for (const auto& shape : shapes) {
-      std::vector<Shape*> replacements;
+      std::vector<std::unique_ptr<Shape>> replacements;
       if (!shape->cut(obs, getGrid(), replacements)) {
         continue;
       }
 
       replacement_shapes[shape.get()] = std::move(replacements);
     }
 
-    for (const auto& [shape, replacement] : replacement_shapes) {
+    for (auto& [shape, replacement] : replacement_shapes) {
       replaceShape(shape, replacement);
     }
   }
diff --git a/src/pdn/src/grid_component.h b/src/pdn/src/grid_component.h
@@ -56,7 +56,9 @@ class GridComponent
   void getShapes(Shape::ShapeTreeMap& shapes) const;
   void removeShapes(Shape::ShapeTreeMap& shapes) const;
   void removeShape(Shape* shape);
-  void replaceShape(Shape* shape, const std::vector<Shape*>& replacements);
+  void replaceShape(Shape* shape, std::unique_ptr<Shape> replacement);
+  void replaceShape(Shape* shape,
+                    std::vector<std::unique_ptr<Shape>>& replacements);
   void clearShapes() { shapes_.clear(); }
   int getShapeCount() const;
 
diff --git a/src/pdn/src/shape.cpp b/src/pdn/src/shape.cpp
@@ -62,9 +62,9 @@ utl::Logger* Shape::getLogger() const
   return grid_component_->getLogger();
 }
 
-Shape* Shape::copy() const
+std::unique_ptr<Shape> Shape::copy() const
 {
-  auto* shape = new Shape(layer_, net_, rect_, type_);
+  auto shape = std::make_unique<Shape>(layer_, net_, rect_, type_);
   shape->shape_type_ = shape_type_;
   shape->obs_ = obs_;
   shape->iterm_connections_ = iterm_connections_;
@@ -204,7 +204,7 @@ odb::Rect Shape::getMinimumRect() const
 
 bool Shape::cut(const ObstructionTree& obstructions,
                 const Grid* ignore_grid,
-                std::vector<Shape*>& replacements) const
+                std::vector<std::unique_ptr<Shape>>& replacements) const
 {
   return cut(
       obstructions, replacements, [ignore_grid](const ShapePtr& other) -> bool {
@@ -217,7 +217,7 @@ bool Shape::cut(const ObstructionTree& obstructions,
 }
 
 bool Shape::cut(const ObstructionTree& obstructions,
-                std::vector<Shape*>& replacements,
+                std::vector<std::unique_ptr<Shape>>& replacements,
                 const std::function<bool(const ShapePtr&)>& obs_filter) const
 {
   using namespace boost::polygon::operators;
@@ -306,11 +306,11 @@ bool Shape::cut(const ObstructionTree& obstructions,
     }
 
     if (accept) {
-      auto* new_shape = copy();
+      auto new_shape = copy();
       new_shape->setRect(new_rect);
       new_shape->updateTermConnections();
 
-      replacements.push_back(new_shape);
+      replacements.push_back(std::move(new_shape));
     }
   }
   return true;
@@ -593,12 +593,12 @@ std::string Shape::getRectText(const odb::Rect& rect, double dbu_to_micron)
                      rect.yMax() / dbu_to_micron);
 }
 
-Shape* Shape::extendTo(
+std::unique_ptr<Shape> Shape::extendTo(
     const odb::Rect& rect,
     const ObstructionTree& obstructions,
     const std::function<bool(const ShapePtr&)>& obs_filter) const
 {
-  std::unique_ptr<Shape> new_shape(copy());
+  std::unique_ptr<Shape> new_shape = copy();
 
   if (isHorizontal()) {
     new_shape->rect_.set_xlo(std::min(rect_.xMin(), rect.xMin()));
@@ -626,7 +626,7 @@ Shape* Shape::extendTo(
     return nullptr;
   }
 
-  return new_shape.release();
+  return new_shape;
 }
 
 Shape::ShapeTreeMap Shape::convertVectorToTree(ShapeVectorMap& vec)
@@ -672,9 +672,10 @@ FollowPinShape::FollowPinShape(odb::dbTechLayer* layer,
 {
 }
 
-Shape* FollowPinShape::copy() const
+std::unique_ptr<Shape> FollowPinShape::copy() const
 {
-  auto* shape = new FollowPinShape(getLayer(), getNet(), getRect());
+  auto shape
+      = std::make_unique<FollowPinShape>(getLayer(), getNet(), getRect());
   shape->generateObstruction();
   shape->rows_ = rows_;
   return shape;
@@ -741,9 +742,10 @@ odb::Rect FollowPinShape::getMinimumRect() const
   return min_shape;
 }
 
-bool FollowPinShape::cut(const ObstructionTree& obstructions,
-                         const Grid* ignore_grid,
-                         std::vector<Shape*>& replacements) const
+bool FollowPinShape::cut(
+    const ObstructionTree& obstructions,
+    const Grid* ignore_grid,
+    std::vector<std::unique_ptr<Shape>>& replacements) const
 {
   return Shape::cut(
       obstructions, replacements, [](const ShapePtr& other) -> bool {
diff --git a/src/pdn/src/shape.h b/src/pdn/src/shape.h
@@ -175,18 +175,18 @@ class Shape
   int getNumberOfConnectionsBelow() const;
   int getNumberOfConnectionsAbove() const;
 
-  Shape* extendTo(
+  std::unique_ptr<Shape> extendTo(
       const odb::Rect& rect,
       const ObstructionTree& obstructions,
       const std::function<bool(const ShapePtr&)>& obs_filter
       = [](const ShapePtr&) { return true; }) const;
 
   virtual bool cut(const ObstructionTree& obstructions,
                    const Grid* ignore_grid,
-                   std::vector<Shape*>& replacements) const;
+                   std::vector<std::unique_ptr<Shape>>& replacements) const;
 
   // return a copy of the shape
-  virtual Shape* copy() const;
+  virtual std::unique_ptr<Shape> copy() const;
   // merge this shape with another
   virtual void merge(Shape* shape);
 
@@ -223,7 +223,7 @@ class Shape
 
  protected:
   bool cut(const ObstructionTree& obstructions,
-           std::vector<Shape*>& replacements,
+           std::vector<std::unique_ptr<Shape>>& replacements,
            const std::function<bool(const ShapePtr&)>& obs_filter) const;
 
  private:
@@ -261,7 +261,7 @@ class FollowPinShape : public Shape
   void addRow(odb::dbRow* row) { rows_.insert(row); }
 
   odb::Rect getMinimumRect() const override;
-  Shape* copy() const override;
+  std::unique_ptr<Shape> copy() const override;
   void merge(Shape* shape) override;
   void updateTermConnections() override;
 
@@ -274,7 +274,7 @@ class FollowPinShape : public Shape
 
   bool cut(const ObstructionTree& obstructions,
            const Grid* ignore_grid,
-           std::vector<Shape*>& replacements) const override;
+           std::vector<std::unique_ptr<Shape>>& replacements) const override;
 
  private:
   std::set<odb::dbRow*> rows_;

Original file line number	Diff line number	Diff line change
`@@ -195,7 +195,7 @@ void PdnGen::trimShapes()`
`195`	`195`	`const bool is_pin_layer`
`196`	`196`	`= pin_layers.find(shape->getLayer()) != pin_layers.end();`
`197`	`197`
`198`		`- Shape* new_shape = nullptr;`
	`198`	`+ std::unique_ptr<Shape> new_shape = nullptr;`
`199`	`199`	`const odb::Rect new_rect = shape->getMinimumRect();`
`200`	`200`	`if (new_rect == shape->getRect()) { // no change to shape`
`201`	`201`	`continue;`
`@@ -221,7 +221,7 @@ void PdnGen::trimShapes()`
`221`	`221`	`}`
`222`	`222`	`} else {`
`223`	`223`	`if (!is_pin_layer) {`
`224`		`- component->replaceShape(shape.get(), {new_shape});`
	`224`	`+ component->replaceShape(shape.get(), std::move(new_shape));`
`225`	`225`	`}`
`226`	`226`	`}`
`227`	`227`	`}`
Original file line number	Diff line number	Diff line change
`@@ -292,7 +292,7 @@ bool Grid::repairVias(const Shape::ShapeTreeMap& global_shapes,`
`292`	`292`	`return !shape->belongsTo(this);`
`293`	`293`	`};`
`294`	`294`
`295`		`- std::map<Shape, Shape> replace_shapes;`
	`295`	`+ std::map<Shape*, std::unique_ptr<Shape>> replace_shapes;`
`296`	`296`	`for (const auto& via : vias_) {`
`297`	`297`	`// ensure shapes belong to something`
`298`	`298`	`const auto& lower_shape = via->getLowerShape();`
`@@ -313,28 +313,28 @@ bool Grid::repairVias(const Shape::ShapeTreeMap& global_shapes,`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`if (lower_belongs_to_grid && lower_shape->isModifiable()) {`
`316`		`- auto* new_lower`
	`316`	`+ auto new_lower`
`317`	`317`	`= lower_shape->extendTo(upper_shape->getRect(),`
`318`	`318`	`obstructions[lower_shape->getLayer()],`
`319`	`319`	`obs_filter);`
`320`	`320`	`if (new_lower != nullptr) {`
`321`		`- replace_shapes[lower_shape.get()] = new_lower;`
	`321`	`+ replace_shapes[lower_shape.get()] = std::move(new_lower);`
`322`	`322`	`}`
`323`	`323`	`}`
`324`	`324`	`if (upper_belongs_to_grid && upper_shape->isModifiable()) {`
`325`		`- auto* new_upper`
	`325`	`+ auto new_upper`
`326`	`326`	`= upper_shape->extendTo(lower_shape->getRect(),`
`327`	`327`	`obstructions[upper_shape->getLayer()],`
`328`	`328`	`obs_filter);`
`329`	`329`	`if (new_upper != nullptr) {`
`330`		`- replace_shapes[upper_shape.get()] = new_upper;`
	`330`	`+ replace_shapes[upper_shape.get()] = std::move(new_upper);`
`331`	`331`	`}`
`332`	`332`	`}`
`333`	`333`	`}`
`334`	`334`
`335`		`- for (const auto& [old_shape, new_shape] : replace_shapes) {`
	`335`	`+ for (auto& [old_shape, new_shape] : replace_shapes) {`
`336`	`336`	`auto* component = old_shape->getGridComponent();`
`337`		`- component->replaceShape(old_shape, {new_shape});`
	`337`	`+ component->replaceShape(old_shape, std::move(new_shape));`
`338`	`338`	`}`
`339`	`339`
`340`	`340`	`debugPrint(getLogger(),`
Original file line number	Diff line number	Diff line change
`@@ -193,14 +193,23 @@ void GridComponent::removeShape(Shape* shape)`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`void GridComponent::replaceShape(Shape* shape,`
`196`		`- const std::vector<Shape*>& replacements)`
	`196`	`+ std::unique_ptr<Shape> replacement)`
	`197`	`+{`
	`198`	`+ std::vector<std::unique_ptr<Shape>> replacements;`
	`199`	`+ replacements.push_back(std::move(replacement));`
	`200`	`+ replaceShape(shape, replacements);`
	`201`	`+}`
	`202`	`+`
	`203`	`+void GridComponent::replaceShape(`
	`204`	`+ Shape* shape,`
	`205`	`+ std::vector<std::unique_ptr<Shape>>& replacements)`
`197`	`206`	`{`
`198`	`207`	`auto vias = shape->getVias();`
`199`	`208`
`200`	`209`	`removeShape(shape);`
`201`	`210`
`202`		`- for (auto* new_shape : replacements) {`
`203`		`- const auto& new_shape_ptr = addShape(new_shape);`
	`211`	`+ for (auto& new_shape : replacements) {`
	`212`	`+ const auto& new_shape_ptr = addShape(new_shape.release());`
`204`	`213`
`205`	`214`	`if (new_shape_ptr == nullptr) {`
`206`	`215`	`continue;`
`@@ -217,6 +226,8 @@ void GridComponent::replaceShape(Shape* shape,`
`217`	`226`	`}`
`218`	`227`	`}`
`219`	`228`	`}`
	`229`	`+`
	`230`	`+ replacements.clear();`
`220`	`231`	`}`
`221`	`232`
`222`	`233`	`void GridComponent::getObstructions(`
`@@ -283,17 +294,17 @@ void GridComponent::cutShapes(const Shape::ObstructionTreeMap& obstructions)`
`283`	`294`	`continue;`
`284`	`295`	`}`
`285`	`296`	`const auto& obs = obstructions.at(layer);`
`286`		`- std::map<Shape, std::vector<Shape>> replacement_shapes;`
	`297`	`+ std::map<Shape*, std::vector<std::unique_ptr<Shape>>> replacement_shapes;`
`287`	`298`	`for (const auto& shape : shapes) {`
`288`		`- std::vector<Shape*> replacements;`
	`299`	`+ std::vector<std::unique_ptr<Shape>> replacements;`
`289`	`300`	`if (!shape->cut(obs, getGrid(), replacements)) {`
`290`	`301`	`continue;`
`291`	`302`	`}`
`292`	`303`
`293`	`304`	`replacement_shapes[shape.get()] = std::move(replacements);`
`294`	`305`	`}`
`295`	`306`
`296`		`- for (const auto& [shape, replacement] : replacement_shapes) {`
	`307`	`+ for (auto& [shape, replacement] : replacement_shapes) {`
`297`	`308`	`replaceShape(shape, replacement);`
`298`	`309`	`}`
`299`	`310`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,9 +62,9 @@ utl::Logger* Shape::getLogger() const`
`62`	`62`	`return grid_component_->getLogger();`
`63`	`63`	`}`
`64`	`64`
`65`		`-Shape* Shape::copy() const`
	`65`	`+std::unique_ptr<Shape> Shape::copy() const`
`66`	`66`	`{`
`67`		`- auto* shape = new Shape(layer_, net_, rect_, type_);`
	`67`	`+ auto shape = std::make_unique<Shape>(layer_, net_, rect_, type_);`
`68`	`68`	`shape->shape_type_ = shape_type_;`
`69`	`69`	`shape->obs_ = obs_;`
`70`	`70`	`shape->iterm_connections_ = iterm_connections_;`
`@@ -204,7 +204,7 @@ odb::Rect Shape::getMinimumRect() const`
`204`	`204`
`205`	`205`	`bool Shape::cut(const ObstructionTree& obstructions,`
`206`	`206`	`const Grid* ignore_grid,`
`207`		`- std::vector<Shape*>& replacements) const`
	`207`	`+ std::vector<std::unique_ptr<Shape>>& replacements) const`
`208`	`208`	`{`
`209`	`209`	`return cut(`
`210`	`210`	`obstructions, replacements, [ignore_grid](const ShapePtr& other) -> bool {`
`@@ -217,7 +217,7 @@ bool Shape::cut(const ObstructionTree& obstructions,`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`bool Shape::cut(const ObstructionTree& obstructions,`
`220`		`- std::vector<Shape*>& replacements,`
	`220`	`+ std::vector<std::unique_ptr<Shape>>& replacements,`
`221`	`221`	`const std::function<bool(const ShapePtr&)>& obs_filter) const`
`222`	`222`	`{`
`223`	`223`	`using namespace boost::polygon::operators;`
`@@ -306,11 +306,11 @@ bool Shape::cut(const ObstructionTree& obstructions,`
`306`	`306`	`}`
`307`	`307`
`308`	`308`	`if (accept) {`
`309`		`- auto* new_shape = copy();`
	`309`	`+ auto new_shape = copy();`
`310`	`310`	`new_shape->setRect(new_rect);`
`311`	`311`	`new_shape->updateTermConnections();`
`312`	`312`
`313`		`- replacements.push_back(new_shape);`
	`313`	`+ replacements.push_back(std::move(new_shape));`
`314`	`314`	`}`
`315`	`315`	`}`
`316`	`316`	`return true;`
`@@ -593,12 +593,12 @@ std::string Shape::getRectText(const odb::Rect& rect, double dbu_to_micron)`
`593`	`593`	`rect.yMax() / dbu_to_micron);`
`594`	`594`	`}`
`595`	`595`
`596`		`-Shape* Shape::extendTo(`
	`596`	`+std::unique_ptr<Shape> Shape::extendTo(`
`597`	`597`	`const odb::Rect& rect,`
`598`	`598`	`const ObstructionTree& obstructions,`
`599`	`599`	`const std::function<bool(const ShapePtr&)>& obs_filter) const`
`600`	`600`	`{`
`601`		`- std::unique_ptr<Shape> new_shape(copy());`
	`601`	`+ std::unique_ptr<Shape> new_shape = copy();`
`602`	`602`
`603`	`603`	`if (isHorizontal()) {`
`604`	`604`	`new_shape->rect_.set_xlo(std::min(rect_.xMin(), rect.xMin()));`
`@@ -626,7 +626,7 @@ Shape* Shape::extendTo(`
`626`	`626`	`return nullptr;`
`627`	`627`	`}`
`628`	`628`
`629`		`- return new_shape.release();`
	`629`	`+ return new_shape;`
`630`	`630`	`}`
`631`	`631`
`632`	`632`	`Shape::ShapeTreeMap Shape::convertVectorToTree(ShapeVectorMap& vec)`
`@@ -672,9 +672,10 @@ FollowPinShape::FollowPinShape(odb::dbTechLayer* layer,`
`672`	`672`	`{`
`673`	`673`	`}`
`674`	`674`
`675`		`-Shape* FollowPinShape::copy() const`
	`675`	`+std::unique_ptr<Shape> FollowPinShape::copy() const`
`676`	`676`	`{`
`677`		`- auto* shape = new FollowPinShape(getLayer(), getNet(), getRect());`
	`677`	`+ auto shape`
	`678`	`+ = std::make_unique<FollowPinShape>(getLayer(), getNet(), getRect());`
`678`	`679`	`shape->generateObstruction();`
`679`	`680`	`shape->rows_ = rows_;`
`680`	`681`	`return shape;`
`@@ -741,9 +742,10 @@ odb::Rect FollowPinShape::getMinimumRect() const`
`741`	`742`	`return min_shape;`
`742`	`743`	`}`
`743`	`744`
`744`		`-bool FollowPinShape::cut(const ObstructionTree& obstructions,`
`745`		`- const Grid* ignore_grid,`
`746`		`- std::vector<Shape*>& replacements) const`
	`745`	`+bool FollowPinShape::cut(`
	`746`	`+ const ObstructionTree& obstructions,`
	`747`	`+ const Grid* ignore_grid,`
	`748`	`+ std::vector<std::unique_ptr<Shape>>& replacements) const`
`747`	`749`	`{`
`748`	`750`	`return Shape::cut(`
`749`	`751`	`obstructions, replacements, [](const ShapePtr& other) -> bool {`