Merge pull request #8257 from The-OpenROAD-Project-staging/TR-pa-unique-class

DRT: PA Unique Class

Author: osamahammad21

src/drt/src/pa/AbstractPAGraphics.h

@@ -27,12 +27,12 @@ class AbstractPAGraphics
 
   virtual void startPin(frBPin* pin,
                         frInstTerm* inst_term,
-                        frOrderedIdSet<frInst*>* inst_class)
+                        UniqueClass* inst_class)
       = 0;
 
   virtual void startPin(frMPin* pin,
                         frInstTerm* inst_term,
-                        frOrderedIdSet<frInst*>* inst_class)
+                        UniqueClass* inst_class)
       = 0;
 
   virtual void setAPs(const std::vector<std::unique_ptr<frAccessPoint>>& aps,

src/drt/src/pa/FlexPA.cpp

@@ -44,7 +44,7 @@ using utl::ThreadException;
 
 static inline void serializePatterns(
     const std::unordered_map<
-        frInst*,
+        UniqueClass*,
         std::vector<std::unique_ptr<FlexPinAccessPattern>>>& patterns,
     const std::string& file_name)
 {
@@ -53,8 +53,8 @@ static inline void serializePatterns(
   registerTypes(ar);
   int sz = patterns.size();
   ar << sz;
-  for (auto& [inst, pattern] : patterns) {
-    frBlockObject* obj = (frBlockObject*) inst;
+  for (auto& [unique_class, pattern] : patterns) {
+    frBlockObject* obj = (frBlockObject*) unique_class->getFirstInst();
     serializeBlockObject(ar, obj);
     ar << pattern;
   }
@@ -107,13 +107,14 @@ void FlexPA::init()
 void FlexPA::addInst(frInst* inst)
 {
   const bool new_unique = unique_insts_.addInst(inst);
+  auto unique_class = unique_insts_.getUniqueClass(inst);
   if (new_unique) {
-    unique_insts_.initUniqueInstPinAccess(inst);
-    initSkipInstTerm(inst);
+    unique_insts_.initUniqueInstPinAccess(unique_class);
+    initSkipInstTerm(unique_class);
     genInstAccessPoints(inst);
     prepPatternInst(inst);
   }
-  inst->setPinAccessIdx(unique_insts_.getUnique(inst)->getPinAccessIdx());
+  inst->setPinAccessIdx(unique_class->getPinAccessIdx());
 
   insts_set_.insert(inst);
   if (isSkipInst(inst)) {
@@ -125,22 +126,12 @@ void FlexPA::addInst(frInst* inst)
 
 void FlexPA::deleteInst(frInst* inst)
 {
-  const bool is_class_head = (inst == unique_insts_.getUnique(inst));
-  // if inst is the class head the new head will be returned by deleteInst()
-  UniqueInsts::InstSet* unique_class = unique_insts_.getClass(inst);
-  frInst* class_head = unique_insts_.deleteInst(inst);
-
+  auto old_unique_class = unique_insts_.getUniqueClass(inst);
+  unique_insts_.deleteInst(inst);
   // whole class has to be deleted
-  if (!class_head) {
-    unique_inst_patterns_.erase(inst);
-    for (auto& inst_term : inst->getInstTerms()) {
-      skip_unique_inst_term_.erase({unique_class, inst_term->getTerm()});
-    }
-  }
-  // new class representative has to be chosen
-  else if (is_class_head) {
-    unique_inst_patterns_[class_head] = std::move(unique_inst_patterns_[inst]);
-    unique_inst_patterns_.erase(inst);
+  if (old_unique_class->getInsts().empty()) {
+    unique_inst_patterns_.erase(old_unique_class);
+    unique_insts_.deleteUniqueClass(old_unique_class);
   }
   insts_set_.erase(inst);
 }
@@ -157,7 +148,8 @@ void FlexPA::applyPatternsFile(const char* file_path)
   while (sz--) {
     frBlockObject* obj;
     serializeBlockObject(ar, obj);
-    auto& pattern = unique_inst_patterns_[static_cast<frInst*>(obj)];
+    auto unique_class = unique_insts_.getUniqueClass(static_cast<frInst*>(obj));
+    auto& pattern = unique_inst_patterns_[unique_class];
     ar >> pattern;
   }
   file.close();
@@ -217,7 +209,7 @@ void FlexPA::prepPattern()
 {
   ProfileTask profile("PA:pattern");
 
-  const auto& unique = unique_insts_.getUnique();
+  const auto& unique = unique_insts_.getUniqueClasses();
 
   // revert access points to origin
   unique_inst_patterns_.reserve(unique.size());
@@ -227,15 +219,19 @@ void FlexPA::prepPattern()
   omp_set_num_threads(router_cfg_->MAX_THREADS);
   ThreadException exception;
 #pragma omp parallel for schedule(dynamic)
-  for (frInst* unique_inst : unique) {
+  for (auto& unique_class : unique) {
     try {
       // only do for core and block cells
       // TODO the above comment says "block cells" but that's not what the code
       // does?
-      if (!isStdCell(unique_inst)) {
+      if (unique_class->getInsts().empty()) {
+        continue;
+      }
+      auto candidate_inst = *unique_class->getInsts().begin();
+      if (!isStdCell(candidate_inst)) {
         continue;
       }
-      prepPatternInst(unique_inst);
+      prepPatternInst(candidate_inst);
 #pragma omp critical
       {
         cnt++;
@@ -315,13 +311,13 @@ bool FlexPA::isSkipInstTermLocal(frInstTerm* in)
 
 bool FlexPA::isSkipInstTerm(frInstTerm* in)
 {
-  auto inst_class = unique_insts_.getClass(in->getInst());
+  auto inst_class = unique_insts_.getUniqueClass(in->getInst());
   if (inst_class == nullptr) {
     return isSkipInstTermLocal(in);
   }
 
   // This should be already computed in initSkipInstTerm()
-  return skip_unique_inst_term_.at({inst_class, in->getTerm()});
+  return inst_class->isSkipTerm(in->getTerm());
 }
 
 bool FlexPA::isSkipInst(frInst* inst)

src/drt/src/pa/FlexPA.h

@@ -126,13 +126,11 @@ class FlexPA
   int macro_cell_pin_valid_planar_ap_cnt_ = 0;
   int macro_cell_pin_valid_via_ap_cnt_ = 0;
   int macro_cell_pin_no_ap_cnt_ = 0;
-  std::unordered_map<frInst*,
+  std::unordered_map<UniqueClass*,
                      std::vector<std::unique_ptr<FlexPinAccessPattern>>>
       unique_inst_patterns_;
 
   UniqueInsts unique_insts_;
-  using UniqueMTerm = std::pair<const UniqueInsts::InstSet*, frMTerm*>;
-  std::map<UniqueMTerm, bool> skip_unique_inst_term_;
 
   // helper structures
   std::vector<std::map<frCoord, frAccessPointEnum>> track_coords_;
@@ -167,7 +165,7 @@ class FlexPA
   void initTrackCoords();
   void initViaRawPriority();
   void initAllSkipInstTerm();
-  void initSkipInstTerm(frInst* unique_inst);
+  void initSkipInstTerm(UniqueClass* unique_class);
   // prep
   void prep();
 

src/drt/src/pa/FlexPA_acc_pattern.cpp

@@ -67,10 +67,10 @@ void FlexPA::buildInstsSet()
 
 void FlexPA::prepPatternInst(frInst* unique_inst)
 {
+  auto unique_class = unique_insts_.getUniqueClass(unique_inst);
 #pragma omp critical
-  unique_inst_patterns_[unique_inst]
+  unique_inst_patterns_[unique_class]
       = std::vector<std::unique_ptr<FlexPinAccessPattern>>();
-
   int num_valid_pattern = prepPatternInstHelper(unique_inst, true);
 
   if (num_valid_pattern > 0) {
@@ -662,7 +662,8 @@ bool FlexPA::genPatternsCommit(
   if (target_obj != nullptr
       && genPatternsGC({target_obj}, objs, Commit, &owners)) {
     pin_access_pattern->updateCost();
-    unique_inst_patterns_[unique_inst].push_back(std::move(pin_access_pattern));
+    unique_inst_patterns_[unique_insts_.getUniqueClass(unique_inst)].push_back(
+        std::move(pin_access_pattern));
     // genPatternsPrint(nodes, pins);
     is_valid = true;
   } else {

src/drt/src/pa/FlexPA_acc_point.cpp

@@ -1356,9 +1356,9 @@ int FlexPA::genPinAccess(T* pin, frInstTerm* inst_term)
   std::set<std::pair<Point, frLayerNum>> apset;
 
   if (graphics_) {
-    frOrderedIdSet<frInst*>* inst_class = nullptr;
+    UniqueClass* inst_class = nullptr;
     if (inst_term) {
-      inst_class = unique_insts_.getClass(inst_term->getInst());
+      inst_class = unique_insts_.getUniqueClass(inst_term->getInst());
     }
     graphics_->startPin(pin, inst_term, inst_class);
   }
@@ -1482,21 +1482,23 @@ void FlexPA::genAllAccessPoints()
   omp_set_num_threads(router_cfg_->MAX_THREADS);
   ThreadException exception;
 
-  const std::vector<frInst*>& unique = unique_insts_.getUnique();
+  const auto& unique = unique_insts_.getUniqueClasses();
 #pragma omp parallel for schedule(dynamic)
-  for (frInst* unique_inst : unique) {  // NOLINT
+  for (const auto& unique_class : unique) {  // NOLINT
     try {
+      auto candidate_inst = unique_class->getFirstInst();
       // only do for core and block cells
-      if (!isStdCell(unique_inst) && !isMacroCell(unique_inst)) {
+      if (!isStdCell(candidate_inst) && !isMacroCell(candidate_inst)) {
         continue;
       }
 
-      genInstAccessPoints(unique_inst);
+      genInstAccessPoints(candidate_inst);
       if (router_cfg_->VERBOSE <= 0) {
         continue;
       }
 
-      int inst_terms_cnt = static_cast<int>(unique_inst->getInstTerms().size());
+      int inst_terms_cnt
+          = static_cast<int>(candidate_inst->getInstTerms().size());
 #pragma omp critical
       for (int j = 0; j < inst_terms_cnt; j++) {
         pin_count++;
@@ -1548,18 +1550,15 @@ void FlexPA::genAllAccessPoints()
 
 void FlexPA::revertAccessPoints()
 {
-  const auto& unique = unique_insts_.getUnique();
-  for (frInst* inst : unique) {
-    const dbTransform xform = inst->getTransform();
+  const auto& unique = unique_insts_.getUniqueClasses();
+  for (const auto& unique_class : unique) {
+    auto candidate_inst = unique_class->getFirstInst();
+    const dbTransform xform = candidate_inst->getTransform();
     const Point offset(xform.getOffset());
     dbTransform revertXform(Point(-offset.getX(), -offset.getY()));
 
-    const auto pin_access_idx = inst->getPinAccessIdx();
-    for (auto& inst_term : inst->getInstTerms()) {
-      // if (isSkipInstTerm(inst_term.get())) {
-      //   continue;
-      // }
-
+    const auto pin_access_idx = candidate_inst->getPinAccessIdx();
+    for (auto& inst_term : candidate_inst->getInstTerms()) {
       for (auto& pin : inst_term->getTerm()->getPins()) {
         auto pin_access = pin->getPinAccess(pin_access_idx);
         for (auto& access_point : pin_access->getAccessPoints()) {

src/drt/src/pa/FlexPA_graphics.cpp

@@ -151,7 +151,7 @@ void FlexPAGraphics::drawLayer(odb::dbTechLayer* layer, gui::Painter& painter)
 
 void FlexPAGraphics::startPin(frMPin* pin,
                               frInstTerm* inst_term,
-                              frOrderedIdSet<frInst*>* inst_class)
+                              UniqueClass* inst_class)
 {
   pin_ = nullptr;
 
@@ -160,7 +160,7 @@ void FlexPAGraphics::startPin(frMPin* pin,
     if (term_name_ != "*" && term->getName() != term_name_) {
       return;
     }
-    if (inst_class->find(inst_) == inst_class->end()) {
+    if (!inst_class->hasInst(inst_)) {
       return;
     }
   }
@@ -180,7 +180,7 @@ void FlexPAGraphics::startPin(frMPin* pin,
 
 void FlexPAGraphics::startPin(frBPin* pin,
                               frInstTerm* inst_term,
-                              frOrderedIdSet<frInst*>* inst_class)
+                              UniqueClass* inst_class)
 {
   pin_ = nullptr;
 

src/drt/src/pa/FlexPA_graphics.h

@@ -49,11 +49,11 @@ class FlexPAGraphics : public gui::Renderer, public AbstractPAGraphics
 
   void startPin(frBPin* pin,
                 frInstTerm* inst_term,
-                frOrderedIdSet<frInst*>* inst_class) override;
+                UniqueClass* inst_class) override;
 
   void startPin(frMPin* pin,
                 frInstTerm* inst_term,
-                frOrderedIdSet<frInst*>* inst_class) override;
+                UniqueClass* inst_class) override;
 
   void setAPs(const std::vector<std::unique_ptr<frAccessPoint>>& aps,
               frAccessPointEnum lower_type,

src/drt/src/pa/FlexPA_init.cpp

@@ -147,37 +147,25 @@ void FlexPA::initTrackCoords()
 
 void FlexPA::initAllSkipInstTerm()
 {
-  const auto& unique = unique_insts_.getUnique();
+  const auto& unique = unique_insts_.getUniqueClasses();
 #pragma omp parallel for schedule(dynamic)
-  for (frInst* unique_inst : unique) {
-    initSkipInstTerm(unique_inst);
+  for (const auto& unique_class : unique) {
+    initSkipInstTerm(unique_class.get());
   }
 }
 
-void FlexPA::initSkipInstTerm(frInst* unique_inst)
+void FlexPA::initSkipInstTerm(UniqueClass* unique_class)
 {
-  for (auto& inst_term : unique_inst->getInstTerms()) {
-    frMTerm* term = inst_term->getTerm();
-    const UniqueInsts::InstSet* inst_class
-        = unique_insts_.getClass(unique_inst);
-
-#pragma omp critical
-    skip_unique_inst_term_[{inst_class, term}] = false;
-
-    // We have to be careful that the skip conditions are true not only of
-    // the unique instance but also all the equivalent instances.
-    bool skip = isSkipInstTermLocal(inst_term.get());
-    if (skip) {
-      for (frInst* inst : *inst_class) {
-        frInstTerm* it = inst->getInstTerm(inst_term->getIndexInOwner());
-        skip = isSkipInstTermLocal(it);
-        if (!skip) {
-          break;
-        }
+  for (const auto& term : unique_class->getMaster()->getTerms()) {
+    bool skip = true;
+    for (const auto& inst : unique_class->getInsts()) {
+      auto inst_term = inst->getInstTerm(term->getIndexInOwner());
+      skip = isSkipInstTermLocal(inst_term);
+      if (!skip) {
+        break;
       }
     }
-#pragma omp critical
-    skip_unique_inst_term_.at({inst_class, term}) = skip;
+    unique_class->setSkipTerm(term.get(), skip);
   }
 }
 

src/drt/src/pa/FlexPA_row_pattern.cpp

@@ -267,8 +267,8 @@ void FlexPA::genInstRowPatternInit(
   // init inst nodes
   for (int inst_idx = 0; inst_idx < (int) insts.size(); inst_idx++) {
     auto& inst = insts[inst_idx];
-    auto unique_inst = unique_insts_.getUnique(inst);
-    auto& inst_patterns = unique_inst_patterns_[unique_inst];
+    auto unique_class = unique_insts_.getUniqueClass(inst);
+    auto& inst_patterns = unique_inst_patterns_[unique_class];
     nodes[inst_idx]
         = std::vector<std::unique_ptr<FlexDPNode>>(inst_patterns.size());
     for (int acc_pattern_idx = 0; acc_pattern_idx < (int) inst_patterns.size();
@@ -347,9 +347,9 @@ void FlexPA::genInstRowPatternCommit(
 
     frInst* inst = insts[curr_inst_idx];
     int access_point_idx = 0;
-    frInst* unique_inst = unique_insts_.getUnique(inst);
+    auto unique_class = unique_insts_.getUniqueClass(inst);
     auto access_pattern
-        = unique_inst_patterns_[unique_inst][curr_acc_patterns_idx].get();
+        = unique_inst_patterns_[unique_class][curr_acc_patterns_idx].get();
     auto& access_points = access_pattern->getPattern();
 
     // update inst_term ap
@@ -391,9 +391,9 @@ void FlexPA::genInstRowPatternPrint(
       // print debug information
       auto& inst = insts[curr_inst_idx];
       int access_point_idx = 0;
-      auto unique_inst = unique_insts_.getUnique(inst);
+      auto unique_class = unique_insts_.getUniqueClass(inst);
       auto access_pattern
-          = unique_inst_patterns_[unique_inst][curr_acc_pattern_idx].get();
+          = unique_inst_patterns_[unique_class][curr_acc_pattern_idx].get();
       auto& access_points = access_pattern->getPattern();
 
       for (auto& inst_term : inst->getInstTerms()) {
@@ -448,13 +448,13 @@ int FlexPA::getEdgeCost(FlexDPNode* prev_node,
   std::vector<std::pair<frConnFig*, frBlockObject*>> objs;
   // push the vias from prev inst access pattern and curr inst access pattern
   const auto prev_inst = insts[prev_inst_idx];
-  const auto prev_unique_inst = unique_insts_.getUnique(prev_inst);
+  const auto prev_unique_class = unique_insts_.getUniqueClass(prev_inst);
   const auto curr_inst = insts[curr_inst_idx];
-  const auto curr_unique_inst = unique_insts_.getUnique(curr_inst);
+  const auto curr_unique_class = unique_insts_.getUniqueClass(curr_inst);
   const auto prev_pin_access_pattern
-      = unique_inst_patterns_[prev_unique_inst][prev_acc_pattern_idx].get();
+      = unique_inst_patterns_[prev_unique_class][prev_acc_pattern_idx].get();
   const auto curr_pin_access_pattern
-      = unique_inst_patterns_[curr_unique_inst][curr_acc_pattern_idx].get();
+      = unique_inst_patterns_[curr_unique_class][curr_acc_pattern_idx].get();
   addAccessPatternObj(
       prev_inst, prev_pin_access_pattern, objs, temp_vias, true);
   addAccessPatternObj(