odb: unify dbupermicron

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

Author: osamahammad21

src/drt/src/DesignCallBack.cpp

@@ -9,12 +9,6 @@
 
 namespace drt {
 
-static inline int defdist(odb::dbBlock* block, int x)
-{
-  return x * (double) block->getDefUnits()
-         / (double) block->getDbUnitsPerMicron();
-}
-
 void DesignCallBack::inDbPreMoveInst(odb::dbInst* db_inst)
 {
   auto design = router_->getDesign();
@@ -43,9 +37,6 @@ void DesignCallBack::inDbPostMoveInst(odb::dbInst* db_inst)
   }
   int x, y;
   db_inst->getLocation(x, y);
-  auto block = db_inst->getBlock();
-  x = defdist(block, x);
-  y = defdist(block, y);
   inst->setOrigin({x, y});
   inst->setOrient(db_inst->getOrient());
   router_->addInstancePAData(inst);

src/grt/src/GlobalRouter.tcl

@@ -48,7 +48,7 @@ proc set_global_routing_region_adjustment { args } {
     utl::error GRT 47 "Missing dbTech."
   }
   set tech [ord::get_db_tech]
-  set lef_units [$tech getLefUnits]
+  set lef_units [$tech getDbUnitsPerMicron]
 
   if { [info exists keys(-layer)] } {
     set layer $keys(-layer)

src/gui/src/gui.cpp

@@ -783,7 +783,7 @@ void Gui::saveImage(const std::string& filename,
     if (tech == nullptr) {
       logger_->error(utl::GUI, 16, "No design loaded.");
     }
-    const double dbu_per_micron = tech->getLefUnits();
+    const double dbu_per_micron = tech->getDbUnitsPerMicron();
 
     std::string save_cmds;
     // build display control commands

src/gui/src/gui.tcl

@@ -100,10 +100,10 @@ proc save_image { args } {
     if { $tech == "NULL" } {
       utl::error GUI 17 "No technology loaded."
     }
-    set resolution [expr $keys(-resolution) * [$tech getLefUnits]]
+    set resolution [expr $keys(-resolution) * [$tech getDbUnitsPerMicron]]
     if { $resolution < 1 } {
       set resolution 1.0
-      set res_per_pixel [expr $resolution / [$tech getLefUnits]]
+      set res_per_pixel [expr $resolution / [$tech getDbUnitsPerMicron]]
       utl::warn GUI 31 "Resolution too high for design, defaulting to ${res_per_pixel}um per pixel"
     }
   }
@@ -156,10 +156,10 @@ proc save_animated_gif { args } {
     if { $tech == "NULL" } {
       utl::error GUI 52 "No technology loaded."
     }
-    set resolution [expr $keys(-resolution) * [$tech getLefUnits]]
+    set resolution [expr $keys(-resolution) * [$tech getDbUnitsPerMicron]]
     if { $resolution < 1 } {
       set resolution 1.0
-      set res_per_pixel [expr $resolution / [$tech getLefUnits]]
+      set res_per_pixel [expr $resolution / [$tech getDbUnitsPerMicron]]
       utl::warn GUI 55 "Resolution too high for design, defaulting to ${res_per_pixel}um per pixel"
     }
   }

src/odb/include/odb/db.h

@@ -5697,13 +5697,6 @@ class dbTech : public dbObject
   ///
   std::string getName();
 
-  ///
-  /// Set the Database distance units per micron.
-  ///
-  /// Legal values are 100, 200, 1000, 2000, 10000, 20000
-  ///
-  void setDbUnitsPerMicron(int value);
-
   ///
   /// Get the Database units per micron.
   ///
@@ -5880,9 +5873,7 @@ class dbTech : public dbObject
   /// Create a new technology.
   /// Returns nullptr if a database technology already exists
   ///
-  static dbTech* create(dbDatabase* db,
-                        const char* name,
-                        int dbu_per_micron = 1000);
+  static dbTech* create(dbDatabase* db, const char* name);
 
   ///
   /// Translate a database-id back to a pointer.

src/odb/src/db/dbDatabase.h

@@ -48,7 +48,10 @@ namespace odb {
 inline constexpr uint db_schema_major = 0;  // Not used...
 inline constexpr uint db_schema_initial = 57;
 
-inline constexpr uint db_schema_minor = 121;  // Current revision number
+inline constexpr uint db_schema_minor = 122;  // Current revision number
+
+// Revision where dbTech::dbu_per_micron_ was removed
+inline constexpr uint db_schema_remove_dbu_per_micron = 122;
 
 // Revision where core area is stored as a polygon
 inline constexpr uint db_schema_core_area_is_polygon = 121;

src/odb/src/db/dbTech.cpp

@@ -101,10 +101,6 @@ bool _dbTech::operator==(const _dbTech& rhs) const
     return false;
   }
 
-  if (_dbu_per_micron != rhs._dbu_per_micron) {
-    return false;
-  }
-
   if (_mfgrid != rhs._mfgrid) {
     return false;
   }
@@ -203,7 +199,6 @@ _dbTech::_dbTech(_dbDatabase* db)
   _layer_cnt = 0;
   _rlayer_cnt = 0;
   _lef_units = 0;
-  _dbu_per_micron = 1000;
   _mfgrid = 0;
 
   _flags._namecase = dbOnOffType::ON;
@@ -307,7 +302,6 @@ dbOStream& operator<<(dbOStream& stream, const _dbTech& tech)
   stream << tech._layer_cnt;
   stream << tech._rlayer_cnt;
   stream << tech._lef_units;
-  stream << tech._dbu_per_micron;
   stream << tech._mfgrid;
 
   uint* bit_field = (uint*) &tech._flags;
@@ -350,7 +344,11 @@ dbIStream& operator>>(dbIStream& stream, _dbTech& tech)
   stream >> tech._layer_cnt;
   stream >> tech._rlayer_cnt;
   stream >> tech._lef_units;
-  stream >> tech._dbu_per_micron;
+  if (db->isLessThanSchema(db_schema_remove_dbu_per_micron)) {
+    int dbu_per_micron;
+    stream >> dbu_per_micron;
+    db->dbu_per_micron_ = dbu_per_micron;
+  }
   stream >> tech._mfgrid;
 
   uint* bit_field = (uint*) &tech._flags;
@@ -501,16 +499,9 @@ dbTechLayer* dbTech::findRoutingLayer(int level_number)
   return nullptr;
 }
 
-void dbTech::setDbUnitsPerMicron(int value)
-{
-  _dbTech* tech = (_dbTech*) this;
-  tech->_dbu_per_micron = value;
-}
-
 int dbTech::getDbUnitsPerMicron()
 {
-  _dbTech* tech = (_dbTech*) this;
-  return tech->_dbu_per_micron;
+  return getDb()->getDbuPerMicron();
 }
 
 dbSet<dbTechVia> dbTech::getVias()
@@ -831,12 +822,11 @@ void dbTech::checkLayer(bool typeChk,
     }
   }
 }
-dbTech* dbTech::create(dbDatabase* db_, const char* name, int dbu_per_micron)
+dbTech* dbTech::create(dbDatabase* db_, const char* name)
 {
   _dbDatabase* db = (_dbDatabase*) db_;
 
   _dbTech* tech = db->_tech_tbl->create();
-  tech->_dbu_per_micron = dbu_per_micron;
   tech->_name = name;
   return (dbTech*) tech;
 }

src/odb/src/db/dbTech.h

@@ -64,7 +64,6 @@ class _dbTech : public _dbObject
   int _layer_cnt;
   int _rlayer_cnt;
   int _lef_units;
-  int _dbu_per_micron;
   int _mfgrid;
   _dbTechFlags _flags;
   dbId<_dbTechLayer> _bottom;

src/odb/src/db/dbUtil.h

@@ -113,19 +113,17 @@ void checkNetSanity(const NetType* net,
   //
   if (drvr_count > 1) {
     if constexpr (std::is_same_v<NetType, dbNet>) {
-      logger->warn(
-          utl::ODB,
-          49,
-          "SanityCheck: dbNet '{}' has multiple drivers: {}",
-          net->getName(),
-          fmt::join(drvr_info_list, ""));  // NOLINT(misc-include-cleaner)
+      logger->warn(utl::ODB,
+                   49,
+                   "SanityCheck: dbNet '{}' has multiple drivers: {}",
+                   net->getName(),
+                   drvr_info_list.size());  // NOLINT(misc-include-cleaner)
     } else {
-      logger->warn(
-          utl::ODB,
-          481,  // Reusing error code from dbNet
-          "SanityCheck: dbModNet '{}' has multiple drivers: {}",
-          net->getHierarchicalName(),
-          fmt::join(drvr_info_list, ""));  // NOLINT(misc-include-cleaner)
+      logger->warn(utl::ODB,
+                   481,  // Reusing error code from dbNet
+                   "SanityCheck: dbModNet '{}' has multiple drivers: {}",
+                   net->getHierarchicalName(),
+                   drvr_info_list.size());  // NOLINT(misc-include-cleaner)
     }
   }
 

src/odb/src/lefin/lefin.cpp

@@ -1862,18 +1862,13 @@ void lefinReader::units(LefParser::lefiUnits* unit)
   if (unit->hasDatabase()) {
     _lef_units = (int) unit->databaseNumber();
 
-    if (_override_lef_dbu == false) {
-      if (_create_tech) {
-        if (_lef_units
-            < 1000) {  // historically the database was always stored in nm
-          setDBUPerMicron(1000);
-        } else {
-          setDBUPerMicron(_lef_units);
-        }
-
-        _tech->setDbUnitsPerMicron(_dbu_per_micron);
-        _tech->setLefUnits(_lef_units);
+    if (_create_tech && !_override_lef_dbu) {
+      // historically the database was always stored in nm
+      setDBUPerMicron(std::max(_lef_units, 1000));
+      if (_db->getDbuPerMicron() == 0) {
+        _db->setDbuPerMicron(_dbu_per_micron);
       }
+      _tech->setLefUnits(_lef_units);
     }
 
     if (_lef_units > _dbu_per_micron) {
@@ -1889,33 +1884,63 @@ void lefinReader::units(LefParser::lefiUnits* unit)
   }
 }
 
-void lefinReader::setDBUPerMicron(int dbu)
+namespace {
+bool isValidDBUPerMicron(int dbu)
 {
   switch (dbu) {
-    case 100:
-    case 200:
-    case 400:
-    case 800:
     case 1000:
     case 2000:
     case 4000:
     case 8000:
     case 10000:
     case 20000:
-      _dist_factor = dbu;
-      _dbu_per_micron = dbu;
-      _area_factor = _dbu_per_micron * _dbu_per_micron;
-      break;
+      return true;
     default:
+      return false;
+  }
+}
+}  // namespace
+
+void lefinReader::setDBUPerMicron(int dbu)
+{
+  if (!isValidDBUPerMicron(dbu)) {
+    ++_errors;
+    _logger->warn(utl::ODB,
+                  400,
+                  "error: invalid dbu-per-micron value {}; valid units (1000, "
+                  "2000, 4000, 8000, 10000, 20000)",
+                  dbu);
+
+    return;
+  }
+  if (_db->getDbuPerMicron() != 0) {
+    if (dbu > _db->getDbuPerMicron()) {
+      ++_errors;
+      _logger->warn(
+          utl::ODB,
+          401,
+          "The LEF UNITS DATABASE MICRON convert factor ({}) is greater than "
+          "the database units per micron ({}) of the current database.",
+          dbu,
+          _db->getDbuPerMicron());
+      return;
+    } else if (_db->getDbuPerMicron() % dbu != 0) {
       ++_errors;
       _logger->warn(utl::ODB,
-                    206,
-                    "error: invalid dbu-per-micron value {}; valid units (100, "
-                    "200, 400, 800"
-                    "1000, 2000, 4000, 8000, 10000, 20000)",
-                    _lef_units);
-      break;
+                    402,
+                    "The LEF UNITS DATABASE MICRON convert factor ({}) is "
+                    "not a multiplier of the database units per micron ({}) of "
+                    "the current database.",
+                    dbu,
+                    _db->getDbuPerMicron());
+      return;
+    } else {
+      dbu = _db->getDbuPerMicron();
+    }
   }
+  _dist_factor = dbu;
+  _dbu_per_micron = dbu;
+  _area_factor = _dbu_per_micron * _dbu_per_micron;
 }
 
 void lefinReader::useMinSpacing(LefParser::lefiUseMinSpacing* spacing)
@@ -2370,7 +2395,7 @@ dbTech* lefinReader::createTech(const char* name, const char* lef_file)
   lefrSetRelaxMode();
   init();
 
-  _tech = dbTech::create(_db, name, _dbu_per_micron);
+  _tech = dbTech::create(_db, name);
   _create_tech = true;
 
   if (!readLef(lef_file) || _errors != 0) {
@@ -2439,7 +2464,7 @@ dbLib* lefinReader::createTechAndLib(const char* tech_name,
     return nullptr;
   };
 
-  _tech = dbTech::create(_db, tech_name, _dbu_per_micron);
+  _tech = dbTech::create(_db, tech_name);
   _lib_name = lib_name;
   _create_lib = true;
   _create_tech = true;