Merge pull request #8715 from osamahammad21/3dblox-bmap-parser

ODB: Parser bump map

Author: maliberty

src/odb/include/odb/3dblox.h

@@ -22,6 +22,8 @@ class Connection;
 class DesignDef;
 class dbChipRegionInst;
 class dbChipInst;
+class BumpMapEntry;
+class dbChipRegion;
 
 class ThreeDBlox
 {
@@ -37,6 +39,7 @@ class ThreeDBlox
   dbChip* createDesignTopChiplet(const DesignDef& design);
   void createChipInst(const ChipletInst& chip_inst);
   void createConnection(const Connection& connection);
+  void createBump(const BumpMapEntry& entry, dbChipRegion* chip_region);
   dbChipRegionInst* resolvePath(const std::string& path,
                                 std::vector<dbChipInst*>& path_insts);
   void readHeaderIncludes(const std::vector<std::string>& includes);

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

@@ -10,6 +10,7 @@
 #include <string>
 #include <vector>
 
+#include "bmapParser.h"
 #include "dbvParser.h"
 #include "dbxParser.h"
 #include "objects.h"
@@ -206,6 +207,13 @@ void ThreeDBlox::createChiplet(const ChipletDef& chiplet)
 
   chip->setOffset(Point(chiplet.offset.x * db_->getDbuPerMicron(),
                         chiplet.offset.y * db_->getDbuPerMicron()));
+  if (chip->getChipType() != dbChip::ChipType::HIER
+      && chip->getBlock() == nullptr) {
+    // blackbox stage, create block
+    auto block = odb::dbBlock::create(chip, chiplet.name.c_str());
+    block->setDieArea(Rect(0, 0, chip->getWidth(), chip->getHeight()));
+    block->setCoreArea(Rect(0, 0, chip->getWidth(), chip->getHeight()));
+  }
   for (const auto& [_, region] : chiplet.regions) {
     createRegion(region, chip);
   }
@@ -244,7 +252,72 @@ void ThreeDBlox::createRegion(const ChipletRegion& region, dbChip* chip)
               box);
   }
   chip_region->setBox(box);
+  // Read bump map file
+  if (!region.bmap.empty()) {
+    BmapParser parser(logger_);
+    BumpMapData data = parser.parseFile(region.bmap);
+    for (const auto& entry : data.entries) {
+      createBump(entry, chip_region);
+    }
+  }
+}
+
+void ThreeDBlox::createBump(const BumpMapEntry& entry,
+                            dbChipRegion* chip_region)
+{
+  auto chip = chip_region->getChip();
+  auto block = chip->getBlock();
+  auto inst = block->findInst(entry.bump_inst_name.c_str());
+  if (inst == nullptr) {
+    // create inst
+    auto master = db_->findMaster(entry.bump_cell_type.c_str());
+    if (master == nullptr) {
+      logger_->error(utl::ODB,
+                     531,
+                     "3DBV Parser Error: Bump cell type {} not found",
+                     entry.bump_cell_type);
+    }
+    if (master->getLib()->getTech() != chip->getTech()) {
+      logger_->error(utl::ODB,
+                     532,
+                     "3DBV Parser Error: Bump cell type {} is not in the same "
+                     "tech as the chip region {}/{}",
+                     entry.bump_cell_type,
+                     chip->getName(),
+                     chip_region->getName());
+    }
+    inst = dbInst::create(block, master, entry.bump_inst_name.c_str());
+  }
+  auto bump = dbChipBump::create(chip_region, inst);
+  inst->setOrigin(entry.x * db_->getDbuPerMicron(),
+                  entry.y * db_->getDbuPerMicron());
+  inst->setPlacementStatus(dbPlacementStatus::FIRM);
+  if (entry.net_name != "-") {
+    auto net = block->findNet(entry.net_name.c_str());
+    if (net == nullptr) {
+      logger_->error(utl::ODB,
+                     534,
+                     "3DBV Parser Error: Bump net {} not found",
+                     entry.net_name);
+    }
+    bump->setNet(net);
+    inst->getITerms().begin()->connect(net);
+  }
+  if (entry.port_name != "-") {
+    auto bterm = block->findBTerm(entry.port_name.c_str());
+    if (bterm == nullptr) {
+      logger_->error(utl::ODB,
+                     533,
+                     "3DBV Parser Error: Bump port {} not found",
+                     entry.port_name);
+    }
+    bump->setBTerm(bterm);
+    if (bump->getNet()) {
+      bterm->connect(bump->getNet());
+    }
+  }
 }
+
 dbChip* ThreeDBlox::createDesignTopChiplet(const DesignDef& design)
 {
   dbChip* chip

src/odb/src/3dblox/CMakeLists.txt

@@ -5,6 +5,7 @@ find_package(yaml-cpp REQUIRED)
 
 add_library(3dblox
   baseParser.cpp
+  bmapParser.cpp
   dbvParser.cpp
   dbxParser.cpp
   3dblox.cpp

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

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2019-2025, The OpenROAD Authors
+
+#include "bmapParser.h"
+
+#include <exception>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "objects.h"
+#include "utl/Logger.h"
+namespace odb {
+
+BmapParser::BmapParser(utl::Logger* logger) : logger_(logger)
+{
+}
+
+BumpMapData BmapParser::parseFile(const std::string& filename)
+{
+  current_file_path_ = filename;
+  std::ifstream file(filename);
+  if (!file.is_open()) {
+    logger_->error(
+        utl::ODB, 535, "Bump Map Parser Error: Cannot open file: {}", filename);
+  }
+
+  std::stringstream buffer;
+  buffer << file.rdbuf();
+  std::string content = buffer.str();
+  file.close();
+
+  BumpMapData data;
+  parseBumpMapContent(data, content);
+
+  return data;
+}
+
+void BmapParser::parseBumpMapContent(BumpMapData& data,
+                                     const std::string& content)
+{
+  std::istringstream stream(content);
+  std::string line;
+  int line_number = 0;
+
+  while (std::getline(stream, line)) {
+    line_number++;
+
+    // Skip empty lines and comments (lines starting with #)
+    if (line.empty() || line[0] == '#') {
+      continue;
+    }
+
+    parseBumpMapLine(data, line, line_number);
+  }
+}
+
+void BmapParser::parseBumpMapLine(BumpMapData& data,
+                                  const std::string& line,
+                                  int line_number)
+{
+  std::vector<std::string> tokens = splitLine(line);
+
+  // Check if we have exactly 6 columns
+  if (tokens.size() != 6) {
+    logger_->error(
+        utl::ODB,
+        536,
+        "Bump Map Parser Error: file {} Line {} has {} columns, expected 6. "
+        "Format: bumpInstName bumpCellType x y portName netName",
+        current_file_path_,
+        line_number,
+        tokens.size());
+  }
+
+  try {
+    // Parse coordinates as doubles
+    const double x = std::stod(tokens[2]);
+    const double y = std::stod(tokens[3]);
+
+    // Create bump map entry
+    BumpMapEntry entry(tokens[0], tokens[1], x, y, tokens[4], tokens[5]);
+    data.entries.push_back(entry);
+
+  } catch (const std::exception& e) {
+    logger_->error(utl::ODB,
+                   537,
+                   "Bump Map Parser Error: file {} Line {} - Invalid "
+                   "coordinate format: {}",
+                   current_file_path_,
+                   line_number,
+                   std::string(e.what()));
+  }
+}
+
+std::vector<std::string> BmapParser::splitLine(const std::string& line)
+{
+  std::vector<std::string> tokens;
+  std::istringstream stream(line);
+  std::string token;
+
+  while (stream >> token) {
+    tokens.push_back(token);
+  }
+
+  return tokens;
+}
+
+}  // namespace odb

src/odb/src/3dblox/bmapParser.h

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2019-2025, The OpenROAD Authors
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace utl {
+class Logger;
+}
+namespace odb {
+class BumpMapData;
+class BumpMapEntry;
+
+class BmapParser
+{
+ public:
+  BmapParser(utl::Logger* logger);
+
+  BumpMapData parseFile(const std::string& filename);
+
+ private:
+  void parseBumpMapContent(BumpMapData& data, const std::string& content);
+  void parseBumpMapLine(BumpMapData& data,
+                        const std::string& line,
+                        int line_number);
+  std::vector<std::string> splitLine(const std::string& line);
+
+  utl::Logger* logger_;
+  std::string current_file_path_;
+};
+
+}  // namespace odb

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

@@ -207,10 +207,12 @@ void DbvParser::parseRegion(ChipletRegion& region,
 {
   if (region_node["bmap"]) {
     extractValue(region_node, "bmap", region.bmap);
+    region.bmap = resolvePath(region.bmap);
   }
 
   if (region_node["pmap"]) {
     extractValue(region_node, "pmap", region.pmap);
+    region.pmap = resolvePath(region.pmap);
   }
 
   if (region_node["side"]) {

src/odb/src/3dblox/objects.h

@@ -122,4 +122,35 @@ struct DbxData
   std::map<std::string, Connection> connections;
 };
 
+struct BumpMapEntry
+{
+  std::string bump_inst_name;
+  std::string bump_cell_type;
+  double x{0.0};
+  double y{0.0};
+  std::string port_name;
+  std::string net_name;
+
+  BumpMapEntry() = default;
+  BumpMapEntry(const std::string& inst_name,
+               const std::string& cell_type,
+               double x_coord,
+               double y_coord,
+               const std::string& port,
+               const std::string& net)
+      : bump_inst_name(inst_name),
+        bump_cell_type(cell_type),
+        x(x_coord),
+        y(y_coord),
+        port_name(port),
+        net_name(net)
+  {
+  }
+};
+
+struct BumpMapData
+{
+  std::vector<BumpMapEntry> entries;
+};
+
 }  // namespace odb

src/odb/src/db/dbChipInst.cpp

@@ -254,7 +254,11 @@ dbChipInst* dbChipInst::create(dbChip* parent_chip,
       bumpinst->region_next_ = regioninst->chip_bump_insts_;
       regioninst->chip_bump_insts_ = bumpinst->getOID();
     }
+    // reverse the chip_bump_insts_ list
+    ((dbChipRegionInst*) regioninst)->getChipBumpInsts().reverse();
   }
+  // reverse the chip_region_insts_ list
+  ((dbChipInst*) chipinst)->getRegions().reverse();
   return (dbChipInst*) chipinst;
 }
 

src/odb/test/BUILD

@@ -251,6 +251,7 @@ filegroup(
         "Nangate45/Nangate45_stdcell.lef",
         "Nangate45/Nangate45_tech.lef",
         "Nangate45/Nangate45_typ.lib",
+        "Nangate45/fake_bumps.lef",
         "Nangate45/fake_macros.lef",
         "Nangate45/fake_macros.lib",
         "Nangate45/fakeram45.cfg",
@@ -276,6 +277,7 @@ filegroup(
         "data/design58.def",
         "data/example.3dbv",
         "data/example.3dbx",
+        "data/example.bmap",
         "data/floorplan_initialize.def",
         "data/floorplan_initialize.v",
         "data/floorplan_initialize2.def",

src/odb/test/cpp/Test3DBloxParser.cpp

@@ -111,5 +111,24 @@ TEST_F(DbvFixture, test_3dbx)
   EXPECT_EQ(connection->getThickness(), 0.0);
 }
 
+TEST_F(DbvFixture, test_bump_map_parser)
+{
+  auto region = db_->findChip("SoC")->findChipRegion("r1");
+  EXPECT_EQ(region->getChipBumps().size(), 2);
+  auto bump = *region->getChipBumps().begin();
+  EXPECT_EQ(bump->getInst()->getName(), "bump1");
+  EXPECT_EQ(bump->getInst()->getMaster()->getName(), "BUMP");
+  EXPECT_EQ(bump->getInst()->getOrigin().x(), 100.0 * db_->getDbuPerMicron());
+  EXPECT_EQ(bump->getInst()->getOrigin().y(), 200.0 * db_->getDbuPerMicron());
+  EXPECT_EQ(bump->getNet(), nullptr);
+  EXPECT_EQ(bump->getBTerm(), nullptr);
+  auto soc_inst = db_->getChip()->findChipInst("soc_inst");
+  auto region_inst = soc_inst->findChipRegionInst("r1");
+  EXPECT_EQ(region_inst->getChipBumpInsts().size(), 2);
+  auto bump_inst = *region_inst->getChipBumpInsts().begin();
+  EXPECT_EQ(bump_inst->getChipBump(), bump);
+  EXPECT_EQ(bump_inst->getChipRegionInst(), region_inst);
+}
+
 }  // namespace
 }  // namespace odb