Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
gpui: Avoid main-thread waits when unlocking web task queues (#64298)
Antonio Scandurra5c9efb75cf73
diff --git a/crates/gpui/src/queue.rs b/crates/gpui/src/queue.rsindex 76f6d67a019..3e02b1359d9 100644--- a/crates/gpui/src/queue.rs+++ b/crates/gpui/src/queue.rs@@ -2,7 +2,7 @@ use std::{collections::VecDeque,fmt,iter::FusedIterator,- sync::{Arc, atomic::AtomicUsize},+ sync::{Arc, Condvar, Mutex, MutexGuard, PoisonError, TryLockError, atomic::AtomicUsize},};use rand::{Rng, SeedableRng, rngs::SmallRng};@@ -24,8 +24,10 @@ impl<T> PriorityQueues<T> {}struct PriorityQueueState<T> {- queues: parking_lot::Mutex<PriorityQueues<T>>,- condvar: parking_lot::Condvar,+ // std's Wasm atomic backend unlocks and notifies without acquiring another+ // lock. parking_lot can park during those operations, even after try_lock.+ queues: Mutex<PriorityQueues<T>>,+ condvar: Condvar,receiver_count: AtomicUsize,sender_count: AtomicUsize,}@@ -40,7 +42,7 @@ impl<T> PriorityQueueState<T> {return Err(SendError(item));}- let mut queues = self.queues.lock();+ let mut queues = self.queues.lock().unwrap_or_else(PoisonError::into_inner);Self::push(&mut queues, priority, item);self.condvar.notify_one();Ok(())@@ -56,10 +58,11 @@ impl<T> PriorityQueueState<T> {}let mut queues = loop {- if let Some(guard) = self.queues.try_lock() {- break guard;+ match self.queues.try_lock() {+ Ok(guard) => break guard,+ Err(TryLockError::Poisoned(error)) => break error.into_inner(),+ Err(TryLockError::WouldBlock) => std::hint::spin_loop(),}- std::hint::spin_loop();};Self::push(&mut queues, priority, item);self.condvar.notify_one();@@ -77,8 +80,8 @@ impl<T> PriorityQueueState<T> {};}- fn recv<'a>(&'a self) -> Result<parking_lot::MutexGuard<'a, PriorityQueues<T>>, RecvError> {- let mut queues = self.queues.lock();+ fn recv<'a>(&'a self) -> Result<MutexGuard<'a, PriorityQueues<T>>, RecvError> {+ let mut queues = self.queues.lock().unwrap_or_else(PoisonError::into_inner);let sender_count = self.sender_count.load(std::sync::atomic::Ordering::Relaxed);if queues.is_empty() && sender_count == 0 {@@ -86,16 +89,17 @@ impl<T> PriorityQueueState<T> {}while queues.is_empty() {- self.condvar.wait(&mut queues);+ queues = self+ .condvar+ .wait(queues)+ .unwrap_or_else(PoisonError::into_inner);}Ok(queues)}- fn try_recv<'a>(- &'a self,- ) -> Result<Option<parking_lot::MutexGuard<'a, PriorityQueues<T>>>, RecvError> {- let mut queues = self.queues.lock();+ fn try_recv<'a>(&'a self) -> Result<Option<MutexGuard<'a, PriorityQueues<T>>>, RecvError> {+ let queues = self.queues.lock().unwrap_or_else(PoisonError::into_inner);let sender_count = self.sender_count.load(std::sync::atomic::Ordering::Relaxed);if queues.is_empty() && sender_count == 0 {@@ -109,14 +113,13 @@ impl<T> PriorityQueueState<T> {}}- fn spin_try_recv<'a>(- &'a self,- ) -> Result<Option<parking_lot::MutexGuard<'a, PriorityQueues<T>>>, RecvError> {+ fn spin_try_recv<'a>(&'a self) -> Result<Option<MutexGuard<'a, PriorityQueues<T>>>, RecvError> {let queues = loop {- if let Some(guard) = self.queues.try_lock() {- break guard;+ match self.queues.try_lock() {+ Ok(guard) => break guard,+ Err(TryLockError::Poisoned(error)) => break error.into_inner(),+ Err(TryLockError::WouldBlock) => std::hint::spin_loop(),}- std::hint::spin_loop();};let sender_count = self.sender_count.load(std::sync::atomic::Ordering::Relaxed);@@ -198,12 +201,12 @@ pub struct RecvError;impl<T> PriorityQueueReceiver<T> {pub fn new() -> (PriorityQueueSender<T>, Self) {let state = PriorityQueueState {- queues: parking_lot::Mutex::new(PriorityQueues {+ queues: Mutex::new(PriorityQueues {high_priority: VecDeque::new(),medium_priority: VecDeque::new(),low_priority: VecDeque::new(),}),- condvar: parking_lot::Condvar::new(),+ condvar: Condvar::new(),receiver_count: AtomicUsize::new(1),sender_count: AtomicUsize::new(1),};@@ -222,12 +225,20 @@ impl<T> PriorityQueueReceiver<T> {/// Returns whether the queue currently contains no elements.pub fn is_empty(&self) -> bool {- self.state.queues.lock().is_empty()+ self.state+ .queues+ .lock()+ .unwrap_or_else(PoisonError::into_inner)+ .is_empty()}/// Returns the number of queued elements across all priorities.pub(crate) fn len(&self) -> usize {- let queues = self.state.queues.lock();+ let queues = self+ .state+ .queues+ .lock()+ .unwrap_or_else(PoisonError::into_inner);queues.high_priority.len() + queues.medium_priority.len() + queues.low_priority.len()}diff --git a/crates/gpui_web/examples/hello_web/Cargo.toml b/crates/gpui_web/examples/hello_web/Cargo.tomlindex 20826a799fa..85450a97f52 100644--- a/crates/gpui_web/examples/hello_web/Cargo.toml+++ b/crates/gpui_web/examples/hello_web/Cargo.toml@@ -34,6 +34,10 @@ path = "../../../gpui/examples/input.rs"name = "font_fallback_test"path = "font_fallback_test.rs"+[[bin]]+name = "queue_test"+path = "queue_test.rs"+[[bin]]name = "dynamic_fonts"path = "dynamic_fonts.rs"@@ -46,5 +50,6 @@ gpui_platform = { path = "../../../gpui_platform" }gpui_util = { path = "../../../gpui_util" }unicode-segmentation = "1"wasm-bindgen = "0.2"+wasm_thread = { git = "https://github.com/zed-industries/wasm_thread", rev = "0cf96c7708dfb97ccf3da50347e25edcf75d6937", features = ["es_modules"] }web-sys = { version = "0.3", features = ["console", "Location", "Window"] }web-time = "1"diff --git a/crates/gpui_web/examples/hello_web/index.html b/crates/gpui_web/examples/hello_web/index.htmlindex 1ae203395ca..62680135dae 100644--- a/crates/gpui_web/examples/hello_web/index.html+++ b/crates/gpui_web/examples/hello_web/index.html@@ -15,6 +15,7 @@<script data-trunk type="module" src="gallery.js"></script><link data-trunk rel="rust" data-type="worker" data-bin="dynamic_fonts" data-bindgen-target="web" data-keep-debug data-wasm-opt="0" /><link data-trunk rel="rust" data-type="worker" data-bin="font_fallback_test" data-bindgen-target="web" data-keep-debug data-wasm-opt="0" />+ <link data-trunk rel="rust" data-type="worker" data-bin="queue_test" data-bindgen-target="web" data-keep-debug data-wasm-opt="0" /><style>* {margin: 0;diff --git a/crates/gpui_web/examples/hello_web/queue_test.rs b/crates/gpui_web/examples/hello_web/queue_test.rsnew file mode 100644index 00000000000..57f8e70660d--- /dev/null+++ b/crates/gpui_web/examples/hello_web/queue_test.rs@@ -0,0 +1,122 @@+#![feature(stdarch_wasm_atomic_wait)]++use gpui::{Priority, PriorityQueueReceiver, PriorityQueueSender};+use std::sync::{+ Arc,+ atomic::{AtomicUsize, Ordering},+};+use wasm_bindgen::prelude::*;++fn main() {}++/// Exercises both directions of a queue shared by the browser and real workers.+#[wasm_bindgen]+pub struct QueueStress {+ sender: PriorityQueueSender<Option<usize>>,+ receiver: PriorityQueueReceiver<usize>,+ ready: Arc<AtomicUsize>,+ stopped: Arc<AtomicUsize>,+ workers: Vec<wasm_thread::JoinHandle<()>>,+ seen: Vec<bool>,+ sent: usize,+ received: usize,+}++#[wasm_bindgen]+impl QueueStress {+ #[wasm_bindgen(constructor)]+ pub fn new(worker_count: usize, item_count: usize) -> Self {+ assert!(worker_count > 0 && item_count > 0);+ let (sender, receiver) = PriorityQueueReceiver::<Option<usize>>::new();+ let (reply_sender, reply_receiver) = PriorityQueueReceiver::new();+ let reply_sender = Arc::new(reply_sender);+ let ready = Arc::new(AtomicUsize::new(0));+ let stopped = Arc::new(AtomicUsize::new(0));+ let workers = (0..worker_count)+ .map(|_| {+ let mut receiver = receiver.clone();+ let reply_sender = reply_sender.clone();+ let ready = ready.clone();+ let stopped = stopped.clone();+ wasm_thread::spawn(move || {+ ready.fetch_add(1, Ordering::Release);+ while let Some(item) = receiver.pop().expect("receive work") {+ reply_sender.send(priority(item), item).expect("send reply");+ }+ stopped.fetch_add(1, Ordering::Release);+ })+ })+ .collect();+ Self {+ sender,+ receiver: reply_receiver,+ ready,+ stopped,+ workers,+ seen: vec![false; item_count],+ sent: 0,+ received: 0,+ }+ }++ pub fn ready(&self) -> bool {+ self.ready.load(Ordering::Acquire) == self.workers.len()+ }++ pub fn send_batch(&mut self, count: usize) {+ let end = (self.sent + count).min(self.seen.len());+ for item in self.sent..end {+ self.sender+ .spin_send(priority(item), Some(item))+ .expect("send work from browser main thread");+ }+ self.sent = end;+ }++ pub fn drain(&mut self) -> usize {+ while let Some(item) = self+ .receiver+ .spin_try_pop()+ .expect("receive reply on browser main thread")+ {+ let seen = self.seen.get_mut(item).expect("unexpected reply");+ assert!(!*seen, "duplicate reply");+ *seen = true;+ self.received += 1;+ }+ self.received+ }++ pub fn stop(&mut self) {+ assert_eq!(self.sent, self.seen.len());+ assert_eq!(self.received, self.sent);+ assert!(self.seen.iter().all(|seen| *seen));+ // The queue's existing disconnect behavior does not wake empty receivers.+ for _ in &self.workers {+ self.sender+ .spin_send(Priority::Low, None)+ .expect("stop worker");+ }+ }++ pub fn stopped(&self) -> bool {+ self.stopped.load(Ordering::Acquire) == self.workers.len()+ }+}++fn priority(item: usize) -> Priority {+ match item % 3 {+ 0 => Priority::High,+ 1 => Priority::Medium,+ _ => Priority::Low,+ }+}++/// Negative control: a browser-main Wasm atomic wait must trap, even with zero timeout.+#[wasm_bindgen]+pub fn forbidden_main_thread_wait() {+ let value = std::sync::atomic::AtomicI32::new(0);+ unsafe {+ std::arch::wasm32::memory_atomic_wait32(value.as_ptr(), 0, 0);+ }+}diff --git a/crates/gpui_web/examples/hello_web/test_queue.mjs b/crates/gpui_web/examples/hello_web/test_queue.mjsnew file mode 100644index 00000000000..31f127e7739--- /dev/null+++ b/crates/gpui_web/examples/hello_web/test_queue.mjs@@ -0,0 +1,119 @@+// With the hello_web gallery served by Trunk:+// node test_queue.mjs http://127.0.0.1:8080 [worker-count]+import assert from "node:assert/strict";+import fs from "node:fs";+import path from "node:path";+import { spawn } from "node:child_process";+import { fileURLToPath } from "node:url";++const origin = new URL(process.argv[2] ?? "http://127.0.0.1:8080").origin;+const workers = Number(process.argv[3] ?? 8);+assert.ok(Number.isInteger(workers) && workers > 0);+const chrome = process.env.CHROME ??+ (process.platform === "darwin"+ ? "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"+ : "chromium");+const output = path.join(path.dirname(fileURLToPath(import.meta.url)), "target", "queue-test", String(Date.now()));+fs.mkdirSync(output, { recursive: true });+const log = fs.openSync(path.join(output, "chrome.log"), "w");+const browser = spawn(chrome, [+ "--headless=new", "--no-first-run", "--no-default-browser-check",+ "--remote-debugging-port=0", `--user-data-dir=${path.join(output, "profile")}`,+ "about:blank",+], { stdio: ["ignore", log, log] });+const delay = milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds));+let launchError;+browser.on("error", error => { launchError = error; });+let socket;+try {+ let port;+ for (let attempt = 0; attempt < 100; attempt++) {+ if (launchError) throw launchError;+ if (browser.exitCode !== null) throw new Error(`Chrome exited; see ${output}/chrome.log`);+ const portFile = path.join(output, "profile", "DevToolsActivePort");+ if (fs.existsSync(portFile)) {+ port = fs.readFileSync(portFile, "utf8").split("\n")[0];+ break;+ }+ await delay(100);+ }+ assert.ok(port, "Chrome did not start");+ const pages = await (await fetch(`http://127.0.0.1:${port}/json/list`)).json();+ socket = new WebSocket(pages.find(page => page.type === "page").webSocketDebuggerUrl);+ await new Promise((resolve, reject) => {+ socket.addEventListener("open", resolve, { once: true });+ socket.addEventListener("error", reject, { once: true });+ });+ let nextId = 0;+ const pending = new Map();+ const errors = [];+ socket.addEventListener("message", ({ data }) => {+ const message = JSON.parse(data);+ if (message.id) {+ const request = pending.get(message.id);+ if (!request) return;+ pending.delete(message.id);+ clearTimeout(request.timer);+ if (message.error) request.reject(new Error(JSON.stringify(message.error)));+ else request.resolve(message.result);+ } else if (message.method === "Runtime.exceptionThrown") {+ errors.push(message.params);+ }+ });+ const call = (method, params = {}) => new Promise((resolve, reject) => {+ const id = ++nextId;+ // This deadline runs outside the page, so it also catches a main-thread hang.+ const timer = setTimeout(() => reject(new Error(`Timed out: ${method}`)), 120_000);+ timer.unref();+ pending.set(id, { resolve, reject, timer });+ socket.send(JSON.stringify({ id, method, params }));+ });+ await call("Runtime.enable");+ await call("Page.enable");+ const loaded = new Promise((resolve, reject) => {+ const timer = setTimeout(() => reject(new Error("Page did not load")), 10_000);+ socket.addEventListener("message", function onLoad({ data }) {+ if (JSON.parse(data).method === "Page.loadEventFired") {+ clearTimeout(timer);+ socket.removeEventListener("message", onLoad);+ resolve();+ }+ });+ });+ await call("Page.navigate", { url: origin });+ await loaded;+ const result = await call("Runtime.evaluate", {+ awaitPromise: true, returnByValue: true,+ expression: `(async () => {+ if (!crossOriginIsolated) throw new Error("Shared-memory isolation headers are required");+ const fixture = await import("/queue_test.js");+ await fixture.default();+ let trapped = false;+ try { fixture.forbidden_main_thread_wait(); }+ catch (error) { trapped = error instanceof WebAssembly.RuntimeError; }+ if (!trapped) throw new Error("Main-thread Wasm waits must trap in this browser");+ const rounds = 128, batch = 4096;+ const stress = new fixture.QueueStress(${workers}, rounds * batch);+ const yieldToBrowser = () => new Promise(resolve => setTimeout(resolve, 2));+ while (!stress.ready()) await yieldToBrowser();+ for (let round = 0; round < rounds; round++) {+ stress.send_batch(batch);+ while (stress.drain() !== (round + 1) * batch) await yieldToBrowser();+ // Let the request queue empty so workers repeatedly park and get notified.+ await yieldToBrowser();+ }+ stress.stop();+ while (!stress.stopped()) await yieldToBrowser();+ stress.free();+ return { workers: ${workers}, items: rounds * batch, rounds };+ })()`,+ });+ assert.equal(result.exceptionDetails, undefined, JSON.stringify(result.exceptionDetails));+ assert.deepEqual(errors, [], JSON.stringify(errors));+ assert.equal(result.result.value.items, 128 * 4096);+ console.log("PASS: main-thread/worker queue contention", result.result.value);+} finally {+ socket?.close();+ browser.kill();+ fs.closeSync(log);+}diff --git a/crates/gpui_web/src/dispatcher.rs b/crates/gpui_web/src/dispatcher.rsindex 37ba891f70e..721ce6f7c23 100644--- a/crates/gpui_web/src/dispatcher.rs+++ b/crates/gpui_web/src/dispatcher.rs@@ -51,7 +51,7 @@ enum MainThreadItem {struct MainThreadMailbox {sender: PriorityQueueSender<MainThreadItem>,- receiver: parking_lot::Mutex<PriorityQueueReceiver<MainThreadItem>>,+ receiver: std::sync::Mutex<PriorityQueueReceiver<MainThreadItem>>,signal: AtomicI32,}@@ -60,7 +60,7 @@ impl MainThreadMailbox {let (sender, receiver) = PriorityQueueReceiver::new();Self {sender,- receiver: parking_lot::Mutex::new(receiver),+ receiver: std::sync::Mutex::new(receiver),signal: AtomicI32::new(0),}}@@ -77,7 +77,11 @@ impl MainThreadMailbox {}fn drain(&self, window: &web_sys::Window) {- let mut receiver = self.receiver.lock();+ // Only the main thread accesses this receiver; never park if that changes.+ let mut receiver = self+ .receiver+ .try_lock()+ .expect("main-thread mailbox receiver must not be locked");loop {// We need these `spin` variants because we can't acquire a lock on the main thread.// TODO-WASM: Should we do something different?