Merge remote-tracking branch 'private/master' into rsz-fix-tie-placement

gudeh · gudeh · commit 5cee43de602f · 2026-05-04T21:49:46.000Z
diff --git a/BUILD.bazel b/BUILD.bazel
@@ -253,7 +253,10 @@ cc_library(
         "include/ord",
     ],
     visibility = ["//:__subpackages__"],
-    deps = ["@abseil-cpp//absl/synchronization"],
+    deps = [
+        "@abseil-cpp//absl/synchronization",
+        "@tcl_lang//:tcl",
+    ],
 )
 
 cc_library(
diff --git a/MODULE.bazel b/MODULE.bazel
@@ -100,7 +100,7 @@ bazel_dep(name = "verilator", version = "5.036.bcr.3", dev_dependency = True)
 bazel_dep(name = "bazel-orfs", dev_dependency = True)
 bazel_dep(name = "bazel-orfs-verilog", dev_dependency = True)
 
-BAZEL_ORFS_COMMIT = "f5e20547f93729a4f67929902aaa3386d933bad0"
+BAZEL_ORFS_COMMIT = "78f19f25cec73bdec3517a76465dec7ce17ce227"
 
 BAZEL_ORFS_REMOTE = "https://github.com/The-OpenROAD-Project/bazel-orfs.git"
 
@@ -118,6 +118,34 @@ git_override(
     strip_prefix = "verilog",
 )
 
+# bazel-orfs pulls in orfs without a version and patches yosys, relying on
+# overrides that only apply when bazel-orfs is the root module. Mirror them
+# here so OpenROAD-as-root can resolve the module graph.
+bazel_dep(name = "orfs", dev_dependency = True)
+git_override(
+    module_name = "orfs",
+    commit = "10a2baea2171059ec14cda9a5855aa26dd7572c6",
+    patch_strip = 1,
+    patches = [
+        "//bazel/bazel-orfs-patches:0035-fix-remove-non-root-overrides-from-MODULE.bazel.patch",
+    ],
+    remote = "https://github.com/The-OpenROAD-Project/OpenROAD-flow-scripts.git",
+)
+
+bazel_dep(name = "yosys", version = "0.62.bcr.2", dev_dependency = True)
+
+# yosys-slang is not on BCR. Pin to a commit on povik/yosys-slang master
+# that has the upstream Bazel build (povik/yosys-slang#310) and the
+# slang.so visibility fix (povik/yosys-slang#311). Submodules pull in
+# vendored slang and fmt sources.
+bazel_dep(name = "yosys-slang", dev_dependency = True)
+git_override(
+    module_name = "yosys-slang",
+    commit = "7753ea70431d85929292b90c33b32f6dbdb3b048",
+    init_submodules = True,
+    remote = "https://github.com/povik/yosys-slang.git",
+)
+
 # --- Extensions ---
 
 llvm = use_extension(
@@ -172,16 +200,13 @@ npm.npm_translate_lock(
 use_repo(npm, "npm")
 
 orfs = use_extension("@bazel-orfs//:extension.bzl", "orfs_repositories", dev_dependency = True)
-
-# To bump version, run: bazelisk run @bazel-orfs//:bump
 orfs.default(
-    # Official image https://hub.docker.com/r/openroad/orfs/tags
-    image = "docker.io/openroad/orfs:26Q1-816-gf40d2f346",
-    # Use OpenROAD of this repo instead of from the docker image
+    # Use OpenROAD of this repo instead of the one bundled with @orfs
     openroad = "//:openroad",
-    sha256 = "2b05a14ae8062b4af82b245d648e95fa0293e09b61b57468518b66578744afb8",
+    # Expose the yosys-slang plugin via YOSYS_PLUGIN_PATH so
+    # SYNTH_HDL_FRONTEND=slang works in mock-array and other tests.
+    yosys_plugins = ["@yosys-slang//src/yosys_plugin:slang.so"],
 )
-use_repo(orfs, "docker_orfs")
 
 # --- Overrides ---
 
diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock
diff --git a/bazel/bazel-orfs-patches/0035-fix-remove-non-root-overrides-from-MODULE.bazel.patch b/bazel/bazel-orfs-patches/0035-fix-remove-non-root-overrides-from-MODULE.bazel.patch
@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?=C3=98yvind=20Harboe?= <oyvind.harboe@zylin.com>
+Date: Wed, 2 Apr 2026 22:00:00 +0200
+Subject: [PATCH] fix: remove non-root overrides from MODULE.bazel
+
+When ORFS is fetched as a non-root dependency, git_override and
+orfs.default() directives are ignored/illegal.  Remove them so
+the module can be used as a dependency without errors.
+
+Signed-off-by: =?UTF-8?q?=C3=98yvind=20Harboe?= <oyvind.harboe@zylin.com>
+---
+ MODULE.bazel | 19 -------------------
+ 1 file changed, 19 deletions(-)
+
+diff --git a/MODULE.bazel b/MODULE.bazel
+--- a/MODULE.bazel
++++ b/MODULE.bazel
+@@ -8,13 +8,6 @@
+
+ bazel_dep(name = "bazel-orfs")
+
+-# To bump version, run: bazelisk run @bazel-orfs//:bump
+-git_override(
+-    module_name = "bazel-orfs",
+-    commit = "f8a4b694b37c8f5322323eba9a9ae37f9541ee17",
+-    remote = "https://github.com/The-OpenROAD-Project/bazel-orfs.git",
+-)
+-
+ bazel_dep(name = "rules_python", version = "1.8.5")
+ bazel_dep(name = "rules_shell", version = "0.6.1")
+
+@@ -36,15 +29,3 @@
+ use_repo(pip, "orfs-pip")
+
+ orfs = use_extension("@bazel-orfs//:extension.bzl", "orfs_repositories")
+-
+-# To bump version, run: bazelisk run @bazel-orfs//:bump
+-orfs.default(
+-    image = "docker.io/openroad/orfs:v3.0-3273-gedf3d6bf",
+-    # Use local files instead of docker image
+-    makefile = "//flow:makefile",
+-    makefile_yosys = "//flow:makefile_yosys",
+-    pdk = "//flow:asap7",
+-    sha256 = "f5692c6325ebcf27cc348e033355ec95c82c35ace1af7e72a0d352624ada143e",
+-)
+-use_repo(orfs, "com_github_nixos_patchelf_download")
+-use_repo(orfs, "docker_orfs")
+--
+2.51.0
+
diff --git a/bazel/bazel-orfs-patches/BUILD b/bazel/bazel-orfs-patches/BUILD
@@ -0,0 +1 @@
+exports_files(glob(["*.patch"]))
diff --git a/src/gpl/src/nesterovBase.cpp b/src/gpl/src/nesterovBase.cpp
@@ -4,7 +4,6 @@
 #include "nesterovBase.h"
 
 #include <algorithm>
-#include <boost/polygon/polygon.hpp>
 #include <cassert>
 #include <climits>
 #include <cmath>
@@ -23,6 +22,7 @@
 #include <utility>
 #include <vector>
 
+#include "boost/polygon/polygon.hpp"
 #include "fft.h"
 #include "gpl/Replace.h"
 #include "nesterovPlace.h"
diff --git a/src/tst/include/tst/nangate45_fixture.h b/src/tst/include/tst/nangate45_fixture.h
@@ -3,7 +3,6 @@
 
 #include <memory>
 
-#include "gtest/gtest.h"
 #include "odb/db.h"
 #include "tst/fixture.h"
 
diff --git a/src/web/BUILD b/src/web/BUILD
@@ -169,6 +169,7 @@ cc_library(
         "@boost.beast",
         "@boost.geometry",
         "@boost.json",
+        "@boost.system",
         "@spdlog",
         "@tcl_lang//:tcl",
     ],
diff --git a/src/web/include/web/web.h b/src/web/include/web/web.h
@@ -15,6 +15,7 @@
 #include <vector>
 
 #include "boost/asio/ip/tcp.hpp"
+#include "boost/asio/steady_timer.hpp"
 #include "odb/db.h"
 #include "tcl.h"
 #include "utl/Logger.h"
@@ -133,6 +134,13 @@ class WebServer
   std::unique_ptr<boost::asio::io_context> ioc_;
   std::vector<std::thread> threads_;
 
+  // Periodic timer that drains WebLogSink so log output produced by
+  // long-running Tcl commands streams to clients without waiting for a
+  // debug pause/redraw or for the command to return.  Reschedules
+  // itself; cancelled in stop() before ioc_ is shut down.
+  std::unique_ptr<boost::asio::steady_timer> log_drain_timer_;
+  void scheduleLogDrain();
+
   // Closes the Listener's acceptor before the io_context is destroyed,
   // avoiding a crash where the acceptor references a half-destroyed
   // io_context.
diff --git a/src/web/src/main.js b/src/web/src/main.js
@@ -505,12 +505,12 @@ function createTclConsole(container) {
             tclAppend(`>>> ${cmd}\n`, 'tcl-cmd');
             completer.addToHistory(cmd);
             input.value = '';
+            // Log output produced while the command runs streams in
+            // separately as {"type":"log",...} push messages (handled
+            // below in the onPush dispatch).  The eval response only
+            // carries the Tcl return value plus shutdown signaling.
             app.websocketManager.request({ type: 'tcl_eval', cmd })
                 .then(data => {
-                    if (data.output) {
-                        tclAppend(data.output,
-                                  data.is_error ? 'tcl-error' : '');
-                    }
                     if (data.result) {
                         tclAppend(data.result + '\n',
                                   data.is_error ? 'tcl-error' : '');
diff --git a/src/web/src/request_handler.cpp b/src/web/src/request_handler.cpp
@@ -1208,7 +1208,6 @@ WebSocketResponse TclHandler::handleTclEval(const WebSocketRequest& req)
     // teardown is already requested by tclExitHandler via requestStop().
     const bool is_exit = (result.result == kExitResultMsg);
     boost::json::object root;
-    root["output"] = result.output;
     if (is_exit) {
       tcl_eval_->logger->info(
           utl::WEB, 40, "Exit requested from web GUI; shutting down.");
diff --git a/src/web/src/request_handler.h b/src/web/src/request_handler.h
@@ -7,6 +7,7 @@
 #include <boost/json/value.hpp>
 #include <boost/json/value_to.hpp>
 #include <cstdint>
+#include <functional>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -36,16 +37,23 @@ class ClockTreeReport;
 // shutdown signal for the browser.
 inline constexpr const char* kExitResultMsg = "_WEB_EXITING_";
 
-// Thread-safe Tcl command evaluation with output capture.
+// Thread-safe Tcl command evaluation.  Log output emitted while the
+// command runs is captured by WebLogSink (registered on the logger via
+// addSink) and pushed to clients as {"type":"log",...} messages — do
+// NOT redirect the logger to a string here.  redirectStringBegin clears
+// the entire sink list, which would unhook WebLogSink (and any other
+// sink) for the duration of the command and break log streaming.  After
+// each eval the optional drain_output hook is invoked so any buffered
+// log output reaches clients before the eval response is sent.
 struct TclEvaluator
 {
   Tcl_Interp* interp;
   utl::Logger* logger;
   std::mutex mutex;
+  std::function<void()> drain_output;
 
   struct Result
   {
-    std::string output;
     std::string result;
     bool is_error;
   };
@@ -58,12 +66,13 @@ struct TclEvaluator
   Result eval(const std::string& cmd)
   {
     std::lock_guard<std::mutex> lock(mutex);
-    logger->redirectStringBegin();
     const int rc = Tcl_Eval(interp, cmd.c_str());
     Result r;
-    r.output = logger->redirectStringEnd();
     r.result = Tcl_GetStringResult(interp);
     r.is_error = (rc != TCL_OK);
+    if (drain_output) {
+      drain_output();
+    }
     return r;
   }
 };
diff --git a/src/web/src/web_serve.cpp b/src/web/src/web_serve.cpp
@@ -18,8 +18,13 @@
 #include <utility>
 #include <vector>
 
+#include "boost/asio/error.hpp"
 #include "boost/asio/io_context.hpp"
 #include "boost/asio/ip/tcp.hpp"
+#include "boost/asio/post.hpp"
+#include "boost/asio/steady_timer.hpp"
+#include "boost/asio/strand.hpp"
+#include "boost/system/error_code.hpp"
 // NOLINTNEXTLINE(misc-include-cleaner)
 #include "boost/beast/core.hpp"
 // NOLINTNEXTLINE(misc-include-cleaner)
@@ -168,6 +173,13 @@ void WebServer::serve(int port)
     logger_->addSink(log_sink_);
     viewer_hook_->setDrainLogsFn(
         [log_sink = std::move(log_sink)]() { log_sink->drainToClients(); });
+    // Flush WebLogSink at the end of every Tcl eval so log output
+    // emitted during a command reaches clients before the response
+    // carrying the Tcl result.  viewer_hook_ outlives every io thread
+    // that can run a request handler (stop() joins io threads before
+    // resetting viewer_hook_), so the raw pointer capture is safe.
+    tcl_eval->drain_output
+        = [hook = viewer_hook_.get()]() { hook->drainLogs(); };
 
     TileGenerator::setDebugOverlayCallback(
         [weak_gen = std::weak_ptr<TileGenerator>(generator_),
@@ -210,6 +222,17 @@ void WebServer::serve(int port)
 
     const std::string url = "http://localhost:" + std::to_string(handle.port);
 
+    // Bind the timer to a strand so all timer operations (expires_after,
+    // async_wait, cancel) run serialized on a single io thread.  Without
+    // this, stop()'s cancel from the caller thread would race with the
+    // async_wait handler rescheduling on a worker thread — the same
+    // steady_timer cannot be safely mutated from multiple threads.  The
+    // initial scheduleLogDrain() below runs before io threads start, so
+    // it is single-threaded by construction.
+    log_drain_timer_ = std::make_unique<net::steady_timer>(
+        net::make_strand(ioc_->get_executor()));
+    scheduleLogDrain();
+
     threads_.reserve(num_threads);
     for (int i = 0; i < num_threads; ++i) {
       threads_.emplace_back([this] { ioc_->run(); });
@@ -275,6 +298,32 @@ int WebServer::tclExitHandler(ClientData clientData,
   return TCL_ERROR;
 }
 
+// Drain interval chosen to keep the browser console feeling live without
+// burning CPU when nothing is logged.  An idle tick costs one mutex
+// acquire + empty-buffer check inside WebLogSink::drainToClients.
+static constexpr auto kLogDrainInterval = std::chrono::milliseconds(250);
+
+void WebServer::scheduleLogDrain()
+{
+  if (!log_drain_timer_) {
+    return;
+  }
+  log_drain_timer_->expires_after(kLogDrainInterval);
+  log_drain_timer_->async_wait([this](const boost::system::error_code& ec) {
+    // operation_aborted means cancel() was called from stop().  Any
+    // other error (or none) means the timer fired normally — drain and
+    // reschedule.  ioc_->stop() in stop() will discard a re-armed timer
+    // before its next firing, so no UAF risk on shutdown.
+    if (ec == net::error::operation_aborted) {
+      return;
+    }
+    if (viewer_hook_) {
+      viewer_hook_->drainLogs();
+    }
+    scheduleLogDrain();
+  });
+}
+
 void WebServer::requestStop()
 {
   if (!isRunning()) {
@@ -316,7 +365,20 @@ void WebServer::stop()
     shutdown_listener_();
     shutdown_listener_ = {};
   }
+  // Cancel the periodic log drain so its handler stops re-arming.  The
+  // cancel is posted onto the timer's strand so it runs serialized with
+  // scheduleLogDrain — calling cancel() directly from the caller thread
+  // would race with the async_wait handler mutating the timer on an io
+  // thread.  Any in-flight handler completes normally; a re-armed timer
+  // is discarded by ioc_->stop() below.
+  if (log_drain_timer_) {
+    auto* timer = log_drain_timer_.get();
+    net::post(timer->get_executor(), [timer] { timer->cancel(); });
+  }
   stopAndJoinIoThreads();
+  // Reset only after threads are joined so no handler can dereference
+  // the timer mid-shutdown.
+  log_drain_timer_.reset();
   // Release without destroying — destroying io_context can crash on
   // residual async handlers. Leak is bounded (at most one io_context
   // per serve/stop cycle).
diff --git a/test/orfs/README.md b/test/orfs/README.md
diff --git a/test/orfs/check_same.sh b/test/orfs/check_same.sh
diff --git a/test/orfs/gcd/README.md b/test/orfs/gcd/README.md
diff --git a/test/orfs/mock-array/README.md b/test/orfs/mock-array/README.md
diff --git a/test/orfs/mock-array/mock-array.bzl b/test/orfs/mock-array/mock-array.bzl
