Merge pull request #8628 from gadfort/core-area

odb: save core area as a polygon

Author: eder-matheus

src/gui/src/renderThread.cpp

@@ -1112,17 +1112,21 @@ void RenderThread::drawBlock(QPainter* painter,
                          viewer_->pixels_per_dbu_,
                          block->getDbUnitsPerMicron());
 
-  // Draw die area, if set
   painter->setPen(QPen(Qt::gray, 0));
   painter->setBrush(QBrush());
-  odb::Polygon die_area = block->getDieAreaPolygon();
+
+  // Draw die area, if set
+  const odb::Polygon die_area = block->getDieAreaPolygon();
 
   if (die_area.getEnclosingRect().area() > 0) {
-    QPolygon die_area_qpoly;
-    for (const odb::Point& point : die_area.getPoints()) {
-      die_area_qpoly << QPoint(point.getX(), point.getY());
-    }
-    painter->drawPolygon(die_area_qpoly);
+    gui_painter.drawPolygon(die_area);
+  }
+
+  // Draw core area, if set
+  const odb::Polygon core_area = block->getCoreAreaPolygon();
+
+  if (core_area.getEnclosingRect().area() > 0) {
+    gui_painter.drawPolygon(core_area);
   }
 
   drawManufacturingGrid(painter, bounds);

src/gui/src/search.cpp

@@ -126,6 +126,11 @@ void Search::inDbBlockSetDieArea(odb::dbBlock* block)
   setTopBlock(block);
 }
 
+void Search::inDbBlockSetCoreArea(odb::dbBlock* block)
+{
+  emit modified();
+}
+
 void Search::inDbRegionAddBox(odb::dbRegion*, odb::dbBox*)
 {
   emit modified();

src/gui/src/search.h

@@ -235,6 +235,7 @@ class Search : public QObject, public odb::dbBlockCallBackObj
   void inDbSWireAddSBox(odb::dbSBox* box) override;
   void inDbSWireRemoveSBox(odb::dbSBox* box) override;
   void inDbBlockSetDieArea(odb::dbBlock* block) override;
+  void inDbBlockSetCoreArea(odb::dbBlock* block) override;
   void inDbBlockageCreate(odb::dbBlockage* blockage) override;
   void inDbBlockageDestroy(odb::dbBlockage* blockage) override;
   void inDbObstructionCreate(odb::dbObstruction* obs) override;

src/ifp/src/InitFloorplan.cc

@@ -709,6 +709,7 @@ void InitFloorplan::makeUniformRows(odb::dbSite* base_site,
     }
     make_rows(site);
   }
+  block_->setCoreArea(block_->computeCoreArea());
 }
 
 int InitFloorplan::getOffset(dbSite* base_hybrid_site,
@@ -831,6 +832,7 @@ void InitFloorplan::makeHybridRows(dbSite* base_hybrid_site,
       make_rows(site);
     }
   }
+  block_->setCoreArea(block_->computeCoreArea());
 }
 
 dbSite* InitFloorplan::findSite(const char* site_name)
@@ -1293,6 +1295,8 @@ void InitFloorplan::makeUniformRowsPolygon(
     y += site_dy;
   }
 
+  block_->setCoreArea(block_->computeCoreArea());
+
   logger_->info(IFP,
                 1002,
                 "Added {} polygon-aware rows for site {}.",

src/odb/include/odb/db.h

@@ -1118,11 +1118,30 @@ class dbBlock : public dbObject
   Polygon getDieAreaPolygon();
 
   ///
-  /// Get the core area. This computes the bbox of the rows
-  /// and is O(#rows) in runtime.
+  /// Compute the core area based on rows
+  ///
+  odb::Polygon computeCoreArea();
+
+  ///
+  /// Set the core area.
+  ///
+  void setCoreArea(const Rect& new_area);
+
+  ///
+  /// Set the core area with polygon. Allows for non-rectangular floorplans
+  ///
+  void setCoreArea(const Polygon& new_area);
+
+  ///
+  /// Get the core area.
   ///
   Rect getCoreArea();
 
+  ///
+  /// Get the core area.
+  ///
+  Polygon getCoreAreaPolygon();
+
   ///
   /// Add region in the die area where IO pins cannot be placed
   ///

src/odb/include/odb/dbBlockCallBackObj.h

@@ -192,6 +192,7 @@ class dbBlockCallBackObj
   virtual void inDbBlockStreamOutAfter(dbBlock*) {}
   virtual void inDbBlockReadNetsBefore(dbBlock*) {}
   virtual void inDbBlockSetDieArea(dbBlock*) {}
+  virtual void inDbBlockSetCoreArea(dbBlock*) {}
 
   // allow ECO client initialization - payam
   virtual dbBlockCallBackObj& operator()() { return *this; }

src/odb/src/db/dbBlock.cpp

@@ -181,6 +181,7 @@ _dbBlock::_dbBlock(_dbDatabase* db)
   _corner_name_list = nullptr;
   _name = nullptr;
   _die_area = Rect(0, 0, 0, 0);
+  _core_area = Rect(0, 0, 0, 0);
   _maxCapNodeId = 0;
   _maxRSegId = 0;
   _maxCCSegId = 0;
@@ -778,6 +779,7 @@ dbOStream& operator<<(dbOStream& stream, const _dbBlock& block)
   stream << block._corner_name_list;
   stream << block._name;
   stream << block._die_area;
+  stream << block._core_area;
   stream << block._blocked_regions_for_pins;
   stream << block._chip;
   stream << block._bbox;
@@ -906,6 +908,9 @@ dbIStream& operator>>(dbIStream& stream, _dbBlock& block)
     stream >> rect;
     block._die_area = rect;
   }
+  if (db->isSchema(db_schema_core_area_is_polygon)) {
+    stream >> block._core_area;
+  }
   if (db->isSchema(db_schema_dbblock_blocked_regions_for_pins)) {
     stream >> block._blocked_regions_for_pins;
   }
@@ -1078,6 +1083,12 @@ dbIStream& operator>>(dbIStream& stream, _dbBlock& block)
     chip->tech_ = old_db_tech;
   }
 
+  if (!db->isSchema(db_schema_core_area_is_polygon)) {
+    // Wait for rows to be available
+    dbBlock* blk = (dbBlock*) (&block);
+    block._core_area = blk->computeCoreArea();
+  }
+
   return stream;
 }
 
@@ -1185,6 +1196,10 @@ bool _dbBlock::operator==(const _dbBlock& rhs) const
     return false;
   }
 
+  if (_core_area != rhs._core_area) {
+    return false;
+  }
+
   if (_chip != rhs._chip) {
     return false;
   }
@@ -2195,6 +2210,21 @@ void dbBlock::getMasters(std::vector<dbMaster*>& masters)
   }
 }
 
+void dbBlock::setCoreArea(const Rect& new_area)
+{
+  setCoreArea(Polygon(new_area));
+}
+
+void dbBlock::setCoreArea(const Polygon& new_area)
+{
+  _dbBlock* block = (_dbBlock*) this;
+
+  block->_core_area = new_area;
+  for (auto callback : block->_callbacks) {
+    callback->inDbBlockSetCoreArea(this);
+  }
+}
+
 void dbBlock::setDieArea(const Rect& new_area)
 {
   _dbBlock* block = (_dbBlock*) this;
@@ -2275,6 +2305,18 @@ Polygon dbBlock::getDieAreaPolygon()
   return block->_die_area;
 }
 
+Rect dbBlock::getCoreArea()
+{
+  _dbBlock* block = (_dbBlock*) this;
+  return block->_core_area.getEnclosingRect();
+}
+
+Polygon dbBlock::getCoreAreaPolygon()
+{
+  _dbBlock* block = (_dbBlock*) this;
+  return block->_core_area;
+}
+
 void dbBlock::addBlockedRegionForPins(const Rect& region)
 {
   _dbBlock* block = (_dbBlock*) this;
@@ -2287,23 +2329,32 @@ const std::vector<Rect>& dbBlock::getBlockedRegionsForPins()
   return block->_blocked_regions_for_pins;
 }
 
-Rect dbBlock::getCoreArea()
+Polygon dbBlock::computeCoreArea()
 {
-  Rect rect;
-  rect.mergeInit();
-
+  std::vector<odb::Rect> rows;
   for (dbRow* row : getRows()) {
     if (row->getSite()->getClass() != odb::dbSiteClass::PAD) {
-      rect.merge(row->getBBox());
+      rows.push_back(row->getBBox());
     }
   }
 
-  if (!rect.isInverted()) {
-    return rect;
+  if (!rows.empty()) {
+    const auto polys = Polygon::merge(rows);
+
+    if (polys.size() > 1) {
+      odb::Rect area;
+      area.mergeInit();
+      for (const auto& row : rows) {
+        area.merge(row);
+      }
+      return area;
+    }
+
+    return polys[0];
   }
 
   // Default to die area if there aren't any rows.
-  return getDieArea();
+  return getDieAreaPolygon();
 }
 
 void dbBlock::setExtmi(void* ext)

src/odb/src/db/dbBlock.h

@@ -162,6 +162,7 @@ class _dbBlock : public _dbObject
   char* _corner_name_list;
   char* _name;
   Polygon _die_area;
+  Polygon _core_area;
   std::vector<Rect> _blocked_regions_for_pins;
   dbId<_dbChip> _chip;
   dbId<_dbBox> _bbox;

src/odb/src/db/dbDatabase.cpp

@@ -913,6 +913,8 @@ void dbDatabase::triggerPostReadLef(dbTech* tech, dbLib* library)
 
 void dbDatabase::triggerPostReadDef(dbBlock* block, const bool floorplan)
 {
+  block->setCoreArea(block->computeCoreArea());
+
   _dbDatabase* db = (_dbDatabase*) this;
   for (dbDatabaseObserver* observer : db->observers_) {
     if (floorplan) {

src/odb/src/db/dbDatabase.h

@@ -48,7 +48,10 @@ namespace odb {
 inline constexpr uint db_schema_major = 0;  // Not used...
 inline constexpr uint db_schema_initial = 57;
 
-inline constexpr uint db_schema_minor = 120;  // Current revision number
+inline constexpr uint db_schema_minor = 121;  // Current revision number
+
+// Revision where core area is stored as a polygon
+inline constexpr uint db_schema_core_area_is_polygon = 121;
 
 // Revision where _dbDatabase::dbu_per_micron_ was added
 inline constexpr uint db_schema_dbu_per_micron = 120;