Skip to content

armgit / zed

Public Imported from GitHub
0

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.rs
index 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.toml
index 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.html
index 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.rs
new file mode 100644
index 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.mjs
new file mode 100644
index 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.rs
index 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?