odb: recursive writeDbv and writeDbx

Signed-off-by: osamahammad21 <[email protected]>

Author: osamahammad21

src/OpenRoad.cc

@@ -505,7 +505,7 @@ void OpenRoad::read3DBloxBMap(const std::string& filename)
 void OpenRoad::write3Dbv(const std::string& filename)
 {
   odb::ThreeDBlox writer(logger_, db_, sta_);
-  writer.writeDbv(filename);
+  writer.writeDbv(filename, db_->getChip());
 }
 void OpenRoad::readDb(const char* filename, bool hierarchy)
 {

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

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <string>
+#include <unordered_set>
 #include <vector>
 
 namespace utl {
@@ -26,6 +27,8 @@ class BumpMapEntry;
 class dbChipRegion;
 class dbBlock;
 class dbInst;
+class dbTech;
+class dbLib;
 
 class ThreeDBlox
 {
@@ -36,7 +39,8 @@ class ThreeDBlox
   void readDbx(const std::string& dbx_file);
   void readBMap(const std::string& bmap_file);
   void check();
-  void writeDbv(const std::string& dbv_file);
+  void writeDbv(const std::string& dbv_file, odb::dbChip* chip);
+  void writeDbx(const std::string& dbx_file, odb::dbChip* chip);
 
  private:
   void createChiplet(const ChipletDef& chiplet);
@@ -54,5 +58,7 @@ class ThreeDBlox
   utl::Logger* logger_ = nullptr;
   odb::dbDatabase* db_ = nullptr;
   sta::Sta* sta_ = nullptr;
+  std::unordered_set<odb::dbTech*> written_techs_;
+  std::unordered_set<odb::dbLib*> written_libs_;
 };
 }  // namespace odb

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

@@ -21,11 +21,13 @@
 #include "odb/dbTransform.h"
 #include "odb/dbTypes.h"
 #include "odb/defin.h"
+#include "odb/defout.h"
 #include "odb/geom.h"
 #include "odb/lefin.h"
+#include "odb/lefout.h"
 #include "sta/Sta.hh"
 #include "utl/Logger.h"
-
+#include "utl/ScopedTemporaryFile.h"
 namespace odb {
 
 static std::map<std::string, std::string> dup_orient_map
@@ -94,10 +96,91 @@ void ThreeDBlox::check()
   checker.check(db_->getChip());
 }
 
-void ThreeDBlox::writeDbv(const std::string& dbv_file)
+namespace {
+std::unordered_set<odb::dbTech*> getUsedTechs(odb::dbChip* chip)
+{
+  std::unordered_set<odb::dbTech*> techs;
+  for (auto inst : chip->getChipInsts()) {
+    if (inst->getMasterChip()->getTech() != nullptr) {
+      techs.insert(inst->getMasterChip()->getTech());
+    }
+  }
+  return techs;
+}
+std::unordered_set<odb::dbLib*> getUsedLibs(odb::dbChip* chip)
+{
+  std::unordered_set<odb::dbLib*> libs;
+  for (auto inst : chip->getChipInsts()) {
+    auto master_chip = inst->getMasterChip();
+    if (master_chip->getBlock() != nullptr) {
+      for (auto inst : master_chip->getBlock()->getInsts()) {
+        libs.insert(inst->getMaster()->getLib());
+      }
+    }
+  }
+  return libs;
+}
+std::string getResultsDirectoryPath(const std::string& file_path)
 {
+  std::string current_dir_path;
+  auto path = std::filesystem::path(file_path);
+  if (path.has_parent_path()) {
+    current_dir_path = path.parent_path().string() + "/";
+  }
+  return current_dir_path;
+}
+}  // namespace
+void ThreeDBlox::writeDbv(const std::string& dbv_file, odb::dbChip* chip)
+{
+  if (chip == nullptr) {
+    return;
+  }
+  ///////////Results Directory Path ///////////
+  std::string current_dir_path = getResultsDirectoryPath(dbv_file);
+  ////////////////////////////////////////////
+
+  for (auto inst : chip->getChipInsts()) {
+    auto master_chip = inst->getMasterChip();
+    if (master_chip->getChipType() == odb::dbChip::ChipType::HIER) {
+      writeDbx(current_dir_path + master_chip->getName() + ".3dbx",
+               master_chip);
+    }
+  }
+  // write used techs
+  for (auto tech : getUsedTechs(chip)) {
+    if (written_techs_.find(tech) != written_techs_.end()) {
+      continue;
+    }
+    written_techs_.insert(tech);
+    std::string tech_file_path = current_dir_path + tech->getName() + ".lef";
+    utl::OutStreamHandler stream_handler(tech_file_path.c_str());
+    odb::lefout lef_writer(logger_, stream_handler.getStream());
+    lef_writer.writeTech(tech);
+  }
+  // write used libs
+  for (auto lib : getUsedLibs(chip)) {
+    if (written_libs_.find(lib) != written_libs_.end()) {
+      continue;
+    }
+    written_libs_.insert(lib);
+    std::string lib_file_path = current_dir_path + lib->getName() + "_lib.lef";
+    utl::OutStreamHandler stream_handler(lib_file_path.c_str());
+    odb::lefout lef_writer(logger_, stream_handler.getStream());
+    lef_writer.writeLib(lib);
+  }
+
   DbvWriter writer(logger_, db_);
-  writer.writeChiplet(dbv_file, db_->getChip());
+  writer.writeChiplet(dbv_file, chip);
+}
+
+void ThreeDBlox::writeDbx(const std::string& dbx_file, odb::dbChip* chip)
+{
+  if (chip == nullptr) {
+    return;
+  }
+  // TODO: implement
+  std::string current_dir_path = getResultsDirectoryPath(dbx_file);
+  writeDbv(current_dir_path + chip->getName() + ".3dbv", chip);
 }
 
 void ThreeDBlox::calculateSize(dbChip* chip)
@@ -142,11 +225,13 @@ dbChip::ChipType getChipType(const std::string& type, utl::Logger* logger)
   logger->error(
       utl::ODB, 527, "3DBV Parser Error: Invalid chip type: {}", type);
 }
+
 std::string getFileName(const std::string& tech_file_path)
 {
   std::filesystem::path tech_file_path_fs(tech_file_path);
   return tech_file_path_fs.stem().string();
 }
+
 void ThreeDBlox::createChiplet(const ChipletDef& chiplet)
 {
   dbTech* tech = nullptr;
@@ -239,6 +324,7 @@ void ThreeDBlox::createChiplet(const ChipletDef& chiplet)
     createRegion(region, chip);
   }
 }
+
 dbChipRegion::Side getChipRegionSide(const std::string& side,
                                      utl::Logger* logger)
 {
@@ -348,6 +434,7 @@ dbChip* ThreeDBlox::createDesignTopChiplet(const DesignDef& design)
   db_->setTopChip(chip);
   return chip;
 }
+
 void ThreeDBlox::createChipInst(const ChipletInst& chip_inst)
 {
   auto chip = db_->findChip(chip_inst.reference.c_str());

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

@@ -200,10 +200,6 @@ void DbvWriter::writeLef(YAML::Node& external_node, odb::dbChip* chiplet)
   if (chiplet->getTech()) {
     auto tech = chiplet->getTech();
     std::string tech_file = tech->getName() + ".lef";
-    std::string tech_file_path = current_dir_path_ + tech_file;
-    utl::OutStreamHandler stream_handler(tech_file_path.c_str());
-    odb::lefout lef_writer(logger_, stream_handler.getStream());
-    lef_writer.writeTech(tech);
     YAML::Node list_node;
     list_node.SetStyle(YAML::EmitterStyle::Flow);
     list_node.push_back(tech_file);
@@ -226,10 +222,6 @@ void DbvWriter::writeLef(YAML::Node& external_node, odb::dbChip* chiplet)
     external_node["LEF_file"] = list_node;
     for (auto lib : libs) {
       std::string lef_file = std::string(lib->getName()) + "_lib.lef";
-      std::string lef_file_path = current_dir_path_ + lef_file;
-      utl::OutStreamHandler stream_handler(lef_file_path.c_str());
-      odb::lefout lef_writer(logger_, stream_handler.getStream());
-      lef_writer.writeLib(lib);
       external_node["LEF_file"].push_back(lef_file);
     }
   }