Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
#![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);
}
}