Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
gpui: Expose threaded dispatcher for tests (#62096)
Nathan Sobo8886dcb0d4ea
diff --git a/crates/gpui/src/app/bench_context.rs b/crates/gpui/src/app/bench_context.rsindex 3085776d702..4c68bd50f56 100644--- a/crates/gpui/src/app/bench_context.rs+++ b/crates/gpui/src/app/bench_context.rs@@ -10,17 +10,17 @@ use anyhow::{Result, anyhow};use hdrhistogram::Histogram;use crate::{- AnyView, AnyWindowHandle, App, AppCell, AppContext, BackgroundExecutor, BenchDispatcher,- Bounds, Context, Empty, Entity, EntityId, Focusable, ForegroundExecutor, Global, Platform,- PlatformHeadlessRenderer, PlatformTextSystem, Render, Reservation, Task, TestPlatform,- VisualContext, Window, WindowBounds, WindowHandle, WindowOptions,+ AnyView, AnyWindowHandle, App, AppCell, AppContext, BackgroundExecutor, Bounds, Context, Empty,+ Entity, EntityId, Focusable, ForegroundExecutor, Global, Platform, PlatformHeadlessRenderer,+ PlatformTextSystem, Render, Reservation, Task, TestPlatform, ThreadedDispatcher, VisualContext,+ Window, WindowBounds, WindowHandle, WindowOptions,app::GpuiBorrow,profiler::{self, FrameTiming, FrameTimingCollector},};/// Returns a benchmark platform backed by this thread's shared dispatcher.///-/// The platform uses this thread's shared multithreaded [`BenchDispatcher`], so+/// The platform uses this thread's shared multithreaded [`ThreadedDispatcher`], so/// background work runs with production concurrency in real time. The dispatcher/// is cached per thread and reused across benchmark invocations so worker and/// timer threads persist for the whole process instead of being recreated for@@ -42,10 +42,10 @@ pub fn bench_platform(text_system: Arc<dyn PlatformTextSystem>,) -> Rc<dyn Platform> {thread_local! {- static DISPATCHER: OnceCell<Arc<BenchDispatcher>> = const { OnceCell::new() };+ static DISPATCHER: OnceCell<Arc<ThreadedDispatcher>> = const { OnceCell::new() };}let dispatcher = DISPATCHER.with(|cell| {- cell.get_or_init(|| Arc::new(BenchDispatcher::new()))+ cell.get_or_init(|| Arc::new(ThreadedDispatcher::new())).clone()});let background_executor = BackgroundExecutor::new(dispatcher.clone());@@ -276,7 +276,7 @@ pub struct BenchAppContext<'a, 'measurement> {impl<'a, 'measurement> BenchAppContext<'a, 'measurement> {/// Creates a new benchmark app context backed by the provided platform.///- /// The platform's executors must be backed by a [`BenchDispatcher`]+ /// The platform's executors must be backed by a [`ThreadedDispatcher`]/// (see [`bench_platform`]) so the context can drain foreground work via/// [`Self::run_until_idle`]; panics otherwise.pub fn new(@@ -289,7 +289,7 @@ impl<'a, 'measurement> BenchAppContext<'a, 'measurement> {/// Creates a new benchmark app context backed by the provided platform.///- /// The platform's executors must be backed by a [`BenchDispatcher`]+ /// The platform's executors must be backed by a [`ThreadedDispatcher`]/// (see [`bench_platform`]) so the context can drain foreground work via/// [`Self::run_until_idle`]; panics otherwise.#[doc(hidden)]@@ -312,9 +312,9 @@ impl<'a, 'measurement> BenchAppContext<'a, 'measurement> {// Validate up front so misconfiguration fails at construction with a// clear message instead of deep inside `run_until_idle`.assert!(- background_executor.dispatcher().as_bench().is_some(),+ background_executor.dispatcher().as_threaded().is_some(),"BenchAppContext requires a platform whose executors are backed by a \- BenchDispatcher; construct one with gpui::bench_platform"+ ThreadedDispatcher; construct one with gpui::bench_platform");let foreground_executor = platform.foreground_executor();let asset_source = Arc::new(());@@ -360,11 +360,11 @@ impl<'a, 'measurement> BenchAppContext<'a, 'measurement> {/// Runs queued foreground tasks on this thread and waits for in flight/// background work to finish. Timers that aren't due yet are not waited- /// for (see [`BenchDispatcher::run_until_idle`]).+ /// for (see [`ThreadedDispatcher::run_until_idle`]).pub fn run_until_idle(&self) {self.background_executor.dispatcher()- .as_bench()+ .as_threaded().expect("validated in BenchAppContext::build").run_until_idle();}@@ -414,7 +414,7 @@ impl<'a, 'measurement> BenchAppContext<'a, 'measurement> {let mut benchmark = || {dispatcher- .as_bench()+ .as_threaded().expect("validated in BenchAppContext::build").run_ready_main_tasks();self.with_window(view.entity_id(), |window, cx| {@@ -496,7 +496,7 @@ impl<'a, 'measurement> BenchAppContext<'a, 'measurement> {let dispatcher = self.background_executor.dispatcher();let dispatcher = dispatcher- .as_bench()+ .as_threaded().expect("validated in BenchAppContext::build");drop(self.app);diff --git a/crates/gpui/src/gpui.rs b/crates/gpui/src/gpui.rsindex 4b1679cbe44..1cb41d46f7f 100644--- a/crates/gpui/src/gpui.rs+++ b/crates/gpui/src/gpui.rs@@ -41,7 +41,7 @@ pub mod profiler;target_os = "windows",target_os = "linux",target_family = "wasm",- feature = "bench"+ feature = "test-support"))]#[expect(missing_docs)]pub mod queue;diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rsindex 9d4146a31ed..5523b9c0e0f 100644--- a/crates/gpui/src/platform.rs+++ b/crates/gpui/src/platform.rs@@ -9,8 +9,8 @@ pub mod layer_shell;/// Types for configuring parent-anchored popup windows such as menus, dropdowns and tooltips.pub mod popup;-#[cfg(any(test, feature = "bench"))]-mod bench_dispatcher;+#[cfg(any(test, feature = "test-support"))]+mod threaded_dispatcher;#[cfg(any(test, feature = "test-support"))]mod test;@@ -83,8 +83,8 @@ pub(crate) use test::*;#[cfg(any(test, feature = "test-support"))]pub use test::{TestDispatcher, TestScreenCaptureSource, TestScreenCaptureStream};-#[cfg(any(test, feature = "bench"))]-pub use bench_dispatcher::BenchDispatcher;+#[cfg(any(test, feature = "test-support"))]+pub use threaded_dispatcher::ThreadedDispatcher;#[cfg(all(target_os = "macos", any(test, feature = "test-support")))]pub use visual_test::VisualTestPlatform;@@ -1041,10 +1041,10 @@ pub trait PlatformDispatcher: Send + Sync {None}- // This cfg must match the `bench_dispatcher` module's, which implements+ // This cfg must match the `threaded_dispatcher` module's, which implements// this method whenever it compiles.- #[cfg(any(test, feature = "bench"))]- fn as_bench(&self) -> Option<&BenchDispatcher> {+ #[cfg(any(test, feature = "test-support"))]+ fn as_threaded(&self) -> Option<&ThreadedDispatcher> {None}}diff --git a/crates/gpui/src/platform/bench_dispatcher.rs b/crates/gpui/src/platform/threaded_dispatcher.rssimilarity index 89%rename from crates/gpui/src/platform/bench_dispatcher.rsrename to crates/gpui/src/platform/threaded_dispatcher.rsindex 139434bd187..be130691dab 100644--- a/crates/gpui/src/platform/bench_dispatcher.rs+++ b/crates/gpui/src/platform/threaded_dispatcher.rs@@ -14,19 +14,18 @@ use crate::{const MIN_THREADS: usize = 2;-/// A multithreaded [`PlatformDispatcher`] for benchmarks.+/// A multithreaded [`PlatformDispatcher`] for tests and benchmarks.////// Background tasks run in parallel on a pool of worker threads and timers fire/// in real time on a dedicated timer thread, mirroring the production/// dispatchers (see `LinuxDispatcher`). Main-thread tasks are queued until the-/// benchmark thread drains them via [`Self::run_until_idle`], since there is no+/// creating thread drains them via [`Self::run_until_idle`], since there is no/// platform run loop pumping them.////// Unlike [`TestDispatcher`](crate::TestDispatcher), which runs everything on a/// single thread with a virtual clock, work dispatched through this dispatcher-/// executes with production concurrency, so wall-clock measurements reflect-/// real parallelism.-pub struct BenchDispatcher {+/// executes with production concurrency.+pub struct ThreadedDispatcher {background_sender: PriorityQueueSender<RunnableVariant>,main_sender: PriorityQueueSender<RunnableVariant>,main_receiver: Mutex<PriorityQueueReceiver<RunnableVariant>>,@@ -36,7 +35,7 @@ pub struct BenchDispatcher {}/// Tracks how many background and timer runnables are queued or running so-/// [`BenchDispatcher::run_until_idle`] knows when to stop waiting.+/// [`ThreadedDispatcher::run_until_idle`] knows when to stop waiting.#[derive(Default)]struct IdleTracker {inflight: Mutex<usize>,@@ -112,17 +111,17 @@ impl Ord for TimerEntry {}}-impl Default for BenchDispatcher {+impl Default for ThreadedDispatcher {fn default() -> Self {Self::new()}}-impl BenchDispatcher {+impl ThreadedDispatcher {/// Creates a dispatcher whose main thread is the calling thread.////// Worker and timer threads live for the lifetime of the process; the- /// dispatcher is expected to be created once and reused across benchmarks.+ /// dispatcher is expected to be created once and reused.pub fn new() -> Self {let (background_sender, background_receiver) = PriorityQueueReceiver::new();let (main_sender, main_receiver) = PriorityQueueReceiver::new();@@ -134,7 +133,7 @@ impl BenchDispatcher {let mut receiver: PriorityQueueReceiver<RunnableVariant> = background_receiver.clone();let idle = idle.clone();thread::Builder::new()- .name(format!("BenchWorker-{i}"))+ .name(format!("ThreadedDispatcherWorker-{i}")).spawn(move || {while let Ok(runnable) = receiver.pop() {let _decrement = idle.decrement_on_drop();@@ -145,7 +144,7 @@ impl BenchDispatcher {profiler::save_task_timing();}})- .expect("failed to spawn benchmark worker thread");+ .expect("failed to spawn threaded dispatcher worker");}drop(background_receiver);@@ -160,7 +159,7 @@ impl BenchDispatcher {let timers = timers.clone();let idle = idle.clone();thread::Builder::new()- .name("BenchTimer".to_owned())+ .name("ThreadedDispatcherTimer".to_owned()).spawn(move || {let mut state = timers.state.lock();loop {@@ -196,7 +195,7 @@ impl BenchDispatcher {state = timers.state.lock();}})- .expect("failed to spawn benchmark timer thread");+ .expect("failed to spawn threaded dispatcher timer");}Self {@@ -221,7 +220,7 @@ impl BenchDispatcher {pub fn run_until_idle(&self) {assert!(self.is_main_thread(),- "run_until_idle must be called on the benchmark main thread"+ "run_until_idle must be called on the threaded dispatcher's main thread");loop {if self.drain_main_queue() {@@ -263,13 +262,13 @@ impl BenchDispatcher {pub fn run_ready_main_tasks(&self) -> bool {assert!(self.is_main_thread(),- "run_ready_main_tasks must be called on the benchmark main thread"+ "run_ready_main_tasks must be called on the threaded dispatcher's main thread");self.drain_main_queue()}- /// Cancels all pending timers so timers armed by one benchmark can't fire- /// during a later benchmark sharing this process-lifetime dispatcher.+ /// Cancels all pending timers so timers armed by one workload can't fire+ /// during a later workload sharing this process-lifetime dispatcher.////// Dropping a timer runnable drops its completion sender, waking the task/// awaiting the timer. Call [`Self::run_until_idle`] after this method to@@ -287,13 +286,13 @@ impl BenchDispatcher {}/// Describes the dispatcher's idle-tracking state, for diagnosing- /// benchmarks that fail to reach quiescence.+ /// workloads that fail to reach quiescence.pub fn debug_state(&self) -> String {let inflight = *self.idle.inflight.lock();let timers = self.timers.state.lock().heap.len();let main_queue_has_work = self.main_queue_has_work();format!(- "BenchDispatcher {{ inflight: {inflight}, pending_timers: {timers}, \+ "ThreadedDispatcher {{ inflight: {inflight}, pending_timers: {timers}, \main_queue_has_work: {main_queue_has_work} }}")}@@ -331,7 +330,7 @@ impl BenchDispatcher {}}-impl PlatformDispatcher for BenchDispatcher {+impl PlatformDispatcher for ThreadedDispatcher {fn is_main_thread(&self) -> bool {thread::current().id() == self.main_thread_id}@@ -340,7 +339,7 @@ impl PlatformDispatcher for BenchDispatcher {self.idle.increment();self.background_sender.send(priority, runnable)- .unwrap_or_else(|_| panic!("benchmark worker threads are no longer running"));+ .unwrap_or_else(|_| panic!("threaded dispatcher workers are no longer running"));}fn dispatch_on_main_thread(&self, runnable: RunnableVariant, priority: Priority) {@@ -369,15 +368,15 @@ impl PlatformDispatcher for BenchDispatcher {}fn spawn_realtime(&self, f: Box<dyn FnOnce() + Send>) {- // Benchmarks don't need realtime scheduling priority; a plain thread- // keeps this portable.+ // This dispatcher does not need realtime scheduling priority; a plain+ // thread keeps it portable.thread::Builder::new()- .name("BenchRealtime".to_owned())+ .name("ThreadedDispatcherRealtime".to_owned()).spawn(f)- .expect("failed to spawn benchmark realtime thread");+ .expect("failed to spawn threaded dispatcher realtime thread");}- fn as_bench(&self) -> Option<&BenchDispatcher> {+ fn as_threaded(&self) -> Option<&ThreadedDispatcher> {Some(self)}}@@ -391,7 +390,7 @@ mod tests {#[test]fn run_ready_main_tasks_does_not_wait_for_background_handoffs() {- let dispatcher = Arc::new(BenchDispatcher::new());+ let dispatcher = Arc::new(ThreadedDispatcher::new());let background = BackgroundExecutor::new(dispatcher.clone());let foreground = ForegroundExecutor::new(dispatcher.clone());@@ -423,7 +422,7 @@ mod tests {#[test]fn run_until_idle_completes_background_to_main_handoffs() {- let dispatcher = Arc::new(BenchDispatcher::new());+ let dispatcher = Arc::new(ThreadedDispatcher::new());let background = BackgroundExecutor::new(dispatcher.clone());let foreground = ForegroundExecutor::new(dispatcher.clone());@@ -452,7 +451,7 @@ mod tests {#[test]fn timers_fire_in_real_time() {- let dispatcher = Arc::new(BenchDispatcher::new());+ let dispatcher = Arc::new(ThreadedDispatcher::new());let background = BackgroundExecutor::new(dispatcher);let fired = Arc::new(AtomicBool::new(false));@@ -476,7 +475,7 @@ mod tests {#[test]fn cancel_pending_timers_wakes_waiters_without_waiting_for_deadline() {- let dispatcher = Arc::new(BenchDispatcher::new());+ let dispatcher = Arc::new(ThreadedDispatcher::new());let background = BackgroundExecutor::new(dispatcher.clone());let fired = Arc::new(AtomicBool::new(false));