Merge branch 'master' into secure-rsz-time-borrow-opt

Signed-off-by: Matt Liberty <mliberty@precisioninno.com>

Author: maliberty

.github/workflows/github-actions-clang-tidy-bazel-post.yml

@@ -81,20 +81,20 @@ jobs:
           done < pr-meta.txt
 
       - name: Synthesize pull_request event payload
-        id: event
         env:
           PR_NUMBER: ${{ steps.meta.outputs.pr_number }}
           HEAD_SHA: ${{ steps.meta.outputs.head_sha }}
           BASE_SHA: ${{ steps.meta.outputs.base_sha }}
           HEAD_REPO: ${{ steps.meta.outputs.head_repo }}
           BASE_REPO: ${{ steps.meta.outputs.base_repo }}
         run: |
-          # Reviewdog's `github-pr-review` reporter reads GITHUB_EVENT_PATH
-          # expecting a pull_request payload. The real event here is
-          # workflow_run, so we synthesize the minimum payload reviewdog
-          # needs and point GITHUB_EVENT_PATH at it for the next step.
-          EVENT_PATH="${RUNNER_TEMP}/pr-event.json"
-          python3 - <<'PY' > "$EVENT_PATH"
+          # reviewdog reads pull_request.number from the event file at
+          # GITHUB_EVENT_PATH; the workflow_run event has none (its
+          # pull_requests[] is empty for fork PRs), so it bails with "this is
+          # not PullRequest build". GITHUB_EVENT_PATH is runner-protected, so
+          # an env: override is silently ignored — overwrite the event file in
+          # place instead. Safe: nothing downstream reads the original event.
+          python3 - <<'PY' > "${GITHUB_EVENT_PATH}"
           import json, os
           payload = {
             "action": "synchronize",
@@ -118,57 +118,34 @@ jobs:
           }
           print(json.dumps(payload))
           PY
-          echo "event_path=${EVENT_PATH}" >> "$GITHUB_OUTPUT"
 
       - name: Set up reviewdog
         uses: reviewdog/action-setup@d8a7baabd7f3e8544ee4dbde3ee41d0011c3a93f  # v1.5.0
         with:
           reviewdog_version: latest
 
       - name: Dump reviewdog-visible env and event payload
-        # Gated on debug re-runs. Reviewdog emits "this is not PullRequest
-        # build" and posts nothing for fork PRs even though the synthesized
-        # pull_request payload is well-formed (verified locally against
-        # reviewdog v0.21.0). Suspect: step-level `env:` cannot override
-        # runner-protected GITHUB_EVENT_PATH / GITHUB_EVENT_NAME, so reviewdog
-        # reads the runner's workflow_run event payload instead of our synth.
-        # This step proves what reviewdog actually sees on the next debug
-        # re-run.
+        # Debug-gated: confirm the event file now holds the synthesized
+        # pull_request payload reviewdog will read.
         if: runner.debug == '1'
-        env:
-          GITHUB_EVENT_NAME: pull_request
-          GITHUB_EVENT_PATH: ${{ steps.event.outputs.event_path }}
-          GITHUB_SHA: ${{ steps.meta.outputs.head_sha }}
-          GITHUB_REPOSITORY: ${{ steps.meta.outputs.base_repo }}
         run: |
-          echo "::group::GITHUB_* env visible to next step"
+          echo "::group::GITHUB_* env visible to reviewdog"
           env | grep -E '^(GITHUB_|RUNNER_|REVIEWDOG_)' | sort
           echo "::endgroup::"
-          echo "::group::Synth event file location and content"
-          echo "steps.event.outputs.event_path = ${{ steps.event.outputs.event_path }}"
-          echo "Effective GITHUB_EVENT_PATH    = ${GITHUB_EVENT_PATH}"
+          echo "::group::Effective GITHUB_EVENT_PATH content (should be our synth)"
+          echo "Effective GITHUB_EVENT_PATH = ${GITHUB_EVENT_PATH}"
           if [ -f "${GITHUB_EVENT_PATH}" ]; then
-            echo "--- file exists, content: ---"
             cat "${GITHUB_EVENT_PATH}"
           else
             echo "::warning::GITHUB_EVENT_PATH file does not exist"
           fi
           echo "::endgroup::"
-          echo "::group::Synth file at literal path (should match above)"
-          SYNTH="${{ steps.event.outputs.event_path }}"
-          [ -f "${SYNTH}" ] && cat "${SYNTH}" || echo "missing"
-          echo "::endgroup::"
 
       - name: Run reviewdog
         env:
           REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GITHUB_EVENT_NAME: pull_request
-          GITHUB_EVENT_PATH: ${{ steps.event.outputs.event_path }}
-          GITHUB_SHA: ${{ steps.meta.outputs.head_sha }}
-          GITHUB_REPOSITORY: ${{ steps.meta.outputs.base_repo }}
         run: |
-          # On debug re-runs add reviewdog's own -log-level=debug so the
-          # cienv detection trace is visible alongside the env dump above.
+          # -log-level=debug on debug re-runs for tracing.
           LOG_FLAGS=()
           if [ "${RUNNER_DEBUG}" = "1" ]; then
             LOG_FLAGS+=(-log-level=debug)

MODULE.bazel

@@ -249,25 +249,19 @@ git_override(
     strip_prefix = "verilog",
 )
 
-# @orfs marks most non-root-only directives (qt-bazel/yosys-slang git_overrides,
+# @orfs marks non-root-only directives (qt-bazel/yosys-slang git_overrides,
 # orfs.default(), toolchain registration) as dev_dependency, so they are no-ops
-# here. But @orfs//flow loads @bazel-orfs//:openroad.bzl, and @orfs marks its
-# bazel-orfs bazel_dep dev_dependency too, which drops @bazel-orfs from @orfs's
-# repo mapping when consumed non-root — so loading @orfs//flow fails. The patch
-# makes that one bazel_dep non-dev.
+# here; its bazel-orfs bazel_dep is non-dev so @orfs//flow can load
+# @bazel-orfs//:openroad.bzl when consumed non-root.
 #
 # Use archive_override (HTTPS tarball) rather than git_override so the
 # build resolves on networks that block direct git access to github.com.
-ORFS_COMMIT = "4b3f2663609fd3f6fd8d862729de1ec5967eb4e6"
+ORFS_COMMIT = "afad87da8d1ebd6ef1bc94288b4204420975a549"
 
 bazel_dep(name = "orfs", dev_dependency = True)
 archive_override(
     module_name = "orfs",
-    patch_strip = 1,
-    patches = [
-        "//bazel/bazel-orfs-patches:0035-orfs-bazel-orfs-visible-non-root.patch",
-    ],
-    sha256 = "b6e496221b5be5a5ecd54e978a7a8157a212b67374e2ecd6c27f90d35e02b473",
+    sha256 = "3b61b0cb106bb64d5cb453dff404a346b29a16bf3614166532ffa6ef733e1f65",
     strip_prefix = "OpenROAD-flow-scripts-" + ORFS_COMMIT,
     urls = ["https://github.com/The-OpenROAD-Project/OpenROAD-flow-scripts/archive/" + ORFS_COMMIT + ".tar.gz"],
 )

bazel/bazel-orfs-patches/0035-orfs-bazel-orfs-visible-non-root.patch

@@ -45,7 +45,7 @@ cc_library(
         "//src/utl",
         "@abc",
         "@boost.stacktrace",
-        "@tcl_lang//:tcl",  # build_cleaner keep swig.cc bracket-includes <tcl.h>
+        "@tcl_lang//:tcl",
     ],
 )
 

bazel/bazel-orfs-patches/BUILD

@@ -1268,12 +1268,29 @@ void HTreeBuilder::run()
     computeLevelTopology(level, regionWidth, regionHeight);
 
     if (isNumberOfSinksTooSmall(numSinksPerSubRegion)) {
-      logger_->info(CTS,
-                    32,
-                    " Stop criterion found. Max number of sinks is {}.",
-                    options_->getMaxFanout() ? options_->getMaxFanout()
-                                             : numMaxLeafSinks_);
-      break;
+      if (options_->getMaxWl()) {
+        double maxHPWL = topologyForEachLevel_.back().getLargestSinkRegionHPWL(
+            wireSegmentUnit_);
+        if (maxHPWL < options_->getMaxWl()) {
+          logger_->info(CTS,
+                        38,
+                        " Stop criterion found. Sink region hpwl "
+                        "is smaller than max wirelength ({:.3f} um) and max "
+                        "number of sinks is {}.",
+                        static_cast<double>(options_->getMaxWl())
+                            / options_->getDbUnits(),
+                        options_->getMaxFanout() ? options_->getMaxFanout()
+                                                 : numMaxLeafSinks_);
+          break;
+        }
+      } else {
+        logger_->info(CTS,
+                      32,
+                      " Stop criterion found. Max number of sinks is {}.",
+                      options_->getMaxFanout() ? options_->getMaxFanout()
+                                               : numMaxLeafSinks_);
+        break;
+      }
     }
   }
 
@@ -1825,6 +1842,33 @@ void HTreeBuilder::initSecondLevelSinks(
   }
 }
 
+double HTreeBuilder::LevelTopology::getLargestSinkRegionHPWL(
+    const unsigned wireSegmentUnit) const
+{
+  double bestHpwl = 0.0;
+  for (unsigned i = 0; i < branchSinkLocs_.size(); ++i) {
+    const auto& sinks = branchSinkLocs_[i];
+    if (sinks.size() < 2) {
+      continue;
+    }
+    double minX = sinks[0].getX();
+    double maxX = minX;
+    double minY = sinks[0].getY();
+    double maxY = minY;
+    for (unsigned j = 1; j < sinks.size(); ++j) {
+      minX = std::min(minX, sinks[j].getX());
+      maxX = std::max(maxX, sinks[j].getX());
+      minY = std::min(minY, sinks[j].getY());
+      maxY = std::max(maxY, sinks[j].getY());
+    }
+    const double hpwl = ((maxX - minX) + (maxY - minY));
+    if (hpwl > bestHpwl) {
+      bestHpwl = hpwl;
+    }
+  }
+  return bestHpwl * wireSegmentUnit;
+}
+
 void HTreeBuilder::computeBranchSinks(
     const LevelTopology& topology,
     const unsigned branchIdx,

src/cgt/BUILD

@@ -128,6 +128,8 @@ class HTreeBuilder : public TreeBuilder
       return branchSinkLocs_[branchIdx];
     }
 
+    double getLargestSinkRegionHPWL(unsigned wireSegmentUnit) const;
+
     void setOutputSlew(unsigned slew) { outputSlew_ = slew; }
     unsigned getOutputSlew() const { return outputSlew_; }
     void setOutputCap(unsigned cap) { outputCap_ = cap; }

src/cts/src/HTreeBuilder.cpp

@@ -122,6 +122,7 @@ void TritonCTS::runTritonCts()
   sinkBuffers_.clear();
   regTreeRootBufIndex_ = 0;
   delayBufIndex_ = 0;
+  options_->setMaxWl(0);
   options_->removeOwner();
   logger_->info(CTS, 500, "Runtime: {:.2f}s", timer.elapsed());
 }
@@ -244,7 +245,9 @@ void TritonCTS::setupCharacterization()
 
   double maxWlMicrons
       = resizer_->findMaxWireLength(/* don't issue error */ false) * 1e+6;
-  options_->setMaxWl(block_->micronsToDbu(maxWlMicrons));
+  if (maxWlMicrons > 0) {
+    options_->setMaxWl(block_->micronsToDbu(maxWlMicrons));
+  }
 
   // A new characteriztion is always created.
   techChar_ = std::make_unique<TechChar>(