Start work on a deterministic executor for tests

Co-Authored-By: Nathan Sobo <nathan@zed.dev>

gpui/src/app.rs

@@ -119,6 +119,7 @@ impl App {
         let foreground = Rc::new(executor::Foreground::test());
         let cx = Rc::new(RefCell::new(MutableAppContext::new(
             foreground,
+            Arc::new(executor::Background::new()),
             Arc::new(platform),
             Rc::new(foreground_platform),
             (),
@@ -134,6 +135,7 @@ impl App {
         let foreground = Rc::new(executor::Foreground::platform(platform.dispatcher())?);
         let app = Self(Rc::new(RefCell::new(MutableAppContext::new(
             foreground,
+            Arc::new(executor::Background::new()),
             platform.clone(),
             foreground_platform.clone(),
             asset_source,
@@ -237,11 +239,16 @@ impl App {
 }
 
 impl TestAppContext {
-    pub fn new(foreground: Rc<executor::Foreground>, first_entity_id: usize) -> Self {
+    pub fn new(
+        foreground: Rc<executor::Foreground>,
+        background: Arc<executor::Background>,
+        first_entity_id: usize,
+    ) -> Self {
         let platform = Arc::new(platform::test::platform());
         let foreground_platform = Rc::new(platform::test::foreground_platform());
         let mut cx = MutableAppContext::new(
             foreground.clone(),
+            background,
             platform,
             foreground_platform.clone(),
             (),
@@ -566,6 +573,7 @@ pub struct MutableAppContext {
 impl MutableAppContext {
     fn new(
         foreground: Rc<executor::Foreground>,
+        background: Arc<executor::Background>,
         platform: Arc<dyn platform::Platform>,
         foreground_platform: Rc<dyn platform::ForegroundPlatform>,
         asset_source: impl AssetSource,
@@ -582,7 +590,7 @@ impl MutableAppContext {
                 windows: Default::default(),
                 values: Default::default(),
                 ref_counts: Arc::new(Mutex::new(RefCounts::default())),
-                background: Arc::new(executor::Background::new()),
+                background,
                 thread_pool: scoped_pool::Pool::new(num_cpus::get(), "app"),
                 font_cache: Arc::new(FontCache::new(fonts)),
             },

gpui/src/executor.rs

@@ -1,9 +1,12 @@
 use anyhow::{anyhow, Result};
 use async_task::Runnable;
 pub use async_task::Task;
+use parking_lot::Mutex;
+use rand::prelude::*;
 use smol::prelude::*;
 use smol::{channel, Executor};
 use std::rc::Rc;
+use std::sync::mpsc::SyncSender;
 use std::sync::Arc;
 use std::{marker::PhantomData, thread};
 
@@ -15,11 +18,94 @@ pub enum Foreground {
         _not_send_or_sync: PhantomData<Rc<()>>,
     },
     Test(smol::LocalExecutor<'static>),
+    Deterministic(Arc<Deterministic>),
 }
 
-pub struct Background {
+pub enum Background {
-    executor: Arc<smol::Executor<'static>>,
+    Deterministic(Arc<Deterministic>),
-    _stop: channel::Sender<()>,
+    Production {
+        executor: Arc<smol::Executor<'static>>,
+        _stop: channel::Sender<()>,
+    },
+}
+
+pub struct Deterministic {
+    seed: u64,
+    runnables: Arc<Mutex<(Vec<Runnable>, Option<SyncSender<()>>)>>,
+}
+
+impl Deterministic {
+    fn new(seed: u64) -> Self {
+        Self {
+            seed,
+            runnables: Default::default(),
+        }
+    }
+
+    pub fn spawn_local<F, T>(&self, future: F) -> Task<T>
+    where
+        T: 'static,
+        F: Future<Output = T> + 'static,
+    {
+        let runnables = self.runnables.clone();
+        let (runnable, task) = async_task::spawn_local(future, move |runnable| {
+            let mut runnables = runnables.lock();
+            runnables.0.push(runnable);
+            runnables.1.as_ref().unwrap().send(()).ok();
+        });
+        runnable.schedule();
+        task
+    }
+
+    pub fn spawn<F, T>(&self, future: F) -> Task<T>
+    where
+        T: 'static + Send,
+        F: 'static + Send + Future<Output = T>,
+    {
+        let runnables = self.runnables.clone();
+        let (runnable, task) = async_task::spawn(future, move |runnable| {
+            let mut runnables = runnables.lock();
+            runnables.0.push(runnable);
+            runnables.1.as_ref().unwrap().send(()).ok();
+        });
+        runnable.schedule();
+        task
+    }
+
+    pub fn run<F, T>(&self, future: F) -> T
+    where
+        T: 'static,
+        F: Future<Output = T> + 'static,
+    {
+        let (wake_tx, wake_rx) = std::sync::mpsc::sync_channel(32);
+        let runnables = self.runnables.clone();
+        runnables.lock().1 = Some(wake_tx);
+
+        let (output_tx, output_rx) = std::sync::mpsc::channel();
+        self.spawn_local(async move {
+            let output = future.await;
+            output_tx.send(output).unwrap();
+        })
+        .detach();
+
+        let mut rng = StdRng::seed_from_u64(self.seed);
+        loop {
+            if let Ok(value) = output_rx.try_recv() {
+                runnables.lock().1 = None;
+                return value;
+            }
+
+            wake_rx.recv().unwrap();
+            let runnable = {
+                let mut runnables = runnables.lock();
+                let runnables = &mut runnables.0;
+                let index = rng.gen_range(0..runnables.len());
+                runnables.remove(index)
+            };
+
+            runnable.run();
+        }
+    }
 }
 
 impl Foreground {
@@ -48,13 +134,15 @@ impl Foreground {
                 task
             }
             Self::Test(executor) => executor.spawn(future),
+            Self::Deterministic(executor) => executor.spawn_local(future),
         }
     }
 
-    pub async fn run<T>(&self, future: impl Future<Output = T>) -> T {
+    pub fn run<T: 'static>(&self, future: impl 'static + Future<Output = T>) -> T {
         match self {
             Self::Platform { .. } => panic!("you can't call run on a platform foreground executor"),
-            Self::Test(executor) => executor.run(future).await,
+            Self::Test(executor) => smol::block_on(executor.run(future)),
+            Self::Deterministic(executor) => executor.run(future),
         }
     }
 }
@@ -73,7 +161,7 @@ impl Background {
                 .unwrap();
         }
 
-        Self {
+        Self::Production {
             executor,
             _stop: stop.0,
         }
@@ -84,6 +172,17 @@ impl Background {
         T: 'static + Send,
         F: Send + Future<Output = T> + 'static,
     {
-        self.executor.spawn(future)
+        match self {
+            Self::Production { executor, .. } => executor.spawn(future),
+            Self::Deterministic(executor) => executor.spawn(future),
+        }
     }
 }
+
+pub fn deterministic(seed: u64) -> (Rc<Foreground>, Arc<Background>) {
+    let executor = Arc::new(Deterministic::new(seed));
+    (
+        Rc::new(Foreground::Deterministic(executor.clone())),
+        Arc::new(Background::Deterministic(executor)),
+    )
+}

gpui/src/lib.rs

@@ -31,4 +31,3 @@ pub use presenter::{
     SizeConstraint, Vector2FExt,
 };
 pub use scoped_pool;
-pub use smol::block_on;

gpui_macros/src/lib.rs

@@ -11,6 +11,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
 
     let args = syn::parse_macro_input!(args as AttributeArgs);
     let mut max_retries = 0;
+    let mut iterations = 1;
     for arg in args {
         match arg {
             NestedMeta::Meta(Meta::Path(name))
@@ -19,9 +20,14 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
                 namespace = format_ident!("crate");
             }
             NestedMeta::Meta(Meta::NameValue(meta)) => {
-                if let Some(result) = parse_retries(&meta) {
+                if let Some(result) = parse_int_meta(&meta, "retries") {
                     match result {
-                        Ok(retries) => max_retries = retries,
+                        Ok(value) => max_retries = value,
+                        Err(error) => return TokenStream::from(error.into_compile_error()),
+                    }
+                } else if let Some(result) = parse_int_meta(&meta, "iterations") {
+                    match result {
+                        Ok(value) => iterations = value,
                         Err(error) => return TokenStream::from(error.into_compile_error()),
                     }
                 }
@@ -44,7 +50,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
     let inner_fn_args = (0..inner_fn.sig.inputs.len())
         .map(|i| {
             let first_entity_id = i * 100_000;
-            quote!(#namespace::TestAppContext::new(foreground.clone(), #first_entity_id),)
+            quote!(#namespace::TestAppContext::new(foreground.clone(), background.clone(), #first_entity_id),)
         })
         .collect::<proc_macro2::TokenStream>();
 
@@ -54,29 +60,34 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
             fn #outer_fn_name() {
                 #inner_fn
 
-                if #max_retries > 0 {
+                let mut retries = 0;
-                    let mut retries = 0;
+                let mut seed = 0;
-                    loop {
+                loop {
-                        let result = std::panic::catch_unwind(|| {
+                    let result = std::panic::catch_unwind(|| {
-                            let foreground = ::std::rc::Rc::new(#namespace::executor::Foreground::test());
+                        let (foreground, background) = #namespace::executor::deterministic(seed as u64);
-                            #namespace::block_on(foreground.run(#inner_fn_name(#inner_fn_args)));
+                        foreground.run(#inner_fn_name(#inner_fn_args));
-                        });
+                    });
 
-                        match result {
+                    match result {
-                            Ok(result) => return result,
+                        Ok(result) => {
-                            Err(error) => {
+                            seed += 1;
-                                if retries < #max_retries {
+                            retries = 0;
-                                    retries += 1;
+                            if seed == #iterations {
-                                    println!("retrying: attempt {}", retries);
+                                return result
-                                } else {
+                            }
-                                    std::panic::resume_unwind(error);
+                        }
+                        Err(error) => {
+                            if retries < #max_retries {
+                                retries += 1;
+                                println!("retrying: attempt {}", retries);
+                            } else {
+                                if #iterations > 1 {
+                                    eprintln!("failing seed: {}", seed);
                                 }
+                                std::panic::resume_unwind(error);
                             }
                         }
                     }
-                } else {
-                    let foreground = ::std::rc::Rc::new(#namespace::executor::Foreground::test());
-                    #namespace::block_on(foreground.run(#inner_fn_name(#inner_fn_args)));
                 }
             }
         }
@@ -120,15 +131,15 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
     TokenStream::from(quote!(#outer_fn))
 }
 
-fn parse_retries(meta: &MetaNameValue) -> Option<syn::Result<usize>> {
+fn parse_int_meta(meta: &MetaNameValue, name: &str) -> Option<syn::Result<usize>> {
     let ident = meta.path.get_ident();
-    if ident.map_or(false, |n| n == "retries") {
+    if ident.map_or(false, |n| n == name) {
         if let Lit::Int(int) = &meta.lit {
             Some(int.base10_parse())
         } else {
             Some(Err(syn::Error::new(
                 meta.lit.span(),
-                "retries mut be an integer",
+                format!("{} mut be an integer", name),
             )))
         }
     } else {