ord: add read_3dblox_bmap command to read a bmap and create bumps

Signed-off-by: Peter Gadfort <[email protected]>

Author: gadfort

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, bool create_bpins = false);
 
   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, bool create_bpins)
+{
+  odb::ThreeDBlox parser(logger_, db_);
+  parser.readBMap(filename, create_bpins);
+}
+
 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, bool create_bpins)
+{
+  OpenRoad *ord = getOpenRoad();
+  ord->read3DBloxBMap(filename, create_bpins);
+}
+
 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" {[-create_pins] filename}
+
+proc read_3dblox_bmap { args } {
+  sta::parse_key_args "read_3dblox_bmap" args keys {} flags {-create_pins}
+  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 [info exists flags(-create_pins)]
+}
+
 sta::define_cmd_args "write_db" {filename}
 
 sta::define_cmd_args "read_db" {[-hier] filename}

src/README.md

@@ -335,6 +335,21 @@ 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 [-create_pins] filename
+```
+
+##### Options
+
+| Switch Name | Description |
+| ----- | ----- |
+| `-create_pins` | If specified, block pins will be created over each bump. |
+| `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, bool create_bpins);
 
  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

@@ -15,6 +15,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 +445,140 @@ void ThreeDBlox::createConnection(const Connection& connection)
                                       bottom_region);
   conn->setThickness(connection.thickness * db_->getDbuPerMicron());
 }
+
+void ThreeDBlox::readBMap(const std::string& bmap_file, bool create_bpins)
+{
+  dbBlock* block = db_->getChip()->getBlock();
+
+  BmapParser parser(logger_);
+  BumpMapData data = parser.parseFile(bmap_file);
+  std::vector<odb::dbInst*> bumps;
+  for (const auto& entry : data.entries) {
+    bumps.push_back(createBump(entry, block));
+  }
+
+  if (create_bpins) {
+    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->getRoutingLevel() <= layer->getRoutingLevel()) {
+              max_layer = layer;
+              if (max_layer->getRoutingLevel() < layer->getRoutingLevel()) {
+                top_shapes.clear();
+              }
+              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;
+      }
+
+      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