Merge pull request #8230 from osamahammad21/odb-chip-maps

odb: name mapping for chip objects

Author: maliberty

src/odb/include/odb/db.h

@@ -7020,6 +7020,10 @@ class dbChip : public dbObject
 
   dbSet<dbChipNet> getChipNets() const;
 
+  dbChipInst* findChipInst(const std::string& name) const;
+
+  dbChipRegion* findChipRegion(const std::string& name) const;
+
   ///
   /// Create a new chip.
   /// Returns nullptr if there is no database technology.
@@ -7129,6 +7133,10 @@ class dbChipInst : public dbObject
 
   dbSet<dbChipRegionInst> getRegions() const;
 
+  dbChipRegionInst* findChipRegionInst(dbChipRegion* chip_region) const;
+
+  dbChipRegionInst* findChipRegionInst(const std::string& name) const;
+
   static odb::dbChipInst* create(dbChip* parent_chip,
                                  dbChip* master_chip,
                                  const std::string& name);

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

@@ -160,6 +160,16 @@
       "type": "dbId<_dbChipNet>",
       "flags": ["private"],
       "schema": "db_schema_chip_bump"
+    },
+    {
+      "name": "chipinsts_map_",
+      "type": "std::unordered_map<std::string, dbId<_dbChipInst>>",
+      "flags": ["private", "no-serial"]
+    },
+    {
+      "name": "chip_region_map_",
+      "type": "std::unordered_map<std::string, dbId<_dbChipRegion>>",
+      "flags": ["private", "no-serial"]
     }
   ],
   "declared_classes": ["dbPropertyItr", "_dbNameCache","dbBlockItr"],

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

@@ -39,6 +39,11 @@
       "type":"dbId<_dbChipRegionInst>",
       "flags":["private"],
       "schema":"db_schema_chip_region"
+    },
+    {
+      "name":"region_insts_map_",
+      "type":"std::unordered_map<dbId<_dbChipRegion>, dbId<_dbChipRegionInst>>",
+      "flags":["private", "no-serial", "no-template"]
     }
   ],
   "h_includes": [

src/odb/src/db/dbChip.cpp

@@ -4,6 +4,9 @@
 // Generator Code Begin Cpp
 #include "dbChip.h"
 
+#include <string>
+#include <unordered_map>
+
 #include "dbBlock.h"
 #include "dbBlockItr.h"
 #include "dbChipConn.h"
@@ -223,6 +226,10 @@ dbIStream& operator>>(dbIStream& stream, _dbChip& obj)
   if (obj.getDatabase()->isSchema(db_schema_chip_hash_table)) {
     stream >> obj._next_entry;
   }
+  auto chip = (dbChip*) &obj;
+  for (const auto& chip_region : chip->getChipRegions()) {
+    obj.chip_region_map_[chip_region->getName()] = chip_region->getId();
+  }
   // User Code End >>
   return stream;
 }
@@ -546,6 +553,27 @@ dbSet<dbChipNet> dbChip::getChipNets() const
   return dbSet<dbChipNet>(chip, db->chip_net_itr_);
 }
 
+dbChipInst* dbChip::findChipInst(const std::string& name) const
+{
+  _dbChip* chip = (_dbChip*) this;
+  auto it = chip->chipinsts_map_.find(name);
+  if (it != chip->chipinsts_map_.end()) {
+    auto db = (_dbDatabase*) chip->getOwner();
+    return (dbChipInst*) db->chip_inst_tbl_->getPtr((*it).second);
+  }
+  return nullptr;
+}
+
+dbChipRegion* dbChip::findChipRegion(const std::string& name) const
+{
+  _dbChip* chip = (_dbChip*) this;
+  auto it = chip->chip_region_map_.find(name);
+  if (it != chip->chip_region_map_.end()) {
+    return (dbChipRegion*) chip->chip_region_tbl_->getPtr((*it).second);
+  }
+  return nullptr;
+}
+
 dbChip* dbChip::create(dbDatabase* db_, const std::string& name, ChipType type)
 {
   _dbDatabase* db = (_dbDatabase*) db_;

src/odb/src/db/dbChip.h

@@ -4,6 +4,9 @@
 // Generator Code Begin Header
 #pragma once
 
+#include <string>
+#include <unordered_map>
+
 #include "dbCore.h"
 #include "odb/geom.h"
 #include "odb/odb.h"
@@ -60,6 +63,8 @@ class _dbChip : public _dbObject
   dbId<_dbChipInst> chipinsts_;
   dbId<_dbChipConn> conns_;
   dbId<_dbChipNet> nets_;
+  std::unordered_map<std::string, dbId<_dbChipInst>> chipinsts_map_;
+  std::unordered_map<std::string, dbId<_dbChipRegion>> chip_region_map_;
   dbTable<_dbProperty>* _prop_tbl;
   dbTable<_dbChipRegion>* chip_region_tbl_;
   dbId<_dbChip> _next_entry;

src/odb/src/db/dbChipInst.cpp

@@ -5,6 +5,7 @@
 #include "dbChipInst.h"
 
 #include <string>
+#include <unordered_map>
 
 #include "dbDatabase.h"
 #include "dbTable.h"
@@ -161,6 +162,26 @@ dbSet<dbChipRegionInst> dbChipInst::getRegions() const
   return dbSet<dbChipRegionInst>(_chipinst, _db->chip_region_inst_itr_);
 }
 
+dbChipRegionInst* dbChipInst::findChipRegionInst(
+    dbChipRegion* chip_region) const
+{
+  if (chip_region == nullptr) {
+    return nullptr;
+  }
+  _dbChipInst* obj = (_dbChipInst*) this;
+  auto it = obj->region_insts_map_.find(chip_region->getId());
+  if (it != obj->region_insts_map_.end()) {
+    auto db = (_dbDatabase*) obj->getOwner();
+    return (dbChipRegionInst*) db->chip_region_inst_tbl_->getPtr((*it).second);
+  }
+  return nullptr;
+}
+
+dbChipRegionInst* dbChipInst::findChipRegionInst(const std::string& name) const
+{
+  return findChipRegionInst(getMasterChip()->findChipRegion(name));
+}
+
 dbChipInst* dbChipInst::create(dbChip* parent_chip,
                                dbChip* master_chip,
                                const std::string& name)
@@ -183,6 +204,13 @@ dbChipInst* dbChipInst::create(dbChip* parent_chip,
     db->getLogger()->error(
         utl::ODB, 507, "Cannot create chip instance {} in itself", name);
   }
+  if (parent_chip->findChipInst(name) != nullptr) {
+    db->getLogger()->error(utl::ODB,
+                           514,
+                           "Chip instance {} already exists in parent chip {}",
+                           name,
+                           parent_chip->getName());
+  }
 
   // Create a new chip instance
   _dbChipInst* chipinst = db->chip_inst_tbl_->create();
@@ -198,6 +226,7 @@ dbChipInst* dbChipInst::create(dbChip* parent_chip,
   // Link the chip instance to the parent chip's linked list
   chipinst->chipinst_next_ = _parent->chipinsts_;
   _parent->chipinsts_ = chipinst->getOID();
+  _parent->chipinsts_map_[name] = chipinst->getOID();
 
   // create chipRegionInsts
   for (auto region : master_chip->getChipRegions()) {
@@ -206,6 +235,7 @@ dbChipInst* dbChipInst::create(dbChip* parent_chip,
     regioninst->parent_chipinst_ = chipinst->getOID();
     regioninst->chip_region_inst_next_ = chipinst->chip_region_insts_;
     chipinst->chip_region_insts_ = regioninst->getOID();
+    chipinst->region_insts_map_[region->getId()] = regioninst->getOID();
     // create chipBumpInsts
     for (auto bump : region->getChipBumps()) {
       _dbChipBumpInst* bumpinst = db->chip_bump_inst_tbl_->create();
@@ -245,6 +275,7 @@ void dbChipInst::destroy(dbChipInst* chipInst)
   }
   // Get parent chip
   _dbChip* parent = db->chip_tbl_->getPtr(inst->parent_chip_);
+  parent->chipinsts_map_.erase(inst->name_);
 
   // Remove from parent's linked list
   if (parent->chipinsts_ == inst->getOID()) {

src/odb/src/db/dbChipInst.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <string>
+#include <unordered_map>
 
 #include "dbCore.h"
 #include "odb/dbTypes.h"
@@ -17,6 +18,9 @@ class dbOStream;
 class _dbDatabase;
 class _dbChip;
 class _dbChipRegionInst;
+// User Code Begin Classes
+class _dbChipRegion;
+// User Code End Classes
 
 class _dbChipInst : public _dbObject
 {
@@ -35,6 +39,8 @@ class _dbChipInst : public _dbObject
   dbId<_dbChip> parent_chip_;
   dbId<_dbChipInst> chipinst_next_;
   dbId<_dbChipRegionInst> chip_region_insts_;
+  std::unordered_map<dbId<_dbChipRegion>, dbId<_dbChipRegionInst>>
+      region_insts_map_;
 };
 dbIStream& operator>>(dbIStream& stream, _dbChipInst& obj);
 dbOStream& operator<<(dbOStream& stream, const _dbChipInst& obj);

src/odb/src/db/dbChipRegion.cpp

@@ -186,11 +186,20 @@ dbChipRegion* dbChipRegion::create(dbChip* chip,
                     layer->getName());
     }
   }
+  if (chip->findChipRegion(name) != nullptr) {
+    logger->error(
+        utl::ODB,
+        520,
+        "Cannot create chip region {} for chip {} because chip region "
+        "already exists",
+        name,
+        chip->getName());
+  }
   _dbTechLayer* _layer = (_dbTechLayer*) layer;
 
   // Create a new chip region
   _dbChipRegion* chip_region = _chip->chip_region_tbl_->create();
-
+  _chip->chip_region_map_[name] = chip_region->getOID();
   // Initialize the chip region
   chip_region->name_ = name;
   chip_region->side_ = static_cast<uint8_t>(side);

src/odb/src/db/dbDatabase.cpp

@@ -301,6 +301,19 @@ dbIStream& operator>>(dbIStream& stream, _dbDatabase& obj)
   // Set the revision of the database to the current revision
   obj._schema_major = db_schema_major;
   obj._schema_minor = db_schema_minor;
+
+  // Set the chipinsts_map_ of the chip
+  dbDatabase* db = (dbDatabase*) &obj;
+  for (const auto& inst : db->getChipInsts()) {
+    _dbChip* parent_chip = (_dbChip*) inst->getParentChip();
+    parent_chip->chipinsts_map_[inst->getName()] = inst->getId();
+  }
+  // Set the region_insts_map_ of the chipinst
+  for (const auto& chip_region_inst : db->getChipRegionInsts()) {
+    _dbChipInst* chipinst = (_dbChipInst*) chip_region_inst->getChipInst();
+    chipinst->region_insts_map_[chip_region_inst->getChipRegion()->getId()]
+        = chip_region_inst->getId();
+  }
   // User Code End >>
   return stream;
 }

src/odb/test/cpp/TestChips.cpp

@@ -136,6 +136,12 @@ BOOST_FIXTURE_TEST_CASE(test_chip_creation, F_CHIP_HIERARCHY)
   BOOST_TEST(db->getChips().size() == 4);
   BOOST_TEST(db->findChip("cpu_chip") == nullptr);
   BOOST_TEST(db->getChip() == nullptr);
+  try {
+    dbChipInst::create(system_chip, cpu_chip, "cpu_inst");
+    BOOST_TEST(false);
+  } catch (const std::exception& e) {
+    BOOST_TEST(true);
+  }
 }
 
 BOOST_FIXTURE_TEST_CASE(test_chip_hierarchy, F_CHIP_HIERARCHY)
@@ -170,6 +176,9 @@ BOOST_FIXTURE_TEST_CASE(test_chip_hierarchy, F_CHIP_HIERARCHY)
   BOOST_TEST(memory_inst->getParentChip() == system_chip);
   BOOST_TEST(io_inst->getParentChip() == system_chip);
   BOOST_TEST(cache_inst->getParentChip() == cpu_chip);
+  BOOST_TEST(system_chip->findChipInst("cpu_inst") == cpu_inst);
+  BOOST_TEST(cpu_chip->findChipInst("cache_inst") == cache_inst);
+  BOOST_TEST(system_chip->findChipInst("cache_inst") == nullptr);
 
   // Verify master relationships
   BOOST_TEST(cpu_inst->getMasterChip() == cpu_chip);
@@ -222,7 +231,10 @@ BOOST_FIXTURE_TEST_CASE(test_chip_complex_destroy, F_CHIP_HIERARCHY)
   BOOST_TEST(db->getChipBumpInsts().size() == 0);
   BOOST_TEST(db->getChipRegionInsts().size() == 0);
   BOOST_TEST(system_chip->getChipInsts().size() == 0);
+  BOOST_TEST(system_chip->findChipInst("cpu_inst") == nullptr);
+  BOOST_TEST(system_chip->findChipInst("io_inst") == nullptr);
 }
+
 BOOST_FIXTURE_TEST_CASE(test_chip_regions, F_CHIP_HIERARCHY)
 {
   auto iterateChipRegions = [](dbChip* chip,
@@ -248,6 +260,20 @@ BOOST_FIXTURE_TEST_CASE(test_chip_regions, F_CHIP_HIERARCHY)
   BOOST_TEST(
       (memory_chip_region_r3->getSide() == dbChipRegion::Side::INTERNAL));
   BOOST_TEST(memory_chip_region_r3->getLayer() == nullptr);
+  // Test dbChip::findChipRegion
+  BOOST_TEST(memory_chip->findChipRegion("R1") == memory_chip_region_r1);
+  BOOST_TEST(memory_chip->findChipRegion("R2") == memory_chip_region_r2);
+  BOOST_TEST(memory_chip->findChipRegion("R3") == memory_chip_region_r3);
+  BOOST_TEST(memory_chip->findChipRegion("R4") == nullptr);
+  // Test dbChipInst::findChipRegionInst
+  BOOST_TEST(memory_inst->findChipRegionInst("R1")->getChipRegion()
+             == memory_chip_region_r1);
+  BOOST_TEST(memory_inst->findChipRegionInst("R2")->getChipRegion()
+             == memory_chip_region_r2);
+  BOOST_TEST(memory_inst->findChipRegionInst("R3")->getChipRegion()
+             == memory_chip_region_r3);
+  BOOST_TEST(memory_inst->findChipRegionInst("R4") == nullptr);
+
   iterateChipRegions(memory_chip, {"R1", "R2", "R3"});
   iterateChipRegionInsts(memory_inst, {"R1", "R2", "R3"});
   iterateChipRegions(io_chip, {"R1"});