Merge remote-tracking branch 'origin/master' into sta-debug

Author: gadfort

src/CMakeLists.txt

@@ -345,7 +345,6 @@ target_link_libraries(openroad
   cut
   grt
   tap
-  gui
   drt
   dst
   psm
@@ -358,6 +357,7 @@ target_link_libraries(openroad
   par
   est
   web
+  gui
   absl::synchronization
   ${ABC_LIBRARY}
   ${TCL_LIBRARY}

src/gpl/src/nesterovBase.cpp

@@ -839,26 +839,22 @@ void BinGrid::updateBinsNonPlaceArea()
   using boost::polygon::operators::operator+=;
   using boost::polygon::operators::operator&=;
 
-  // Build the union of all non-place instance rectangles. Overlapping
-  // fixed macros (or blockages) would otherwise be double-counted into
-  // the bins they share, pushing density above 100% and producing
-  // artificially large repulsive forces on movable cells.
-  Polygon90Set fixed_set;
-  for (auto& inst : pb_->nonPlaceInsts()) {
+  // For each bin, collect indices of non-place instances whose bbox
+  // overlaps it. The per-bin geometric union (which dedupes overlapping
+  // fixed macros / blockages) only depends on those instances, so we
+  // avoid copying a full design-wide polygon set per bin.
+  const auto& non_place_insts = pb_->nonPlaceInsts();
+  std::vector<std::vector<int>> bin_insts(bins_.size());
+  for (size_t i = 0; i < non_place_insts.size(); ++i) {
+    const Instance* inst = non_place_insts[i];
     if (inst->lx() >= inst->ux() || inst->ly() >= inst->uy()) {
       continue;
     }
-    fixed_set += BoostRect(inst->lx(), inst->ly(), inst->ux(), inst->uy());
-  }
-
-  // Identify bins touched by any fixed instance to skip the empty ones.
-  std::vector<bool> touched(bins_.size(), false);
-  for (auto& inst : pb_->nonPlaceInsts()) {
     std::pair<int, int> pairX = getMinMaxIdxX(inst);
     std::pair<int, int> pairY = getMinMaxIdxY(inst);
     for (int y = pairY.first; y < pairY.second; y++) {
       for (int x = pairX.first; x < pairX.second; x++) {
-        touched[y * binCntX_ + x] = true;
+        bin_insts[y * binCntX_ + x].push_back(static_cast<int>(i));
       }
     }
   }
@@ -867,13 +863,31 @@ void BinGrid::updateBinsNonPlaceArea()
   // fixed instances). Drives nonPlaceAreaUnscaled and the cap below.
   std::vector<int64_t> unionArea(bins_.size(), 0);
   for (size_t i = 0; i < bins_.size(); ++i) {
-    if (!touched[i]) {
+    const auto& touching = bin_insts[i];
+    if (touching.empty()) {
       continue;
     }
     Bin& bin = bins_[i];
-    Polygon90Set clip = fixed_set;
-    clip &= BoostRect(bin.lx(), bin.ly(), bin.ux(), bin.uy());
-    unionArea[i] = boost::polygon::area(clip);
+    if (touching.size() == 1) {
+      // Single instance: union == clipped overlap, skip Boost.Polygon.
+      const Instance* inst = non_place_insts[touching.front()];
+      const int rectLx = std::max(bin.lx(), inst->lx());
+      const int rectLy = std::max(bin.ly(), inst->ly());
+      const int rectUx = std::min(bin.ux(), inst->ux());
+      const int rectUy = std::min(bin.uy(), inst->uy());
+      if (rectLx < rectUx && rectLy < rectUy) {
+        unionArea[i] = static_cast<int64_t>(rectUx - rectLx)
+                       * static_cast<int64_t>(rectUy - rectLy);
+      }
+    } else {
+      Polygon90Set local_set;
+      for (int idx : touching) {
+        const Instance* inst = non_place_insts[idx];
+        local_set += BoostRect(inst->lx(), inst->ly(), inst->ux(), inst->uy());
+      }
+      local_set &= BoostRect(bin.lx(), bin.ly(), bin.ux(), bin.uy());
+      unionArea[i] = boost::polygon::area(local_set);
+    }
     // Note that nonPlaceArea should have scale-down with target
     // density. See MS-replace paper.
     bin.setNonPlaceAreaUnscaled(
@@ -899,7 +913,7 @@ void BinGrid::updateBinsNonPlaceArea()
     }
   }
   for (size_t i = 0; i < bins_.size(); ++i) {
-    if (!touched[i]) {
+    if (bin_insts[i].empty()) {
       continue;
     }
     Bin& bin = bins_[i];

src/grt/src/Rudy.cpp

@@ -4,6 +4,7 @@
 #include "grt/Rudy.h"
 
 #include <algorithm>
+#include <climits>
 #include <cstdint>
 #include <optional>
 #include <set>
@@ -147,6 +148,9 @@ void Rudy::processNet(odb::dbNet* net)
 
 void Rudy::processIntersectionSignalNet(const odb::Rect net_rect)
 {
+  if (net_rect.isInverted()) {
+    return;
+  }
   const auto net_area = net_rect.area();
   if (net_area == 0) {
     // TODO: handle nets with 0 area from getTermBBox()

src/grt/test/save_guideok

@@ -5,6 +5,9 @@
 
 set -e
 
+script_dir="$(dirname "$(readlink -f "$0")")/../../../test/shared"
+bazel_pending=()
+
 for test_name in "${@:1}"
 do
     if [ -f "results/${test_name}-tcl.guide" ]; then
@@ -14,6 +17,10 @@ do
         cp "results/${test_name}-py.guide" "${test_name}.guideok"
         echo "${test_name}"
     else
-        echo "\"${test_name}\" guide file not found"
+        bazel_pending+=("${test_name}")
     fi
 done
+
+if [ ${#bazel_pending[@]} -gt 0 ]; then
+    "${script_dir}/bazel_save.sh" guideok guide "${bazel_pending[@]}"
+fi

src/web/include/web/web.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <spdlog/common.h>
+
 #include <condition_variable>
 #include <cstdint>
 #include <functional>
@@ -108,29 +110,37 @@ class WebServer
                  double dbu_per_pixel,
                  const std::string& vis_json);
 
- private:
-  // Tears down the I/O threads and cleans up hooks.  Called by the
-  // destructor; safe to call multiple times.
+  // Tears down the I/O threads and cleans up hooks.  Safe to call multiple
+  // times and from any thread; after it returns, isRunning() is false and
+  // serve() may be called again to restart the server.
   void stop();
 
+ private:
+  // Stops ioc_, joins every worker thread except the current one, and
+  // clears threads_. Detaches the current thread if it happens to be a
+  // worker (would otherwise raise EDEADLK on self-join).
+  void stopAndJoinIoThreads();
+
   odb::dbDatabase* db_ = nullptr;
   sta::dbSta* sta_ = nullptr;
   utl::Logger* logger_ = nullptr;
   Tcl_Interp* interp_ = nullptr;
   int num_threads_ = 0;
   std::shared_ptr<TileGenerator> generator_;
   std::unique_ptr<WebViewerHook> viewer_hook_;
-  std::shared_ptr<spdlog::sinks::sink> log_sink_;
 
   // Background I/O context and worker threads (non-null while running).
   std::unique_ptr<boost::asio::io_context> ioc_;
   std::vector<std::thread> threads_;
 
-  // Type-erased callback that closes the Listener's acceptor before the
-  // io_context is destroyed — prevents a crash where the acceptor's
-  // destructor references the io_context that's mid-destruction.
+  // Closes the Listener's acceptor before the io_context is destroyed,
+  // avoiding a crash where the acceptor references a half-destroyed
+  // io_context.
   std::function<void()> shutdown_listener_;
 
+  // Held so stop() can remove it from the Logger before viewer_hook_ is
+  // destroyed — the sink stores a raw pointer into the hook.
+  spdlog::sink_ptr log_sink_;
   // Blocking support: waitForStop() sleeps on stop_cv_ until
   // requestStop() sets stop_requested_.
   std::mutex stop_mutex_;

src/web/src/main.js

@@ -361,6 +361,42 @@ function tclAppend(text, className) {
     app.tclOutputEl.scrollTop = app.tclOutputEl.scrollHeight;
 }
 
+// Browser UX for `exit`/`quit` typed in the Tcl console. The browser
+// override (web_serve.cpp tclExitHandler) sets exit_requested_, and
+// Main.cc calls exit(EXIT_SUCCESS) once waitForStop() returns — so the
+// whole OpenROAD process exits, not just the web session. (Compare
+// `web_server -stop`, which only stops serving and arrives here as a
+// broadcast `type: shutdown` handled below.)
+// window.close() only succeeds when the tab was opened via JS (or via
+// certain launcher integrations); when it fails we replace the page
+// with a terminal overlay so the user knows OpenROAD exited and they
+// can close the tab manually.
+function handleServerShutdown() {
+    // Idempotent: invoked from both the Tcl-eval response (`action: shutdown`)
+    // and the broadcast push (`type: shutdown`); whichever arrives first wins.
+    if (app._shutdownHandled) return;
+    app._shutdownHandled = true;
+    // Disable auto-reconnect and suppress the "disconnected" banner —
+    // the disconnect is intentional.
+    if (app.websocketManager) {
+        app.websocketManager._shutdown = true;
+        app.websocketManager.onPush = () => {};
+    }
+    const overlay = document.createElement('div');
+    overlay.style.cssText =
+        'position:fixed;inset:0;z-index:99999;background:#1e1e1e;color:#ddd;' +
+        'display:flex;flex-direction:column;align-items:center;justify-content:center;' +
+        'font-family:system-ui,sans-serif;font-size:16px;padding:24px;text-align:center;';
+    overlay.innerHTML =
+        '<div style="font-size:22px;margin-bottom:12px;">OpenROAD exited</div>' +
+        '<div style="opacity:0.7;">You can close this tab.</div>';
+    document.body.appendChild(overlay);
+    // Hold the overlay visible long enough for the user to read it before
+    // window.close() fires.  400 ms was below the perceptual threshold and
+    // looked like the tab vanished instantly on `exit`.
+    setTimeout(() => { try { window.close(); } catch (e) { /* ignore */ } }, 1500);
+}
+
 function createTclConsole(container) {
     const el = document.createElement('div');
     el.className = 'tcl-console';
@@ -396,6 +432,9 @@ function createTclConsole(container) {
                         tclAppend(data.result + '\n',
                                   data.is_error ? 'tcl-error' : '');
                     }
+                    if (data.action === 'shutdown') {
+                        handleServerShutdown();
+                    }
                 })
                 .catch(err => tclAppend(`Error: ${err}\n`, 'tcl-error'));
         }
@@ -730,7 +769,11 @@ app.websocketManager.onPush = (msg) => {
         if (text) tclAppend(text + '\n', '');
     } else if (msg.type === 'shutdown') {
         // Server is stopping intentionally (web_server -stop).
-        // Disable auto-reconnect and show a clear message.
+        // Disable auto-reconnect and show a clear message. Note that
+        // when the user typed `exit`/`quit` in the browser, the eval
+        // response's `action: shutdown` already ran handleServerShutdown
+        // (which set _shutdown and replaced onPush with a no-op), so
+        // this branch only runs in the external-stop case.
         app.websocketManager._shutdown = true;
         statusDiv.innerHTML = '<div class="disconnected-banner">Server stopped</div>';
         statusDiv.style.display = 'block';

src/web/src/request_handler.cpp

@@ -37,6 +37,7 @@
 #include "request_dispatcher.h"
 #include "tile_generator.h"
 #include "timing_report.h"
+#include "utl/Logger.h"
 
 namespace web {
 
@@ -1418,12 +1419,27 @@ WebSocketResponse TclHandler::handleTclEval(const WebSocketRequest& req)
   resp.id = req.id;
   resp.type = WebSocketResponse::kJson;
   try {
-    auto result = tcl_eval_->eval(extract_string(req.raw_json, "cmd"));
+    const std::string cmd = extract_string(req.raw_json, "cmd");
+    auto result = tcl_eval_->eval(cmd);
+    // tclExitHandler (web_serve.cpp) sets this sentinel as the Tcl
+    // result whenever `exit`/`quit` is evaluated through the override —
+    // whether typed bare in the browser or buried in `eval`/`source`.
+    // Convert it to a clean shutdown signal for the browser; the actual
+    // teardown is already requested by tclExitHandler via requestStop().
+    const bool is_exit = (result.result == kExitResultMsg);
     JsonBuilder builder;
     builder.beginObject();
     builder.field("output", result.output);
-    builder.field("result", result.result);
-    builder.field("is_error", result.is_error);
+    if (is_exit) {
+      tcl_eval_->logger->info(
+          utl::WEB, 40, "Exit requested from web GUI; shutting down.");
+      builder.field("result", "Exiting OpenROAD.");
+      builder.field("is_error", false);
+      builder.field("action", "shutdown");
+    } else {
+      builder.field("result", result.result);
+      builder.field("is_error", result.is_error);
+    }
     builder.endObject();
     const std::string& json = builder.str();
     resp.payload.assign(json.begin(), json.end());

src/web/src/request_handler.h

@@ -26,6 +26,12 @@ class RequestDispatcher;
 class TimingReport;
 class ClockTreeReport;
 
+// Sentinel string set as the Tcl result by WebServer::tclExitHandler
+// when the browser-side Tcl `exit`/`quit` is invoked.  TclHandler
+// detects this in handleTclEval and converts the response to a clean
+// shutdown signal for the browser.
+inline constexpr const char* kExitResultMsg = "_WEB_EXITING_";
+
 // Thread-safe Tcl command evaluation with output capture.
 struct TclEvaluator
 {

src/web/src/web.cpp

@@ -813,6 +813,31 @@ WebServer::WebServer(odb::dbDatabase* db,
 {
 }
 
+// Defined here (not in web_serve.cpp) so the destructor's TU does not
+// pull in web_serve.cpp's gui::Gui::get() references — keeps WebServer
+// usable from tests that don't link the full gui library.
+void WebServer::stopAndJoinIoThreads()
+{
+  if (ioc_) {
+    ioc_->stop();
+  }
+  const auto self_id = std::this_thread::get_id();
+  for (auto& t : threads_) {
+    if (!t.joinable()) {
+      continue;
+    }
+    if (t.get_id() == self_id) {
+      // Self-join would raise EDEADLK. ioc_->stop() above unblocks the
+      // worker so detaching is safe — the thread runs to completion on
+      // its own.
+      t.detach();
+    } else {
+      t.join();
+    }
+  }
+  threads_.clear();
+}
+
 WebServer::~WebServer()
 {
   // Wake any thread blocked in waitForStop() so it can return before
@@ -825,24 +850,12 @@ WebServer::~WebServer()
 
   // The destructor fires during Tcl_Exit → atexit → ~OpenRoad chain.
   // By this point the Tcl interpreter is partially torn down and static
-  // objects may be destroyed.  Calling stop() (which joins 32 threads
-  // and tears down boost::asio's reactor) triggers SIGSEGV because the
-  // reactor's internal state references destroyed statics.
-  //
-  // Since the destructor only runs at process exit, the OS reclaims all
-  // memory and closes all sockets.  We just need to stop the threads so
-  // the process can actually exit:
-  if (ioc_) {
-    ioc_->stop();
-  }
-  for (auto& t : threads_) {
-    if (t.joinable()) {
-      t.join();
-    }
-  }
-  threads_.clear();
-  // Close the Listener's acceptor and release the shared_ptr to it
-  // before the io_context goes away.
+  // objects may be destroyed.  We avoid the full stop() path (which
+  // tears down boost::asio's reactor and would crash on residual async
+  // handlers referencing destroyed statics) — the OS reclaims memory
+  // and sockets at process exit, so we only need to release the worker
+  // threads so the process can actually exit.
+  stopAndJoinIoThreads();
   if (shutdown_listener_) {
     shutdown_listener_();
     shutdown_listener_ = {};