Merge branch 'The-OpenROAD-Project:master' into grt_cugr_layer_idx

Author: eder-matheus

.github/workflows/github-actions-on-label-create.yml

@@ -88,3 +88,86 @@ jobs:
       env:
         GITHUB_TOKEN: ${{ github.token }}
         UPSTREAM_PR: ${{ steps.send_pr.outputs.pr }}
+
+    - name: Request CODEOWNERS reviewers on upstream PR
+      if: steps.send_pr.outputs.pr != ''
+      env:
+        GH_TOKEN: ${{ steps.resolve_token.outputs.token }}
+        PR: ${{ steps.send_pr.outputs.pr }}
+        UPSTREAM: ${{ env.UPSTREAM_OWNER }}/${{ env.UPSTREAM_REPO }}
+      run: |
+        set -euo pipefail
+        # System Python on the runner is PEP 668 externally-managed; use a venv.
+        python3 -m venv /tmp/codeowners-venv
+        /tmp/codeowners-venv/bin/pip install --quiet pathspec
+        /tmp/codeowners-venv/bin/python <<'PY'
+        import base64, json, os, subprocess, sys
+        from pathspec import GitIgnoreSpec
+
+        pr = os.environ["PR"]
+        upstream = os.environ["UPSTREAM"]
+
+        pr_json = subprocess.check_output(
+            ["gh", "api", f"repos/{upstream}/pulls/{pr}"], text=True)
+        pr_data = json.loads(pr_json)
+        author = pr_data["user"]["login"]
+        base_ref = pr_data["base"]["ref"]
+
+        # Authoritative CODEOWNERS is the one on the PR base branch.
+        raw = subprocess.check_output(
+            ["gh", "api", "--method", "GET",
+             f"repos/{upstream}/contents/.github/CODEOWNERS",
+             "-f", f"ref={base_ref}", "--jq", ".content"], text=True).strip()
+        codeowners = base64.b64decode(raw).decode()
+
+        rules = []
+        for line in codeowners.splitlines():
+            line = line.split("#", 1)[0].strip()
+            if not line:
+                continue
+            pattern, *rule_owners = line.split()
+            rules.append((GitIgnoreSpec.from_lines([pattern]), rule_owners))
+
+        # GitHub caps /pulls/{n}/files at 3000 even with --paginate; truly
+        # enormous PRs will under-request owners for the overflow.
+        files = subprocess.check_output(
+            ["gh", "api", f"repos/{upstream}/pulls/{pr}/files", "--paginate",
+             "--jq", ".[].filename"], text=True).splitlines()
+
+        owners = set()
+        for path in files:
+            matched = None
+            for spec, rule_owners in rules:
+                if spec.match_file(path):
+                    matched = rule_owners  # last match wins
+            if matched:
+                owners.update(o.lstrip("@") for o in matched)
+
+        # CODEOWNERS lists teams as "org/slug"; the REST endpoint wants the
+        # bare slug in team_reviewers.
+        team_slugs = sorted(t.split("/", 1)[1] for t in owners if "/" in t)
+        users = sorted(o for o in owners
+                       if "/" not in o and o.lower() != author.lower())
+
+        if not (team_slugs or users):
+            print("No CODEOWNERS-matched reviewers.")
+            sys.exit(0)
+
+        # Use the REST POST endpoint directly: `gh pr edit --add-reviewer`
+        # runs a GraphQL query that needs read:org, which our tokens don't
+        # have. POST /pulls/{n}/requested_reviewers only writes, so the
+        # existing repo / pull-requests:write scope is enough. Each array
+        # is capped at 15 per call.
+        def request(body):
+            print("Requesting:", body)
+            subprocess.run(
+                ["gh", "api", "--method", "POST",
+                 f"repos/{upstream}/pulls/{pr}/requested_reviewers",
+                 "--input", "-"],
+                input=json.dumps(body), text=True, check=True)
+
+        for i in range(0, len(team_slugs), 15):
+            request({"team_reviewers": team_slugs[i:i + 15]})
+        for i in range(0, len(users), 15):
+            request({"reviewers": users[i:i + 15]})
+        PY

src/dbSta/src/dbSdcNetwork.cc

@@ -8,6 +8,7 @@
 #include <memory>
 #include <string>
 #include <string_view>
+#include <utility>
 
 #include "spdlog/fmt/fmt.h"
 #include "sta/NetworkClass.hh"
@@ -66,52 +67,23 @@ InstanceSeq dbSdcNetwork::findInstancesMatching(
 void dbSdcNetwork::findInstancesMatching1(const PatternMatch* pattern,
                                           InstanceSeq& insts) const
 {
-  // If the pattern is a literal (no wildcards and not a regex), return
-  // immediately as the literal lookup has already failed in the caller.
+  // Literal pattern: serve from the precomputed pathological-path map.
+  // Most designs contribute zero entries to this map, so the lookup is
+  // O(1) and the miss path simply falls through.
   if (!pattern->isRegexp() && !pattern->hasWildcards()) {
+    const SdcPathToInstMap& map = sdcPathToInstMap();
+    auto it = map.find(pattern->pattern());
+    if (it != map.end()) {
+      insts.push_back(it->second);
+    }
     return;
   }
-  // A recursive lambda to traverse the design hierarchy with a depth-first
-  // search (DFS).
-  // It builds the hierarchical path incrementally using fmt::memory_buffer to
-  // avoid expensive std::string allocations and copies at each step.
-  std::function<void(Instance*, fmt::memory_buffer&)> dfs_search
-      = [&, this](Instance* instance, fmt::memory_buffer& path_buffer) -> void {
-    // Iterate over the children of the current instance.
-    std::unique_ptr<InstanceChildIterator> child_iter{childIterator(instance)};
-    while (child_iter->hasNext()) {
-      Instance* child = child_iter->next();
-
-      // Save the current size of the buffer to restore it later.
-      const size_t original_size = path_buffer.size();
-
-      // Build the child's full path name incrementally.
-      if (original_size > 0) {
-        path_buffer.push_back(pathDivider());
-      }
-      path_buffer.append(std::string_view(name(child)));
-
-      // Check if the child instance name matches the pattern.
-      // Add a null terminator for C-style string compatibility.
-      path_buffer.push_back('\0');
-      if (pattern->match(staToSdc(path_buffer.data()))) {
-        insts.push_back(child);
-      }
-      path_buffer.resize(path_buffer.size() - 1);  // Remove the null terminator
-
-      // Recurse into the child's hierarchy if it's not a leaf.
-      if (!isLeaf(child)) {
-        dfs_search(child, path_buffer);
-      }
-
-      // Restore the buffer to its original state for the next sibling.
-      path_buffer.resize(original_size);
-    }
-  };
-
-  // Start the search from the top-level instance.
-  fmt::memory_buffer path_buffer;
-  dfs_search(topInstance(), path_buffer);
+  visitAllInstancesSdcPath(
+      [&](Instance* child, const std::string& sdc_path, bool /*any_div*/) {
+        if (pattern->match(sdc_path)) {
+          insts.push_back(child);
+        }
+      });
 }
 
 NetSeq dbSdcNetwork::findNetsMatching(const Instance*,
@@ -243,4 +215,119 @@ Pin* dbSdcNetwork::findPin(std::string_view path_name) const
   return pin;
 }
 
+void dbSdcNetwork::visitAllInstancesSdcPath(const SdcPathVisitor& visitor) const
+{
+  // Build paths incrementally in a fmt::memory_buffer to avoid the
+  // per-step std::string allocations a naive DFS would incur. Using a
+  // generic recursive lambda (auto& self) instead of a std::function
+  // skips type erasure and the heap allocation it can incur.
+  // The any_div flag propagates down so the visitor can cheaply tell
+  // whether sdc_path's recursive splitter resolution would fail.
+  auto rec = [&](auto& self,
+                 Instance* parent,
+                 fmt::memory_buffer& buf,
+                 bool any_div) -> void {
+    std::unique_ptr<InstanceChildIterator> it{childIterator(parent)};
+    while (it->hasNext()) {
+      Instance* child = it->next();
+      const size_t orig_size = buf.size();
+      if (orig_size > 0) {
+        buf.push_back(pathDivider());
+      }
+      const std::string leaf = name(child);
+      // Short-circuit: once a subtree is pathological, descendants
+      // inherit that flag without re-scanning the leaf string.
+      const bool subtree_any_div
+          = any_div || leaf.find(pathDivider()) != std::string::npos;
+      buf.append(std::string_view(leaf));
+      buf.push_back('\0');  // null-terminate for staToSdc's C-string input
+      visitor(child, staToSdc(buf.data()), subtree_any_div);
+      buf.resize(buf.size() - 1);
+      if (!isLeaf(child)) {
+        self(self, child, buf, subtree_any_div);
+      }
+      buf.resize(orig_size);
+    }
+  };
+  fmt::memory_buffer buf;
+  rec(rec, topInstance(), buf, false);
+}
+
+const dbSdcNetwork::SdcPathToInstMap& dbSdcNetwork::sdcPathToInstMap() const
+{
+  if (!cache_built_) {
+    visitAllInstancesSdcPath(
+        [&](Instance* inst, std::string sdc_path, bool any_div) {
+          // Only pathological entries (those the recursive splitter in
+          // findInstance cannot resolve) need to live in the cache.
+          if (any_div) {
+            inst_to_sdc_path_.emplace(inst, sdc_path);
+            sdc_path_to_inst_.emplace(std::move(sdc_path), inst);
+          }
+        });
+    cache_built_ = true;
+  }
+  return sdc_path_to_inst_;
+}
+
+bool dbSdcNetwork::hasPathologicalPath(const Instance* inst) const
+{
+  const Instance* top = topInstance();
+  for (const Instance* a = inst; a && a != top; a = network_->parent(a)) {
+    if (name(a).find(pathDivider()) != std::string::npos) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void dbSdcNetwork::insertEntry(Instance* inst) const
+{
+  std::string sdc_path = SdcNetwork::pathName(inst);
+  inst_to_sdc_path_.emplace(inst, sdc_path);
+  sdc_path_to_inst_.emplace(std::move(sdc_path), inst);
+}
+
+void dbSdcNetwork::eraseEntry(const Instance* inst) const
+{
+  auto rev_it = inst_to_sdc_path_.find(inst);
+  if (rev_it == inst_to_sdc_path_.end()) {
+    return;
+  }
+  sdc_path_to_inst_.erase(rev_it->second);
+  inst_to_sdc_path_.erase(rev_it);
+}
+
+void dbSdcNetwork::onInstCreated(Instance* inst)
+{
+  if (!cache_built_) {
+    return;
+  }
+  if (!hasPathologicalPath(inst)) {
+    return;
+  }
+  insertEntry(inst);
+}
+
+void dbSdcNetwork::onInstDestroyed(Instance* inst)
+{
+  if (!cache_built_) {
+    return;
+  }
+  eraseEntry(inst);
+}
+
+void dbSdcNetwork::onInstRenamed(Instance* inst)
+{
+  if (!cache_built_) {
+    return;
+  }
+  // Erase by Instance* (uses the reverse map) — no need to reconstruct
+  // the pre-rename path. Re-insert if still pathological.
+  eraseEntry(inst);
+  if (hasPathologicalPath(inst)) {
+    insertEntry(inst);
+  }
+}
+
 }  // namespace sta

src/dbSta/src/dbSdcNetwork.hh

@@ -2,7 +2,11 @@
 // Copyright (c) 2019-2025, The OpenROAD Authors
 
 #pragma once
+#include <cstddef>
+#include <functional>
+#include <string>
 #include <string_view>
+#include <unordered_map>
 
 #include "sta/Network.hh"
 #include "sta/NetworkClass.hh"
@@ -22,6 +26,25 @@ class dbSdcNetwork : public SdcNetwork
   PinSeq findPinsMatching(const Instance* instance,
                           const PatternMatch* pattern) const override;
 
+  // Drop the cache. Used on subtree-wide edits (parent change, modInst
+  // destroy) where surgical fix-up would be more error-prone than letting
+  // the next literal lookup rebuild lazily.
+  void invalidateSdcPathToInstMap()
+  {
+    sdc_path_to_inst_.clear();
+    inst_to_sdc_path_.clear();
+    cache_built_ = false;
+  }
+
+  // Incremental cache maintenance for hierarchy edits. Each is a no-op
+  // when the cache hasn't been built yet (lazy property preserved) or
+  // when the affected instance has no path component containing the
+  // divider — the cache only ever holds the small set of "pathological"
+  // entries that findInstance's recursive splitter cannot resolve.
+  void onInstCreated(Instance* inst);
+  void onInstDestroyed(Instance* inst);
+  void onInstRenamed(Instance* inst);
+
  protected:
   void findInstancesMatching1(const PatternMatch* pattern,
                               InstanceSeq& insts) const;
@@ -31,6 +54,50 @@ class dbSdcNetwork : public SdcNetwork
                         PinSeq& pins) const;
   Pin* findPin(std::string_view path_name) const override;
   using SdcNetwork::findPin;
+
+ private:
+  // Heterogeneous string hashing so callers can look up by std::string_view
+  // without allocating a temporary std::string for each query.
+  struct TransparentStringHash
+  {
+    using is_transparent = void;
+    size_t operator()(std::string_view s) const noexcept
+    {
+      return std::hash<std::string_view>{}(s);
+    }
+  };
+  using SdcPathToInstMap = std::unordered_map<std::string,
+                                              Instance*,
+                                              TransparentStringHash,
+                                              std::equal_to<>>;
+  // Reverse map for O(1) erase-by-instance during destroy/rename.
+  using InstToSdcPathMap = std::unordered_map<const Instance*, std::string>;
+  using SdcPathVisitor
+      = std::function<void(Instance*, std::string sdc_path, bool any_div)>;
+
+  // DFS the hierarchy, invoking visitor(child, sdc_path, any_div) once per
+  // instance. any_div is true when sdc_path or any ancestor's leaf name
+  // contains the divider — i.e. findInstance cannot resolve sdc_path.
+  void visitAllInstancesSdcPath(const SdcPathVisitor& visitor) const;
+
+  // True iff inst itself or any ancestor has a STA-form leaf name
+  // containing the path divider (an escaped Verilog identifier such as
+  // "\foo/bar"). These are the only entries we cache.
+  bool hasPathologicalPath(const Instance* inst) const;
+
+  // Insert / erase keep both maps consistent. Callers must have ensured
+  // the cache is built; insertEntry additionally requires inst pathological.
+  void insertEntry(Instance* inst) const;
+  void eraseEntry(const Instance* inst) const;
+
+  // Lazy full-path -> Instance lookup, used by findInstancesMatching1 to
+  // resolve literal SDC patterns that the hierarchy walker missed (e.g. a
+  // Verilog escaped identifier "\foo/bar"). Only pathological entries are
+  // stored, so memory is O(escaped-identifier-count), not O(N).
+  const SdcPathToInstMap& sdcPathToInstMap() const;
+  mutable SdcPathToInstMap sdc_path_to_inst_;
+  mutable InstToSdcPathMap inst_to_sdc_path_;
+  mutable bool cache_built_ = false;
 };
 
 }  // namespace sta