Merge pull request #8049 from QuantamHD/pointer_tagging

dbSta: Use pointer tagging instead of getObjectType()

Author: maliberty

src/dbSta/src/dbNetwork.cc

@@ -165,6 +165,22 @@ ObjectId dbNetwork::getDbNwkObjectId(const dbObject* object) const
   return 0;
 }
 
+// We have exactly 8 values available in the lower 3 bits of the
+// pointer due to these classes all having 8 byte alignment. Used
+// to avoid having to call into the database to figure out the
+// type information, which requires a lot of pointer indirection.
+
+// Used to get the value of the pointer tag.
+static constexpr std::uintptr_t kPointerTagMask = std::uintptr_t(0b111U);
+
+enum class PinPointerTags : std::uintptr_t
+{
+  kNone = 0U,
+  kDbIterm = 1U,
+  kDbBterm = 2U,
+  kDbModIterm = 3U,
+};
+
 class DbLibraryIterator1 : public Iterator<Library*>
 {
  public:
@@ -470,14 +486,14 @@ bool DbNetPinIterator::hasNext()
   while (iitr_ != iitr_end_) {
     dbITerm* iterm = *iitr_;
     if (!iterm->getSigType().isSupply()) {
-      next_ = reinterpret_cast<Pin*>(*iitr_);
+      next_ = network_->dbToSta(*iitr_);
       ++iitr_;
       return true;
     }
     iitr_++;
   }
   if ((mitr_ != mitr_end_) && (network_->hasHierarchy())) {
-    next_ = reinterpret_cast<Pin*>(*mitr_);
+    next_ = network_->dbToSta(*mitr_);
     ++mitr_;
     return true;
   }
@@ -1212,14 +1228,20 @@ ObjectId dbNetwork::id(const Pin* pin) const
 
   if (hierarchy_) {
     // get the id for hierarchical objects using dbid.
-    const dbObject* obj = reinterpret_cast<const dbObject*>(pin);
+    std::uintptr_t tag_value
+        = reinterpret_cast<std::uintptr_t>(pin) & kPointerTagMask;
+    // Need to cast to char pin to avoid compiler error for pointer
+    // arithmetic on incomplete types
+    const char* char_pin = reinterpret_cast<const char*>(pin);
+    const dbObject* obj
+        = reinterpret_cast<const dbObject*>(char_pin - tag_value);
     return getDbNwkObjectId(obj);
   }
   if (iterm != nullptr) {
     return iterm->getId() << 1;
   }
   if (bterm != nullptr) {
-    return (bterm->getId() << 1) + 1;
+    return (bterm->getId() << 1) | 1U;
   }
   return 0;
 }
@@ -2765,17 +2787,32 @@ void dbNetwork::staToDb(const Pin* pin,
   iterm = nullptr;
   bterm = nullptr;
   moditerm = nullptr;
-  if (pin) {
-    dbObject* obj = reinterpret_cast<dbObject*>(const_cast<Pin*>(pin));
-    dbObjectType type = obj->getObjectType();
-    if (type == dbITermObj) {
-      iterm = static_cast<dbITerm*>(obj);
-    } else if (type == dbBTermObj) {
-      bterm = static_cast<dbBTerm*>(obj);
-    } else if (type == dbModITermObj) {
-      moditerm = static_cast<dbModITerm*>(obj);
-    } else {
-      logger_->error(ORD, 2018, "Pin is not ITerm or BTerm or modITerm.");
+
+  // Get the value of the tag
+  std::uintptr_t pointer_with_tag = reinterpret_cast<std::uintptr_t>(pin);
+  PinPointerTags tag_value
+      = static_cast<PinPointerTags>(pointer_with_tag & kPointerTagMask);
+
+  // Cast to char* and avoid casting an integral type to pointer type
+  // by doing pointer arithmetic. Compiler apparently prefer this sytle.
+  const char* char_pointer_pin = reinterpret_cast<const char*>(pin);
+  char* pointer_without_tag = const_cast<char*>(
+      char_pointer_pin - static_cast<std::uintptr_t>(tag_value));
+
+  if (pointer_without_tag) {
+    switch (tag_value) {
+      case PinPointerTags::kDbIterm:
+        iterm = reinterpret_cast<dbITerm*>(pointer_without_tag);
+        break;
+      case PinPointerTags::kDbBterm:
+        bterm = reinterpret_cast<dbBTerm*>(pointer_without_tag);
+        break;
+      case PinPointerTags::kDbModIterm:
+        moditerm = reinterpret_cast<dbModITerm*>(pointer_without_tag);
+        break;
+      case PinPointerTags::kNone:
+        logger_->error(ORD, 2018, "Pin is not ITerm or BTerm or modITerm.");
+        break;
     }
   }
 }
@@ -2938,7 +2975,10 @@ Instance* dbNetwork::dbToSta(dbModInst* inst) const
 
 Pin* dbNetwork::dbToSta(dbModITerm* mod_iterm) const
 {
-  return reinterpret_cast<Pin*>(mod_iterm);
+  char* unaligned_pointer = reinterpret_cast<char*>(mod_iterm);
+  return reinterpret_cast<Pin*>(
+      unaligned_pointer
+      + static_cast<std::uintptr_t>(PinPointerTags::kDbModIterm));
 }
 
 Net* dbNetwork::dbToSta(dbModNet* net) const
@@ -2983,12 +3023,18 @@ const Net* dbNetwork::dbToSta(const dbModNet* net) const
 
 Pin* dbNetwork::dbToSta(dbBTerm* bterm) const
 {
-  return reinterpret_cast<Pin*>(bterm);
+  char* unaligned_pointer = reinterpret_cast<char*>(bterm);
+  return reinterpret_cast<Pin*>(
+      unaligned_pointer
+      + static_cast<std::uintptr_t>(PinPointerTags::kDbBterm));
 }
 
 Pin* dbNetwork::dbToSta(dbITerm* iterm) const
 {
-  return reinterpret_cast<Pin*>(iterm);
+  char* unaligned_pointer = reinterpret_cast<char*>(iterm);
+  return reinterpret_cast<Pin*>(
+      unaligned_pointer
+      + static_cast<std::uintptr_t>(PinPointerTags::kDbIterm));
 }
 
 Term* dbNetwork::dbToStaTerm(dbBTerm* bterm) const
@@ -3572,9 +3618,10 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
         dest_mod_net = dest_moditerm->getModNet();
       }
       if (dest_mod_net) {
-        dbNet* dest_flat_net = flatNet((Pin*) dest_pin);
-        disconnectPin((Pin*) dest_pin);
-        connectPin((Pin*) dest_pin, (Net*) dest_flat_net, (Net*) dest_mod_net);
+        Pin* sta_dest_pin = dbToSta(dest_pin);
+        dbNet* dest_flat_net = flatNet(sta_dest_pin);
+        disconnectPin(sta_dest_pin);
+        connectPin(sta_dest_pin, (Net*) dest_flat_net, (Net*) dest_mod_net);
         return;
       }
     }
@@ -3610,11 +3657,12 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
 
       // at leaf level make connection
       if (level == 0) {
-        dbModNet* source_pin_mod_net = hierNet((Pin*) source_pin);
+        Pin* sta_source_pin = dbToSta(source_pin);
+        dbModNet* source_pin_mod_net = hierNet(sta_source_pin);
         if (source_pin_mod_net) {
-          disconnectPin((Pin*) source_pin, (Net*) source_pin_mod_net);
+          disconnectPin(sta_source_pin, (Net*) source_pin_mod_net);
         }
-        connectPin((Pin*) source_pin, (Net*) source_db_mod_net);
+        connectPin(sta_source_pin, (Net*) source_db_mod_net);
       }
 
       dbModInst* parent_inst = cur_module->getModInst();
@@ -3642,11 +3690,12 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
       mod_bterm->setSigType(dbSigType::SIGNAL);
 
       if (level == 0) {
-        dbModNet* dest_pin_mod_net = hierNet((Pin*) dest_pin);
+        Pin* sta_dest_pin = dbToSta(dest_pin);
+        dbModNet* dest_pin_mod_net = hierNet(sta_dest_pin);
         if (dest_pin_mod_net) {
-          disconnectPin((Pin*) dest_pin, (Net*) dest_pin_mod_net);
+          disconnectPin(sta_dest_pin, (Net*) dest_pin_mod_net);
         }
-        connectPin((Pin*) dest_pin, (Net*) dest_db_mod_net);
+        connectPin(sta_dest_pin, (Net*) dest_db_mod_net);
       }
 
       dbModInst* parent_inst = cur_module->getModInst();
@@ -3670,9 +3719,10 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
             = dbModNet::create(highest_common_module, connection_name);
         top_mod_dest->connect(source_db_mod_net);
 
-        dbNet* source_pin_flat_net = flatNet((Pin*) source_pin);
-        disconnectPin((Pin*) source_pin);
-        connectPin((Pin*) source_pin,
+        Pin* sta_source_pin = dbToSta(source_pin);
+        dbNet* source_pin_flat_net = flatNet(sta_source_pin);
+        disconnectPin(sta_source_pin);
+        connectPin(sta_source_pin,
                    (Net*) source_pin_flat_net,
                    (Net*) source_db_mod_net);
         // source_pin->connect(source_db_mod_net);
@@ -3693,20 +3743,22 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
 
     // reassociate the dest pin
 
-    dbModNet* dest_pin_mod_net = hierNet((Pin*) dest_pin);
+    Pin* sta_dest_pin = dbToSta(dest_pin);
+    dbModNet* dest_pin_mod_net = hierNet(sta_dest_pin);
     if (dest_pin_mod_net) {
-      dbNet* dest_pin_flat_net = flatNet((Pin*) dest_pin);
+      dbNet* dest_pin_flat_net = flatNet(sta_dest_pin);
       dest_pin->disconnect();
       connectPin(
-          (Pin*) dest_pin, (Net*) dest_pin_flat_net, (Net*) dest_pin_mod_net);
+          sta_dest_pin, (Net*) dest_pin_flat_net, (Net*) dest_pin_mod_net);
     }
 
     // reassociate the source pin
-    dbModNet* source_pin_mod_net = hierNet((Pin*) source_pin);
+    Pin* sta_source_pin = dbToSta(source_pin);
+    dbModNet* source_pin_mod_net = hierNet(sta_source_pin);
     if (source_pin_mod_net) {
-      dbNet* source_pin_flat_net = flatNet((Pin*) source_pin);
+      dbNet* source_pin_flat_net = flatNet(sta_source_pin);
       source_pin->disconnect();
-      connectPin((Pin*) source_pin,
+      connectPin(sta_source_pin,
                  (Net*) source_pin_flat_net,
                  (Net*) source_pin_mod_net);
     }

src/odb/src/codeGenerator/schema/chip/dbModITerm.json

@@ -1,6 +1,7 @@
 {
     "name":"dbModITerm",
     "needs_non_default_destructor" : "true",
+    "assert_alignment_is_multiple_of": 8,
     "fields":[
         {
             "name":"_name",

src/odb/src/codeGenerator/templates/impl.cpp

@@ -84,6 +84,10 @@ namespace odb {
 
   _{{klass.name}}::_{{klass.name}}(_dbDatabase* db)
   {
+    {% if klass.assert_alignment_is_multiple_of %}
+    // For pointer tagging the bottom log_2({{klass.assert_alignment_is_multiple_of}}) bits.
+    static_assert(alignof(_{{klass.name}}) % {{klass.assert_alignment_is_multiple_of}} == 0);
+    {% endif%}
     {% for field in klass.fields %}
       {% if field.bitFields %}
         {{field.name}} = {};

src/odb/src/db/dbBTerm.cpp

@@ -37,6 +37,8 @@ template class dbTable<_dbBTerm>;
 
 _dbBTerm::_dbBTerm(_dbDatabase*)
 {
+  // For pointer tagging the bottom 3 bits.
+  static_assert(alignof(_dbBTerm) % 8 == 0);
   _flags._io_type = dbIoType::INPUT;
   _flags._sig_type = dbSigType::SIGNAL;
   _flags._orient = 0;

src/odb/src/db/dbITerm.h

@@ -72,6 +72,8 @@ class _dbITerm : public _dbObject
 
 inline _dbITerm::_dbITerm(_dbDatabase*)
 {
+  // For pointer tagging the bottom 3 bits.
+  static_assert(alignof(_dbITerm) % 8 == 0);
   _flags._mterm_idx = 0;
   _flags._spare_bits = 0;
   _flags._clocked = 0;

src/odb/src/db/dbModITerm.cpp

@@ -57,6 +57,8 @@ bool _dbModITerm::operator<(const _dbModITerm& rhs) const
 
 _dbModITerm::_dbModITerm(_dbDatabase* db)
 {
+  // For pointer tagging the bottom log_2(8) bits.
+  static_assert(alignof(_dbModITerm) % 8 == 0);
   _name = nullptr;
 }
 

src/rsz/src/Rebuffer.cc

@@ -1933,8 +1933,9 @@ int Rebuffer::exportBufferTree(const BufferedNetPtr& choice,
         return 0;
       }
 
+      Pin* mod_net_drvr_pin = db_network_->dbToSta(mod_net_drvr);
       dbNet* db_load_net = db_network_->flatNet(load_pin);
-      odb::dbNet* db_net = db_network_->flatNet((Pin*) mod_net_drvr);
+      odb::dbNet* db_net = db_network_->flatNet(mod_net_drvr_pin);
       if ((Net*) db_load_net != net) {
         odb::dbITerm* load_iterm = nullptr;
         odb::dbBTerm* load_bterm = nullptr;