Merge pull request #8845 from gadfort/bmap

odb: add read_3dblox_bmap command

Author: maliberty

include/ord/OpenRoad.hh

@@ -224,6 +224,7 @@ class OpenRoad
 
   void read3Dbv(const std::string& filename);
   void read3Dbx(const std::string& filename);
+  void read3DBloxBMap(const std::string& filename);
 
   void readDb(std::istream& stream);
   void readDb(const char* filename, bool hierarchy = false);

src/OpenRoad.cc

@@ -497,6 +497,12 @@ void OpenRoad::read3Dbx(const std::string& filename)
   parser.readDbx(filename);
 }
 
+void OpenRoad::read3DBloxBMap(const std::string& filename)
+{
+  odb::ThreeDBlox parser(logger_, db_);
+  parser.readBMap(filename);
+}
+
 void OpenRoad::readDb(const char* filename, bool hierarchy)
 {
   try {

src/OpenRoad.i

@@ -369,6 +369,13 @@ read_3dbx_cmd(const char *filename)
   ord->read3Dbx(filename);
 }
 
+void
+read_3dblox_bmap_cmd(const char *filename)
+{
+  OpenRoad *ord = getOpenRoad();
+  ord->read3DBloxBMap(filename);
+}
+
 void
 read_db_cmd(const char *filename, bool hierarchy)
 {

src/OpenRoad.tcl

@@ -197,6 +197,21 @@ proc read_3dbx { args } {
   ord::read_3dbx_cmd $filename
 }
 
+sta::define_cmd_args "read_3dblox_bmap" {filename}
+
+proc read_3dblox_bmap { args } {
+  sta::parse_key_args "read_3dblox_bmap" args keys {} flags {}
+  sta::check_argc_eq1 "read_3dblox_bmap" $args
+  set filename [file nativename [lindex $args 0]]
+  if { ![file exists $filename] } {
+    utl::error "ORD" 74 "$filename does not exist."
+  }
+  if { ![file readable $filename] } {
+    utl::error "ORD" 75 "$filename is not readable."
+  }
+  ord::read_3dblox_bmap_cmd $filename
+}
+
 sta::define_cmd_args "write_db" {filename}
 
 sta::define_cmd_args "read_db" {[-hier] filename}

src/README.md

@@ -335,6 +335,20 @@ report_logic_depth_histogram [-num_bins num_bins] [-exclude_buffers] [-exclude_i
 | `-exclude_buffers` | Exclude buffers when counting critical path length. |
 | `-exclude_inverters` | Exclude inverters when counting critical path length. |
 
+#### 3D Blox
+
+The `read_3dblox_bmap` command will read the bump map and place the bumps into the current design.
+
+```tcl
+read_3dblox_bmap filename
+```
+
+##### Options
+
+| Switch Name | Description |
+| ----- | ----- |
+| `filename` | Path to the bump map. |
+
 ## TCL functions
 
 Get the die and core areas as a list in microns: `llx lly urx ury`

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

@@ -24,6 +24,8 @@ class dbChipRegionInst;
 class dbChipInst;
 class BumpMapEntry;
 class dbChipRegion;
+class dbBlock;
+class dbInst;
 
 class ThreeDBlox
 {
@@ -32,6 +34,7 @@ class ThreeDBlox
   ~ThreeDBlox() = default;
   void readDbv(const std::string& dbv_file);
   void readDbx(const std::string& dbx_file);
+  void readBMap(const std::string& bmap_file);
 
  private:
   void createChiplet(const ChipletDef& chiplet);
@@ -40,6 +43,7 @@ class ThreeDBlox
   void createChipInst(const ChipletInst& chip_inst);
   void createConnection(const Connection& connection);
   void createBump(const BumpMapEntry& entry, dbChipRegion* chip_region);
+  dbInst* createBump(const BumpMapEntry& entry, dbBlock* block);
   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

@@ -6,6 +6,7 @@
 #include <cstddef>
 #include <filesystem>
 #include <map>
+#include <set>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -15,6 +16,7 @@
 #include "dbxParser.h"
 #include "objects.h"
 #include "odb/db.h"
+#include "odb/dbTransform.h"
 #include "odb/dbTypes.h"
 #include "odb/defin.h"
 #include "odb/geom.h"
@@ -444,4 +446,141 @@ void ThreeDBlox::createConnection(const Connection& connection)
                                       bottom_region);
   conn->setThickness(connection.thickness * db_->getDbuPerMicron());
 }
+
+void ThreeDBlox::readBMap(const std::string& bmap_file)
+{
+  dbBlock* block = db_->getChip()->getBlock();
+
+  BmapParser parser(logger_);
+  BumpMapData data = parser.parseFile(bmap_file);
+  std::vector<odb::dbInst*> bumps;
+  bumps.reserve(data.entries.size());
+  for (const auto& entry : data.entries) {
+    bumps.push_back(createBump(entry, block));
+  }
+
+  struct BPinInfo
+  {
+    dbTechLayer* layer = nullptr;
+    odb::Rect rect;
+  };
+
+  // Populate where the bpins should be made
+  std::map<odb::dbMaster*, BPinInfo> bpininfo;
+  for (dbInst* inst : bumps) {
+    dbMaster* master = inst->getMaster();
+    if (bpininfo.find(master) != bpininfo.end()) {
+      continue;
+    }
+
+    odb::dbTechLayer* max_layer = nullptr;
+    std::set<odb::Rect> top_shapes;
+
+    for (dbMTerm* mterm : master->getMTerms()) {
+      for (dbMPin* mpin : mterm->getMPins()) {
+        for (dbBox* geom : mpin->getGeometry()) {
+          auto* layer = geom->getTechLayer();
+          if (layer == nullptr) {
+            continue;
+          }
+          if (max_layer == nullptr) {
+            max_layer = layer;
+            top_shapes.insert(geom->getBox());
+          } else if (max_layer->getRoutingLevel() <= layer->getRoutingLevel()) {
+            if (max_layer->getRoutingLevel() < layer->getRoutingLevel()) {
+              top_shapes.clear();
+            }
+            max_layer = layer;
+            top_shapes.insert(geom->getBox());
+          }
+        }
+      }
+    }
+
+    if (max_layer != nullptr) {
+      odb::Rect master_box;
+      master->getPlacementBoundary(master_box);
+      const odb::Point center = master_box.center();
+      const odb::Rect* top_shape_ptr = nullptr;
+      for (const odb::Rect& shape : top_shapes) {
+        if (shape.intersects(center)) {
+          top_shape_ptr = &shape;
+        }
+      }
+
+      if (top_shape_ptr == nullptr) {
+        top_shape_ptr = &(*top_shapes.begin());
+      }
+
+      bpininfo.emplace(master, BPinInfo{max_layer, *top_shape_ptr});
+    }
+  }
+
+  // create bpins
+  for (dbInst* inst : bumps) {
+    auto masterbpin = bpininfo.find(inst->getMaster());
+    if (masterbpin == bpininfo.end()) {
+      continue;
+    }
+
+    const BPinInfo& pin_info = masterbpin->second;
+
+    const dbTransform xform = inst->getTransform();
+    for (dbITerm* iterm : inst->getITerms()) {
+      dbNet* net = iterm->getNet();
+      if (net == nullptr) {
+        continue;
+      }
+      dbBTerm* bterm = net->get1stBTerm();
+      dbBPin* pin = dbBPin::create(bterm);
+      Rect shape = pin_info.rect;
+      xform.apply(shape);
+      dbBox::create(pin,
+                    pin_info.layer,
+                    shape.xMin(),
+                    shape.yMin(),
+                    shape.xMax(),
+                    shape.yMax());
+      pin->setPlacementStatus(odb::dbPlacementStatus::FIRM);
+      break;
+    }
+  }
+}
+
+dbInst* ThreeDBlox::createBump(const BumpMapEntry& entry, dbBlock* block)
+{
+  const int dbus = db_->getDbuPerMicron();
+  dbInst* inst = block->findInst(entry.bump_inst_name.c_str());
+  if (inst == nullptr) {
+    // create inst
+    dbMaster* master = db_->findMaster(entry.bump_cell_type.c_str());
+    if (master == nullptr) {
+      logger_->error(utl::ODB,
+                     538,
+                     "3DBV Parser Error: Bump cell type {} not found",
+                     entry.bump_cell_type);
+    }
+    inst = dbInst::create(block, master, entry.bump_inst_name.c_str());
+  }
+  inst->setOrigin(entry.x * dbus, entry.y * dbus);
+  inst->setPlacementStatus(dbPlacementStatus::FIRM);
+
+  // Net entry doesn't make sense
+  if (entry.net_name != "-") {
+    dbNet* net = block->findNet(entry.net_name.c_str());
+    if (net == nullptr) {
+      logger_->error(utl::ODB,
+                     539,
+                     "3DBV Parser Error: Bump net {} not found",
+                     entry.net_name);
+    }
+    for (odb::dbITerm* iterm : inst->getITerms()) {
+      iterm->connect(net);
+    }
+  }
+  // Port already on the net, so skip
+
+  return inst;
+}
+
 }  // namespace odb

src/odb/test/BUILD

@@ -279,6 +279,7 @@ filegroup(
         "data/example.3dbv",
         "data/example.3dbx",
         "data/example.bmap",
+        "data/example1.bmap",
         "data/floorplan_initialize.def",
         "data/floorplan_initialize.v",
         "data/floorplan_initialize2.def",

src/odb/test/cpp/BUILD

@@ -224,6 +224,7 @@ cc_test(
     ],
     deps = [
         "//src/odb",
+        "//src/odb/test/cpp/helper",
         "//src/tst",
         "//src/tst:nangate45_fixture",
         "//src/utl",

src/odb/test/cpp/Test3DBloxParser.cpp

@@ -2,6 +2,7 @@
 #include <string>
 
 #include "gtest/gtest.h"
+#include "helper.h"
 #include "odb/3dblox.h"
 #include "odb/db.h"
 #include "odb/geom.h"
@@ -133,5 +134,72 @@ TEST_F(DbvFixture, test_bump_map_parser)
   EXPECT_EQ(bump_inst->getChipRegionInst(), region_inst);
 }
 
+TEST_F(SimpleDbFixture, test_bump_map_reader)
+{
+  createSimpleDB();
+
+  db_->setDbuPerMicron(1000);
+
+  // Create BUMP master
+  dbLib* lib = db_->findLib("lib1");
+  dbTechLayer* bot_layer
+      = dbTechLayer::create(lib->getTech(), "BOT", dbTechLayerType::ROUTING);
+  dbTechLayer* layer
+      = dbTechLayer::create(lib->getTech(), "TOP", dbTechLayerType::ROUTING);
+  dbMaster* master = dbMaster::create(lib, "BUMP");
+  master->setWidth(10000);
+  master->setHeight(10000);
+  master->setOrigin(5000, 5000);
+  master->setType(dbMasterType::COVER_BUMP);
+  dbMTerm* term
+      = dbMTerm::create(master, "PAD", dbIoType::INOUT, dbSigType::SIGNAL);
+  dbMPin* bot_pin = dbMPin::create(term);
+  dbBox::create(bot_pin, bot_layer, -1000, -1000, 1000, 1000);
+  dbMPin* pin = dbMPin::create(term);
+  dbBox::create(pin, layer, -2000, -2000, 2000, 2000);
+  master->setFrozen();
+
+  // Create BTerms
+  dbBlock* block = db_->getChip()->getBlock();
+  dbBTerm* SIG1 = dbBTerm::create(dbNet::create(block, "SIG1"), "SIG1");
+  dbBTerm* SIG2 = dbBTerm::create(dbNet::create(block, "SIG2"), "SIG2");
+  block->setDieArea(Rect(0, 0, 500, 500));
+
+  EXPECT_EQ(block->getInsts().size(), 0);
+
+  ThreeDBlox parser(&logger_, db_.get());
+  std::string path = getFilePath(prefix + "data/example1.bmap");
+  parser.readBMap(path);
+
+  // Check bumps were created
+  EXPECT_EQ(block->getInsts().size(), 2);
+  dbInst* inst1 = block->findInst("bump1");
+  EXPECT_EQ(inst1->getBBox()->getBox().xCenter(), 100 * 1000);
+  EXPECT_EQ(inst1->getBBox()->getBox().yCenter(), 200 * 1000);
+  dbInst* inst2 = block->findInst("bump2");
+  EXPECT_EQ(inst2->getBBox()->getBox().xCenter(), 150 * 1000);
+  EXPECT_EQ(inst2->getBBox()->getBox().yCenter(), 200 * 1000);
+
+  // Check that BPins where added
+  EXPECT_EQ(SIG1->getBPins().size(), 1);
+  EXPECT_EQ(SIG2->getBPins().size(), 1);
+  EXPECT_EQ(SIG1->getBPins().begin()->getBoxes().size(), 1);
+  EXPECT_EQ(SIG2->getBPins().begin()->getBoxes().size(), 1);
+
+  // Check bPin shape and layer
+  dbBox* sig1_box = *SIG1->getBPins().begin()->getBoxes().begin();
+  dbBox* sig2_box = *SIG2->getBPins().begin()->getBoxes().begin();
+  EXPECT_EQ(sig1_box->getTechLayer(), layer);
+  EXPECT_EQ(sig1_box->getBox().xMin(), 98000);
+  EXPECT_EQ(sig1_box->getBox().yMin(), 198000);
+  EXPECT_EQ(sig1_box->getBox().xMax(), 102000);
+  EXPECT_EQ(sig1_box->getBox().yMax(), 202000);
+  EXPECT_EQ(sig2_box->getTechLayer(), layer);
+  EXPECT_EQ(sig2_box->getBox().xMin(), 148000);
+  EXPECT_EQ(sig2_box->getBox().yMin(), 198000);
+  EXPECT_EQ(sig2_box->getBox().xMax(), 152000);
+  EXPECT_EQ(sig2_box->getBox().yMax(), 202000);
+}
+
 }  // namespace
 }  // namespace odb