odb: dbChipConnItr

Signed-off-by: Osama <[email protected]>

Author: osamahammad21

src/odb/include/odb/db.h

@@ -7010,6 +7010,8 @@ class dbChip : public dbObject
 
   dbSet<dbChipInst> getChipInsts() const;
 
+  dbSet<dbChipConn> getChipConns() const;
+
   ///
   /// Create a new chip.
   /// Returns nullptr if there is no database technology.
@@ -7041,6 +7043,8 @@ class dbChipConn : public dbObject
 
   // User Code Begin dbChipConn
 
+  dbChip* getParentChip() const;
+
   dbChipRegionInst* getTopRegion() const;
 
   dbChipRegionInst* getBottomRegion() const;
@@ -7050,10 +7054,11 @@ class dbChipConn : public dbObject
   std::vector<dbChipInst*> getBottomRegionPath() const;
 
   static dbChipConn* create(const std::string& name,
-                            dbChipRegionInst* top_region,
-                            dbChipRegionInst* bottom_region,
+                            dbChip* parent_chip,
                             std::vector<dbChipInst*> top_region_path,
-                            std::vector<dbChipInst*> bottom_region_path);
+                            dbChipRegionInst* top_region,
+                            std::vector<dbChipInst*> bottom_region_path,
+                            dbChipRegionInst* bottom_region);
 
   static void destroy(dbChipConn* chipConn);
   // User Code End dbChipConn

src/odb/src/codeGenerator/schema.json

@@ -180,6 +180,15 @@
       "orderReversed": "true",
       "sequential": 0,
       "includes": ["dbChipInst.h", "dbChip.h"]
+    },
+    {
+      "name": "dbChipConnItr",
+      "parentObject": "dbChipConn",
+      "tableName": "chip_conn_tbl",
+      "reversible": "true",
+      "orderReversed": "true",
+      "sequential": 0,
+      "includes": ["dbChipConn.h", "dbChip.h"]
     }
   ],
   "relations":[

src/odb/src/codeGenerator/schema/chip/dbChip.json

@@ -148,6 +148,12 @@
       "type": "dbId<_dbChipInst>",
       "flags": ["private"],
       "schema":"db_schema_chip_inst"
+    },
+    {
+      "name": "conns_",
+      "type": "dbId<_dbChipConn>",
+      "flags": ["private"],
+      "schema": "db_schema_chip_region"
     }
   ],
   "declared_classes": ["dbPropertyItr", "_dbNameCache","dbBlockItr"],
@@ -161,6 +167,7 @@
     "dbBlockItr.h", 
     "dbBlock.h", 
     "dbTech.h", 
-    "dbPropertyItr.h"
+    "dbPropertyItr.h",
+    "dbChipConn.h"
   ]
 } 

src/odb/src/codeGenerator/schema/chip/dbChipConn.json

@@ -4,6 +4,8 @@
   "fields": [
     { "name": "name_", "type": "std::string", "flags": ["no-set"] },
     { "name": "thickness_", "type": "int", "flags": [] },
+    { "name": "chip_", "type": "dbId<_dbChip>", "flags": ["private"] },
+    { "name": "chip_conn_next_", "type": "dbId<_dbChipConn>", "flags": ["private"] },
     { "name": "top_region_", "type": "dbId<_dbChipRegionInst>", "flags": ["private"] },
     { "name": "top_region_path_", "type": "std::vector<dbId<_dbChipInst>>", "flags": ["private"] },
     { "name": "bottom_region_", "type": "dbId<_dbChipRegionInst>", "flags": ["private"] },

src/odb/src/db/CMakeLists.txt

@@ -148,6 +148,7 @@ add_library(db
     dbTechLayerTwoWiresForbiddenSpcRule.cpp
     dbTechLayerWidthTableRule.cpp
     dbTechLayerWrongDirSpacingRule.cpp
+    dbChipConnItr.cpp
     dbChipInstItr.cpp
     dbChipRegionInstItr.cpp
     dbGroupInstItr.cpp

src/odb/src/db/dbChip.cpp

@@ -6,6 +6,7 @@
 
 #include "dbBlock.h"
 #include "dbBlockItr.h"
+#include "dbChipConn.h"
 #include "dbChipRegion.h"
 #include "dbDatabase.h"
 #include "dbNameCache.h"
@@ -17,6 +18,7 @@
 #include "odb/db.h"
 #include "odb/dbSet.h"
 // User Code Begin Includes
+#include "dbChipConnItr.h"
 #include "dbChipInst.h"
 #include "dbChipInstItr.h"
 // User Code End Includes
@@ -79,6 +81,9 @@ bool _dbChip::operator==(const _dbChip& rhs) const
   if (chipinsts_ != rhs.chipinsts_) {
     return false;
   }
+  if (conns_ != rhs.conns_) {
+    return false;
+  }
   if (*_prop_tbl != *rhs._prop_tbl) {
     return false;
   }
@@ -197,6 +202,9 @@ dbIStream& operator>>(dbIStream& stream, _dbChip& obj)
   if (obj.getDatabase()->isSchema(db_schema_chip_inst)) {
     stream >> obj.chipinsts_;
   }
+  if (obj.getDatabase()->isSchema(db_schema_chip_region)) {
+    stream >> obj.conns_;
+  }
   if (obj.getDatabase()->isSchema(db_schema_chip_region)) {
     stream >> *obj.chip_region_tbl_;
   }
@@ -232,6 +240,7 @@ dbOStream& operator<<(dbOStream& stream, const _dbChip& obj)
   stream << obj.tsv_;
   stream << obj._top;
   stream << obj.chipinsts_;
+  stream << obj.conns_;
   stream << *obj.chip_region_tbl_;
   // User Code Begin <<
   stream << *obj._block_tbl;
@@ -514,6 +523,13 @@ dbSet<dbChipInst> dbChip::getChipInsts() const
   return dbSet<dbChipInst>(chip, db->chip_inst_itr_);
 }
 
+dbSet<dbChipConn> dbChip::getChipConns() const
+{
+  _dbChip* chip = (_dbChip*) this;
+  _dbDatabase* db = (_dbDatabase*) chip->getOwner();
+  return dbSet<dbChipConn>(chip, db->chip_conn_itr_);
+}
+
 dbChip* dbChip::create(dbDatabase* db_, const std::string& name, ChipType type)
 {
   _dbDatabase* db = (_dbDatabase*) db_;
@@ -541,6 +557,11 @@ void dbChip::destroy(dbChip* chip_)
   for (dbChipRegion* chipRegion : chipRegions) {
     dbChipRegion::destroy(chipRegion);
   }
+  // Destroy chip connections
+  dbSet<dbChipConn> chipConns = chip_->getChipConns();
+  for (dbChipConn* chipConn : chipConns) {
+    dbChipConn::destroy(chipConn);
+  }
   // Destroy chip
   _dbDatabase* db = chip->getDatabase();
   if (db->_chip == chip->getOID()) {

src/odb/src/db/dbChip.h

@@ -19,6 +19,7 @@ class _dbProperty;
 class _dbChipRegion;
 class _dbBlock;
 class _dbChipInst;
+class _dbChipConn;
 
 class _dbChip : public _dbObject
 {
@@ -56,6 +57,7 @@ class _dbChip : public _dbObject
   dbBlockItr* _block_itr;
   dbPropertyItr* _prop_itr;
   dbId<_dbChipInst> chipinsts_;
+  dbId<_dbChipConn> conns_;
   dbTable<_dbProperty>* _prop_tbl;
   dbTable<_dbChipRegion>* chip_region_tbl_;
   dbId<_dbChip> _next_entry;

src/odb/src/db/dbChipConn.cpp

@@ -26,6 +26,12 @@ bool _dbChipConn::operator==(const _dbChipConn& rhs) const
   if (thickness_ != rhs.thickness_) {
     return false;
   }
+  if (chip_ != rhs.chip_) {
+    return false;
+  }
+  if (chip_conn_next_ != rhs.chip_conn_next_) {
+    return false;
+  }
   if (top_region_ != rhs.top_region_) {
     return false;
   }
@@ -49,6 +55,8 @@ dbIStream& operator>>(dbIStream& stream, _dbChipConn& obj)
 {
   stream >> obj.name_;
   stream >> obj.thickness_;
+  stream >> obj.chip_;
+  stream >> obj.chip_conn_next_;
   stream >> obj.top_region_;
   stream >> obj.top_region_path_;
   stream >> obj.bottom_region_;
@@ -60,6 +68,8 @@ dbOStream& operator<<(dbOStream& stream, const _dbChipConn& obj)
 {
   stream << obj.name_;
   stream << obj.thickness_;
+  stream << obj.chip_;
+  stream << obj.chip_conn_next_;
   stream << obj.top_region_;
   stream << obj.top_region_path_;
   stream << obj.bottom_region_;
@@ -99,6 +109,14 @@ int dbChipConn::getThickness() const
 }
 
 // User Code Begin dbChipConnPublicMethods
+
+dbChip* dbChipConn::getParentChip() const
+{
+  _dbChipConn* obj = (_dbChipConn*) this;
+  _dbDatabase* _db = (_dbDatabase*) obj->getOwner();
+  return (dbChip*) _db->chip_tbl_->getPtr(obj->chip_);
+}
+
 dbChipRegionInst* dbChipConn::getTopRegion() const
 {
   _dbChipConn* obj = (_dbChipConn*) this;
@@ -139,35 +157,89 @@ std::vector<dbChipInst*> dbChipConn::getBottomRegionPath() const
   return bottom_region_path;
 }
 
+std::vector<dbId<_dbChipInst>> extractChipInstsPath(
+    dbChip* parent_chip,
+    std::vector<dbChipInst*> chip_insts)
+{
+  _dbDatabase* _db = (_dbDatabase*) parent_chip->getImpl()->getOwner();
+  utl::Logger* logger = _db->getLogger();
+  std::vector<dbId<_dbChipInst>> chip_insts_path;
+  for (auto chipinst : chip_insts) {
+    if (chipinst->getParentChip() != parent_chip) {
+      logger->error(utl::ODB,
+                    510,
+                    "Cannot create chip connection. ChipInst {} is not a child "
+                    "of chip {}",
+                    chipinst->getName(),
+                    parent_chip->getName());
+    }
+    chip_insts_path.push_back(chipinst->getImpl()->getOID());
+    parent_chip = chipinst->getMasterChip();
+  }
+  return chip_insts_path;
+}
+
 dbChipConn* dbChipConn::create(const std::string& name,
-                               dbChipRegionInst* top_region,
-                               dbChipRegionInst* bottom_region,
+                               dbChip* parent_chip,
                                std::vector<dbChipInst*> top_region_path,
-                               std::vector<dbChipInst*> bottom_region_path)
+                               dbChipRegionInst* top_region,
+                               std::vector<dbChipInst*> bottom_region_path,
+                               dbChipRegionInst* bottom_region)
 {
   _dbDatabase* _db = (_dbDatabase*) top_region->getImpl()->getOwner();
+  if (parent_chip == nullptr || top_region_path.empty()
+      || bottom_region_path.empty() || top_region == nullptr
+      || bottom_region == nullptr) {
+    return nullptr;
+  }
+  if (top_region->getChipInst() != top_region_path.back()) {
+    _db->getLogger()->error(utl::ODB,
+                            511,
+                            "Cannot create chip connection. Top region path "
+                            "does not match top region");
+  }
+  if (bottom_region->getChipInst() != bottom_region_path.back()) {
+    _db->getLogger()->error(utl::ODB,
+                            512,
+                            "Cannot create chip connection. Bottom region path "
+                            "does not match bottom region");
+  }
   _dbChipConn* obj = (_dbChipConn*) _db->chip_conn_tbl_->create();
+  _dbChip* chip = (_dbChip*) parent_chip;
   obj->name_ = name;
   obj->thickness_ = 0;
+  obj->chip_ = chip->getOID();
   obj->top_region_ = top_region->getImpl()->getOID();
   obj->bottom_region_ = bottom_region->getImpl()->getOID();
-  std::vector<dbId<_dbChipInst>> top_region_path_ids;
-  for (auto chipinst : top_region_path) {
-    top_region_path_ids.push_back(chipinst->getImpl()->getOID());
-  }
-  obj->top_region_path_ = top_region_path_ids;
-  std::vector<dbId<_dbChipInst>> bottom_region_path_ids;
-  for (auto chipinst : bottom_region_path) {
-    bottom_region_path_ids.push_back(chipinst->getImpl()->getOID());
-  }
-  obj->bottom_region_path_ = bottom_region_path_ids;
+  obj->top_region_path_ = extractChipInstsPath(parent_chip, top_region_path);
+  obj->bottom_region_path_
+      = extractChipInstsPath(parent_chip, bottom_region_path);
+
+  obj->chip_conn_next_ = chip->conns_;
+  chip->conns_ = obj->getOID();
   return (dbChipConn*) obj;
 }
 
 void dbChipConn::destroy(dbChipConn* chipConn)
 {
   _dbChipConn* obj = (_dbChipConn*) chipConn;
   _dbDatabase* _db = (_dbDatabase*) obj->getOwner();
+  // Remove from chip's list of connections
+  _dbChip* chip = (_dbChip*) chipConn->getParentChip();
+  if (chip->conns_ == obj->getOID()) {
+    chip->conns_ = obj->chip_conn_next_;
+  } else {
+    uint id = chip->conns_;
+    while (id != 0) {
+      _dbChipConn* _chipconn = _db->chip_conn_tbl_->getPtr(id);
+      if (_chipconn->chip_conn_next_ == obj->getOID()) {
+        _chipconn->chip_conn_next_ = obj->chip_conn_next_;
+        break;
+      }
+      id = _chipconn->chip_conn_next_;
+    }
+  }
+  // Destroy the connection
   _db->chip_conn_tbl_->destroy(obj);
 }
 

src/odb/src/db/dbChipConn.h

@@ -15,6 +15,7 @@ namespace odb {
 class dbIStream;
 class dbOStream;
 class _dbDatabase;
+class _dbChip;
 class _dbChipRegionInst;
 class _dbChipInst;
 
@@ -30,6 +31,8 @@ class _dbChipConn : public _dbObject
 
   std::string name_;
   int thickness_;
+  dbId<_dbChip> chip_;
+  dbId<_dbChipConn> chip_conn_next_;
   dbId<_dbChipRegionInst> top_region_;
   std::vector<dbId<_dbChipInst>> top_region_path_;
   dbId<_dbChipRegionInst> bottom_region_;