Merge pull request #9697 from ahmed532/feat/odb-dbTerm-dbChipBump

odb: create dbBTerm::getChipBump

Author: osamahammad21

src/odb/include/odb/db.h

@@ -1546,6 +1546,12 @@ class dbBTerm : public dbObject
   ///
   dbBlock* getBlock() const;
 
+  ///
+  /// Get the chip bump associated with this block-terminal.
+  /// Returns nullptr if no chip bump is associated.
+  ///
+  dbChipBump* getChipBump() const;
+
   ///
   /// Get the hierarchical parent iterm of this bterm.
   ///

src/odb/src/3dblox/3dblox.cpp

@@ -114,25 +114,6 @@ void ThreeDBlox::buildChipNetsFromVerilog(dbChip* chip, const DbxData& data)
     return;
   }
 
-  // Pre-process master chips to map port names to bumps
-  std::map<dbChip*, std::map<std::string, dbChipBump*>> master_bump_map;
-  for (auto* inst : chip->getChipInsts()) {
-    dbChip* master = inst->getMasterChip();
-
-    // Skip if already processed
-    if (master_bump_map.contains(master)) {
-      continue;
-    }
-
-    for (auto* region : master->getChipRegions()) {
-      for (auto* bump : region->getChipBumps()) {
-        if (auto* bterm = bump->getBTerm()) {
-          master_bump_map[master][bterm->getName()] = bump;
-        }
-      }
-    }
-  }
-
   // Process nets
   std::unique_ptr<sta::NetIterator> net_iter(
       temp_network.netIterator(top_inst));
@@ -167,12 +148,14 @@ void ThreeDBlox::buildChipNetsFromVerilog(dbChip* chip, const DbxData& data)
       const char* port_name = temp_network.name(temp_network.port(pin));
       dbChip* master = chip_inst->getMasterChip();
 
-      auto bump_it = master_bump_map[master].find(port_name);
-      if (bump_it == master_bump_map[master].end()) {
+      dbBTerm* bterm = master->getBlock()->findBTerm(port_name);
+      if (!bterm) {
+        continue;
+      }
+      dbChipBump* bump = bterm->getChipBump();
+      if (!bump) {
         continue;
       }
-
-      dbChipBump* bump = bump_it->second;
       auto* region_inst = chip_inst->findChipRegionInst(bump->getChipRegion());
       if (!region_inst) {
         continue;

src/odb/src/db/dbBTerm.cpp

@@ -15,6 +15,8 @@
 #include "dbBox.h"
 #include "dbBoxItr.h"
 #include "dbChip.h"
+#include "dbChipBump.h"
+#include "dbChipRegion.h"
 #include "dbCommon.h"
 #include "dbCore.h"
 #include "dbDatabase.h"
@@ -74,7 +76,9 @@ _dbBTerm::_dbBTerm(_dbDatabase*, const _dbBTerm& b)
       ground_pin_(b.ground_pin_),
       supply_pin_(b.supply_pin_),
       sta_vertex_id_(0),
-      constraint_region_(b.constraint_region_)
+      constraint_region_(b.constraint_region_),
+      chip_region_(b.chip_region_),
+      chip_bump_(b.chip_bump_)
 {
   if (b.name_) {
     name_ = safe_strdup(b.name_);
@@ -159,6 +163,14 @@ bool _dbBTerm::operator==(const _dbBTerm& rhs) const
     return false;
   }
 
+  if (chip_region_ != rhs.chip_region_) {
+    return false;
+  }
+
+  if (chip_bump_ != rhs.chip_bump_) {
+    return false;
+  }
+
   return true;
 }
 
@@ -183,6 +195,8 @@ dbOStream& operator<<(dbOStream& stream, const _dbBTerm& bterm)
   stream << bterm.constraint_region_;
   stream << bterm.mirrored_bterm_;
   stream << bterm.is_mirrored_;
+  stream << bterm.chip_region_;
+  stream << bterm.chip_bump_;
 
   return stream;
 }
@@ -218,6 +232,10 @@ dbIStream& operator>>(dbIStream& stream, _dbBTerm& bterm)
   if (bterm.getDatabase()->isSchema(kSchemaBtermIsMirrored)) {
     stream >> bterm.is_mirrored_;
   }
+  if (bterm.getDatabase()->isSchema(kSchemaBtermChipBump)) {
+    stream >> bterm.chip_region_;
+    stream >> bterm.chip_bump_;
+  }
 
   return stream;
 }
@@ -508,6 +526,18 @@ dbBlock* dbBTerm::getBlock() const
   return (dbBlock*) getImpl()->getOwner();
 }
 
+dbChipBump* dbBTerm::getChipBump() const
+{
+  const _dbBTerm* obj = (const _dbBTerm*) this;
+  if (obj->chip_bump_ == 0) {
+    return nullptr;
+  }
+  _dbBlock* block = (_dbBlock*) getImpl()->getOwner();
+  _dbChip* chip = (_dbChip*) block->getOwner();
+  _dbChipRegion* region = chip->chip_region_tbl_->getPtr(obj->chip_region_);
+  return (dbChipBump*) region->chip_bump_tbl_->getPtr(obj->chip_bump_);
+}
+
 Rect dbBTerm::getBBox()
 {
   Rect bbox;

src/odb/src/db/dbBTerm.h

@@ -20,6 +20,8 @@ class _dbBlock;
 class _dbBPin;
 class _dbITerm;
 class _dbDatabase;
+class _dbChipRegion;
+class _dbChipBump;
 class dbIStream;
 class dbOStream;
 
@@ -81,6 +83,8 @@ class _dbBTerm : public _dbObject
   Rect constraint_region_;
   dbId<_dbBTerm> mirrored_bterm_;
   bool is_mirrored_;
+  dbId<_dbChipRegion> chip_region_;
+  dbId<_dbChipBump> chip_bump_;
 };
 
 dbOStream& operator<<(dbOStream& stream, const _dbBTerm& bterm);

src/odb/src/db/dbChipBump.cpp

@@ -138,6 +138,9 @@ void dbChipBump::setBTerm(dbBTerm* bterm)
 {
   _dbChipBump* obj = (_dbChipBump*) this;
   obj->bterm_ = bterm->getId();
+  _dbBTerm* _bterm = (_dbBTerm*) bterm;
+  _bterm->chip_region_ = obj->chip_region_;
+  _bterm->chip_bump_ = obj->getOID();
 }
 
 dbChipBump* dbChipBump::create(dbChipRegion* chip_region, dbInst* inst)

src/odb/src/db/dbDatabase.h

@@ -50,7 +50,10 @@ namespace odb {
 inline constexpr uint32_t kSchemaMajor = 0;  // Not used...
 inline constexpr uint32_t kSchemaInitial = 57;
 
-inline constexpr uint32_t kSchemaMinor = 126;  // Current revision number
+inline constexpr uint32_t kSchemaMinor = 127;  // Current revision number
+
+// Revision where chip_bump_ back-reference was added to dbBTerm
+inline constexpr uint32_t kSchemaBtermChipBump = 127;
 
 // Revision where dbTechLayer::wrong_way_min_width_ was added
 inline constexpr uint32_t kSchemaTechLayerMinWidthWrongway = 126;

src/odb/test/cpp/Test3DBloxParser.cpp

@@ -389,5 +389,51 @@ TEST_F(SimpleDbFixture, test_bump_map_reader_no_bterms)
   EXPECT_THROW(parser.readBMap(path), std::runtime_error);
 }
 
+TEST_F(SimpleDbFixture, test_bterm_get_chip_bump)
+{
+  createSimpleDB();
+
+  dbChip* chip = db_->getChip();
+  dbBlock* block = chip->getBlock();
+
+  // Create a chip region on the chip
+  dbChipRegion* region = dbChipRegion::create(
+      chip, "bump_region", dbChipRegion::Side::BACK, nullptr);
+  ASSERT_NE(region, nullptr);
+
+  // Create an inst to back the bump
+  dbLib* lib = db_->findLib("lib1");
+  dbMaster* bump_master = dbMaster::create(lib, "BUMP_CELL");
+  bump_master->setType(dbMasterType::COVER_BUMP);
+  bump_master->setFrozen();
+  dbInst* bump_inst = dbInst::create(block, bump_master, "bump1");
+  ASSERT_NE(bump_inst, nullptr);
+
+  // Create a chip bump
+  dbChipBump* bump = dbChipBump::create(region, bump_inst);
+  ASSERT_NE(bump, nullptr);
+
+  // Create bterms: one that will be associated with the bump, one that won't
+  dbBTerm* sig1 = dbBTerm::create(dbNet::create(block, "SIG1"), "SIG1");
+  dbBTerm* sig2 = dbBTerm::create(dbNet::create(block, "SIG2"), "SIG2");
+  ASSERT_NE(sig1, nullptr);
+  ASSERT_NE(sig2, nullptr);
+
+  // Before setBTerm: both bterms return nullptr for getChipBump
+  EXPECT_EQ(sig1->getChipBump(), nullptr);
+  EXPECT_EQ(sig2->getChipBump(), nullptr);
+
+  // Associate sig1 with the bump
+  bump->setBTerm(sig1);
+
+  // After setBTerm: sig1 returns the bump, sig2 still returns nullptr
+  EXPECT_EQ(sig1->getChipBump(), bump);
+  EXPECT_EQ(sig2->getChipBump(), nullptr);
+
+  // Verify the reverse link is also consistent
+  EXPECT_EQ(bump->getBTerm(), sig1);
+  EXPECT_EQ(bump->getChipRegion(), region);
+}
+
 }  // namespace
 }  // namespace odb

src/odb/test/cpp/TestChips.cpp

@@ -1,4 +1,7 @@
 #include <exception>
+#include <filesystem>
+#include <fstream>
+#include <ios>
 #include <set>
 #include <vector>
 
@@ -343,10 +346,14 @@ TEST_F(ChipHierarchyFixture, test_chip_bumps)
   EXPECT_EQ(io_bump->getBTerm(), nullptr);
   dbNet* net = dbNet::create(io_chip->getBlock(), "net1");
   dbBTerm* bterm = dbBTerm::create(net, "bterm1");
+  // Before setBTerm, getChipBump returns nullptr
+  EXPECT_EQ(bterm->getChipBump(), nullptr);
   io_bump->setNet(net);
   io_bump->setBTerm(bterm);
   EXPECT_EQ(io_bump->getNet(), net);
   EXPECT_EQ(io_bump->getBTerm(), bterm);
+  // After setBTerm, getChipBump returns the bump (back-reference)
+  EXPECT_EQ(bterm->getChipBump(), io_bump);
 
   EXPECT_EQ(io_chip_region_r1->getChipBumps().size(), 1);
   EXPECT_EQ(*io_chip_region_r1->getChipBumps().begin(), io_bump);
@@ -389,5 +396,67 @@ TEST_F(ChipHierarchyFixture, test_chip_bumps)
   EXPECT_THROW(dbChipBump::create(io_chip_region_r1, io_cell), std::exception);
 }
 
+TEST_F(SimpleDbFixture, test_chip_bump_bterm_serialization)
+{
+  createSimpleDB();
+
+  dbChip* chip = db_->getChip();
+  dbBlock* block = chip->getBlock();
+
+  // Create a chip region and a bump backed by an inst
+  dbChipRegion* region = dbChipRegion::create(
+      chip, "bump_region", dbChipRegion::Side::BACK, nullptr);
+  dbLib* lib = db_->findLib("lib1");
+  dbMaster* bump_master = dbMaster::create(lib, "BUMP_CELL");
+  bump_master->setType(dbMasterType::COVER_BUMP);
+  bump_master->setFrozen();
+  dbInst* bump_inst = dbInst::create(block, bump_master, "bump1");
+  dbChipBump* bump = dbChipBump::create(region, bump_inst);
+  ASSERT_NE(bump, nullptr);
+
+  // Associate a bterm with the bump
+  dbBTerm* bterm = dbBTerm::create(dbNet::create(block, "SIG1"), "SIG1");
+  bump->setBTerm(bterm);
+  ASSERT_EQ(bterm->getChipBump(), bump);
+
+  // Write the database to a temp file
+  std::filesystem::create_directory("results");
+  const std::string tmp_path = "results/test_chip_bump_bterm_serialization.odb";
+  {
+    std::ofstream out;
+    out.exceptions(std::ifstream::failbit | std::ifstream::badbit
+                   | std::ios::eofbit);
+    out.open(tmp_path, std::ios::binary);
+    db_->write(out);
+  }
+
+  // Read it back into a fresh database
+  dbDatabase* db2 = dbDatabase::create();
+  {
+    std::ifstream in;
+    in.exceptions(std::ifstream::failbit | std::ifstream::badbit
+                  | std::ios::eofbit);
+    in.open(tmp_path, std::ios::binary);
+    db2->read(in);
+  }
+
+  // Locate the deserialized objects
+  dbBlock* block2 = db2->getChip()->getBlock();
+  ASSERT_NE(block2, nullptr);
+
+  dbBTerm* bterm2 = block2->findBTerm("SIG1");
+  ASSERT_NE(bterm2, nullptr);
+
+  dbChipRegion* region2 = db2->getChip()->findChipRegion("bump_region");
+  ASSERT_NE(region2, nullptr);
+  ASSERT_EQ(region2->getChipBumps().size(), 1);
+  dbChipBump* bump2 = *region2->getChipBumps().begin();
+  ASSERT_NE(bump2, nullptr);
+
+  // Verify the back-reference survived serialization
+  EXPECT_EQ(bterm2->getChipBump(), bump2);
+  EXPECT_EQ(bump2->getBTerm(), bterm2);
+}
+
 }  // namespace
 }  // namespace odb