WIP: Start restructuring executor

Cargo.lock

@@ -2128,6 +2128,7 @@ dependencies = [
  "block",
  "cc",
  "cocoa",
+ "collections",
  "core-foundation",
  "core-graphics",
  "core-text",

crates/gpui/Cargo.toml

@@ -8,9 +8,10 @@ version = "0.1.0"
 path = "src/gpui.rs"
 
 [features]
-test-support = ["env_logger"]
+test-support = ["env_logger", "collections/test-support"]
 
 [dependencies]
+collections = { path = "../collections" }
 gpui_macros = { path = "../gpui_macros" }
 sum_tree = { path = "../sum_tree" }
 async-task = "4.0.3"
@@ -47,6 +48,7 @@ bindgen = "0.58.1"
 cc = "1.0.67"
 
 [dev-dependencies]
+collections = { path = "../collections", features = ["test-support"] }
 env_logger = "0.8"
 png = "0.16"
 simplelog = "0.9"

crates/gpui/src/executor.rs

@@ -1,6 +1,7 @@
 use anyhow::{anyhow, Result};
 use async_task::Runnable;
 use backtrace::{Backtrace, BacktraceFmt, BytesOrWideString};
+use collections::HashMap;
 use parking_lot::Mutex;
 use postage::{barrier, prelude::Stream as _};
 use rand::prelude::*;
@@ -33,7 +34,10 @@ pub enum Foreground {
         dispatcher: Arc<dyn platform::Dispatcher>,
         _not_send_or_sync: PhantomData<Rc<()>>,
     },
-    Deterministic(Arc<Deterministic>),
+    Deterministic {
+        cx_id: usize,
+        executor: Arc<Deterministic>,
+    },
 }
 
 pub enum Background {
@@ -69,9 +73,8 @@ unsafe impl<T: Send> Send for Task<T> {}
 struct DeterministicState {
     rng: StdRng,
     seed: u64,
-    scheduled_from_foreground: Vec<(Runnable, Backtrace)>,
+    scheduled_from_foreground: HashMap<usize, Vec<ScheduledForeground>>,
-    scheduled_from_background: Vec<(Runnable, Backtrace)>,
+    scheduled_from_background: Vec<Runnable>,
-    spawned_from_foreground: Vec<(Runnable, Backtrace)>,
     forbid_parking: bool,
     block_on_ticks: RangeInclusive<usize>,
     now: Instant,
@@ -79,20 +82,24 @@ struct DeterministicState {
     waiting_backtrace: Option<Backtrace>,
 }
 
+enum ScheduledForeground {
+    MainFuture,
+    Runnable(Runnable),
+}
+
 pub struct Deterministic {
     state: Arc<Mutex<DeterministicState>>,
     parker: Mutex<parking::Parker>,
 }
 
 impl Deterministic {
-    fn new(seed: u64) -> Self {
+    pub fn new(seed: u64) -> Arc<Self> {
-        Self {
+        Arc::new(Self {
             state: Arc::new(Mutex::new(DeterministicState {
                 rng: StdRng::seed_from_u64(seed),
                 seed,
                 scheduled_from_foreground: Default::default(),
                 scheduled_from_background: Default::default(),
-                spawned_from_foreground: Default::default(),
                 forbid_parking: false,
                 block_on_ticks: 0..=1000,
                 now: Instant::now(),
@@ -100,22 +107,32 @@ impl Deterministic {
                 waiting_backtrace: None,
             })),
             parker: Default::default(),
-        }
+        })
     }
 
-    fn spawn_from_foreground(&self, future: AnyLocalFuture) -> AnyLocalTask {
+    pub fn build_background(self: &Arc<Self>) -> Arc<Background> {
-        let backtrace = Backtrace::new_unresolved();
+        Arc::new(Background::Deterministic {
-        let scheduled_once = AtomicBool::new(false);
+            executor: self.clone(),
+        })
+    }
+
+    pub fn build_foreground(self: &Arc<Self>, id: usize) -> Rc<Foreground> {
+        Rc::new(Foreground::Deterministic {
+            cx_id: id,
+            executor: self.clone(),
+        })
+    }
+
+    fn spawn_from_foreground(&self, cx_id: usize, future: AnyLocalFuture) -> AnyLocalTask {
         let state = self.state.clone();
         let unparker = self.parker.lock().unparker();
         let (runnable, task) = async_task::spawn_local(future, move |runnable| {
             let mut state = state.lock();
-            let backtrace = backtrace.clone();
+            state
-            if scheduled_once.fetch_or(true, SeqCst) {
+                .scheduled_from_foreground
-                state.scheduled_from_foreground.push((runnable, backtrace));
+                .entry(cx_id)
-            } else {
+                .or_default()
-                state.spawned_from_foreground.push((runnable, backtrace));
+                .push(ScheduledForeground::Runnable(runnable));
-            }
             unparker.unpark();
         });
         runnable.schedule();
@@ -123,24 +140,21 @@ impl Deterministic {
     }
 
     fn spawn(&self, future: AnyFuture) -> AnyTask {
-        let backtrace = Backtrace::new_unresolved();
         let state = self.state.clone();
         let unparker = self.parker.lock().unparker();
         let (runnable, task) = async_task::spawn(future, move |runnable| {
             let mut state = state.lock();
-            state
+            state.scheduled_from_background.push(runnable);
-                .scheduled_from_background
-                .push((runnable, backtrace.clone()));
             unparker.unpark();
         });
         runnable.schedule();
         task
     }
 
-    fn run(&self, mut future: AnyLocalFuture) -> Box<dyn Any> {
+    fn run(&self, cx_id: usize, mut future: AnyLocalFuture) -> Box<dyn Any> {
         let woken = Arc::new(AtomicBool::new(false));
         loop {
-            if let Some(result) = self.run_internal(woken.clone(), &mut future) {
+            if let Some(result) = self.run_internal(cx_id, woken.clone(), &mut future) {
                 return result;
             }
 
@@ -153,67 +167,92 @@ impl Deterministic {
         }
     }
 
-    fn run_until_parked(&self) {
+    fn run_until_parked(&self, cx_id: usize) {
         let woken = Arc::new(AtomicBool::new(false));
         let mut future = any_local_future(std::future::pending::<()>());
-        self.run_internal(woken, &mut future);
+        self.run_internal(cx_id, woken, &mut future);
     }
 
     fn run_internal(
         &self,
+        cx_id: usize,
         woken: Arc<AtomicBool>,
         future: &mut AnyLocalFuture,
     ) -> Option<Box<dyn Any>> {
         let unparker = self.parker.lock().unparker();
-        let waker = waker_fn(move || {
+        let scheduled_main_future = Arc::new(AtomicBool::new(true));
-            woken.store(true, SeqCst);
+        self.state
-            unparker.unpark();
+            .lock()
+            .scheduled_from_foreground
+            .entry(cx_id)
+            .or_default()
+            .insert(0, ScheduledForeground::MainFuture);
+
+        let waker = waker_fn({
+            let state = self.state.clone();
+            let scheduled_main_future = scheduled_main_future.clone();
+            move || {
+                woken.store(true, SeqCst);
+                if !scheduled_main_future.load(SeqCst) {
+                    scheduled_main_future.store(true, SeqCst);
+                    state
+                        .lock()
+                        .scheduled_from_foreground
+                        .entry(cx_id)
+                        .or_default()
+                        .push(ScheduledForeground::MainFuture);
+                }
+
+                unparker.unpark();
+            }
         });
 
         let mut cx = Context::from_waker(&waker);
-        let mut trace = Trace::default();
         loop {
             let mut state = self.state.lock();
-            let runnable_count = state.scheduled_from_foreground.len()
-                + state.scheduled_from_background.len()
-                + state.spawned_from_foreground.len();
 
-            let ix = state.rng.gen_range(0..=runnable_count);
+            if state.scheduled_from_foreground.is_empty()
-            if ix < state.scheduled_from_foreground.len() {
+                && state.scheduled_from_background.is_empty()
-                let (_, backtrace) = &state.scheduled_from_foreground[ix];
-                trace.record(&state, backtrace.clone());
-                let runnable = state.scheduled_from_foreground.remove(ix).0;
-                drop(state);
-                runnable.run();
-            } else if ix - state.scheduled_from_foreground.len()
-                < state.scheduled_from_background.len()
             {
-                let ix = ix - state.scheduled_from_foreground.len();
+                return None;
-                let (_, backtrace) = &state.scheduled_from_background[ix];
+            }
-                trace.record(&state, backtrace.clone());
+
-                let runnable = state.scheduled_from_background.remove(ix).0;
+            if !state.scheduled_from_background.is_empty() && state.rng.gen() {
+                let background_len = state.scheduled_from_background.len();
+                let ix = state.rng.gen_range(0..background_len);
+                let runnable = state.scheduled_from_background.remove(ix);
                 drop(state);
                 runnable.run();
-            } else if ix < runnable_count {
+            } else if !state.scheduled_from_foreground.is_empty() {
-                let (_, backtrace) = &state.spawned_from_foreground[0];
+                let available_cx_ids = state
-                trace.record(&state, backtrace.clone());
+                    .scheduled_from_foreground
-                let runnable = state.spawned_from_foreground.remove(0).0;
+                    .keys()
+                    .copied()
+                    .collect::<Vec<_>>();
+                let cx_id_to_run = *available_cx_ids.iter().choose(&mut state.rng).unwrap();
+                let scheduled_from_cx = state
+                    .scheduled_from_foreground
+                    .get_mut(&cx_id_to_run)
+                    .unwrap();
+                let runnable = scheduled_from_cx.remove(0);
+                if scheduled_from_cx.is_empty() {
+                    state.scheduled_from_foreground.remove(&cx_id_to_run);
+                }
+
                 drop(state);
-                runnable.run();
+                match runnable {
+                    ScheduledForeground::MainFuture => {
+                        scheduled_main_future.store(false, SeqCst);
+                        if let Poll::Ready(result) = future.poll(&mut cx) {
+                            return Some(result);
+                        }
+                    }
+                    ScheduledForeground::Runnable(runnable) => {
+                        runnable.run();
+                    }
+                }
             } else {
-                drop(state);
+                return None;
-                if let Poll::Ready(result) = future.poll(&mut cx) {
-                    return Some(result);
-                }
-
-                let state = self.state.lock();
-
-                if state.scheduled_from_foreground.is_empty()
-                    && state.scheduled_from_background.is_empty()
-                    && state.spawned_from_foreground.is_empty()
-                {
-                    return None;
-                }
             }
         }
     }
@@ -230,15 +269,12 @@ impl Deterministic {
         };
 
         let mut cx = Context::from_waker(&waker);
-        let mut trace = Trace::default();
         for _ in 0..max_ticks {
             let mut state = self.state.lock();
             let runnable_count = state.scheduled_from_background.len();
             let ix = state.rng.gen_range(0..=runnable_count);
             if ix < state.scheduled_from_background.len() {
-                let (_, backtrace) = &state.scheduled_from_background[ix];
+                let runnable = state.scheduled_from_background.remove(ix);
-                trace.record(&state, backtrace.clone());
-                let runnable = state.scheduled_from_background.remove(ix).0;
                 drop(state);
                 runnable.run();
             } else {
@@ -281,69 +317,13 @@ impl DeterministicState {
     }
 }
 
-#[derive(Default)]
-struct Trace {
-    executed: Vec<Backtrace>,
-    scheduled: Vec<Vec<Backtrace>>,
-    spawned_from_foreground: Vec<Vec<Backtrace>>,
-}
-
-impl Trace {
-    fn record(&mut self, state: &DeterministicState, executed: Backtrace) {
-        self.scheduled.push(
-            state
-                .scheduled_from_foreground
-                .iter()
-                .map(|(_, backtrace)| backtrace.clone())
-                .collect(),
-        );
-        self.spawned_from_foreground.push(
-            state
-                .spawned_from_foreground
-                .iter()
-                .map(|(_, backtrace)| backtrace.clone())
-                .collect(),
-        );
-        self.executed.push(executed);
-    }
-
-    fn resolve(&mut self) {
-        for backtrace in &mut self.executed {
-            backtrace.resolve();
-        }
-
-        for backtraces in &mut self.scheduled {
-            for backtrace in backtraces {
-                backtrace.resolve();
-            }
-        }
-
-        for backtraces in &mut self.spawned_from_foreground {
-            for backtrace in backtraces {
-                backtrace.resolve();
-            }
-        }
-    }
-}
-
 struct CwdBacktrace<'a> {
     backtrace: &'a Backtrace,
-    first_frame_only: bool,
 }
 
 impl<'a> CwdBacktrace<'a> {
     fn new(backtrace: &'a Backtrace) -> Self {
-        Self {
+        Self { backtrace }
-            backtrace,
-            first_frame_only: false,
-        }
-    }
-
-    fn first_frame(backtrace: &'a Backtrace) -> Self {
-        Self {
-            backtrace,
-            first_frame_only: true,
-        }
     }
 }
 
@@ -362,69 +342,12 @@ impl<'a> Debug for CwdBacktrace<'a> {
                 .any(|s| s.filename().map_or(false, |f| f.starts_with(&cwd)))
             {
                 formatted_frame.backtrace_frame(frame)?;
-                if self.first_frame_only {
-                    break;
-                }
             }
         }
         fmt.finish()
     }
 }
 
-impl Debug for Trace {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for ((backtrace, scheduled), spawned_from_foreground) in self
-            .executed
-            .iter()
-            .zip(&self.scheduled)
-            .zip(&self.spawned_from_foreground)
-        {
-            writeln!(f, "Scheduled")?;
-            for backtrace in scheduled {
-                writeln!(f, "- {:?}", CwdBacktrace::first_frame(backtrace))?;
-            }
-            if scheduled.is_empty() {
-                writeln!(f, "None")?;
-            }
-            writeln!(f, "==========")?;
-
-            writeln!(f, "Spawned from foreground")?;
-            for backtrace in spawned_from_foreground {
-                writeln!(f, "- {:?}", CwdBacktrace::first_frame(backtrace))?;
-            }
-            if spawned_from_foreground.is_empty() {
-                writeln!(f, "None")?;
-            }
-            writeln!(f, "==========")?;
-
-            writeln!(f, "Run: {:?}", CwdBacktrace::first_frame(backtrace))?;
-            writeln!(f, "+++++++++++++++++++")?;
-        }
-
-        Ok(())
-    }
-}
-
-impl Drop for Trace {
-    fn drop(&mut self) {
-        let trace_on_panic = if let Ok(trace_on_panic) = std::env::var("EXECUTOR_TRACE_ON_PANIC") {
-            trace_on_panic == "1" || trace_on_panic == "true"
-        } else {
-            false
-        };
-        let trace_always = if let Ok(trace_always) = std::env::var("EXECUTOR_TRACE_ALWAYS") {
-            trace_always == "1" || trace_always == "true"
-        } else {
-            false
-        };
-
-        if trace_always || (trace_on_panic && thread::panicking()) {
-            self.resolve();
-            dbg!(self);
-        }
-    }
-}
-
 impl Foreground {
     pub fn platform(dispatcher: Arc<dyn platform::Dispatcher>) -> Result<Self> {
         if dispatcher.is_main_thread() {
@@ -440,7 +363,9 @@ impl Foreground {
     pub fn spawn<T: 'static>(&self, future: impl Future<Output = T> + 'static) -> Task<T> {
         let future = any_local_future(future);
         let any_task = match self {
-            Self::Deterministic(executor) => executor.spawn_from_foreground(future),
+            Self::Deterministic { cx_id, executor } => {
+                executor.spawn_from_foreground(*cx_id, future)
+            }
             Self::Platform { dispatcher, .. } => {
                 fn spawn_inner(
                     future: AnyLocalFuture,
@@ -462,7 +387,7 @@ impl Foreground {
     pub fn run<T: 'static>(&self, future: impl 'static + Future<Output = T>) -> T {
         let future = any_local_future(future);
         let any_value = match self {
-            Self::Deterministic(executor) => executor.run(future),
+            Self::Deterministic { cx_id, executor } => executor.run(*cx_id, future),
             Self::Platform { .. } => panic!("you can't call run on a platform foreground executor"),
         };
         *any_value.downcast().unwrap()
@@ -470,14 +395,14 @@ impl Foreground {
 
     pub fn parking_forbidden(&self) -> bool {
         match self {
-            Self::Deterministic(executor) => executor.state.lock().forbid_parking,
+            Self::Deterministic { executor, .. } => executor.state.lock().forbid_parking,
             _ => panic!("this method can only be called on a deterministic executor"),
         }
     }
 
     pub fn start_waiting(&self) {
         match self {
-            Self::Deterministic(executor) => {
+            Self::Deterministic { executor, .. } => {
                 executor.state.lock().waiting_backtrace = Some(Backtrace::new_unresolved());
             }
             _ => panic!("this method can only be called on a deterministic executor"),
@@ -486,7 +411,7 @@ impl Foreground {
 
     pub fn finish_waiting(&self) {
         match self {
-            Self::Deterministic(executor) => {
+            Self::Deterministic { executor, .. } => {
                 executor.state.lock().waiting_backtrace.take();
             }
             _ => panic!("this method can only be called on a deterministic executor"),
@@ -495,7 +420,7 @@ impl Foreground {
 
     pub fn forbid_parking(&self) {
         match self {
-            Self::Deterministic(executor) => {
+            Self::Deterministic { executor, .. } => {
                 let mut state = executor.state.lock();
                 state.forbid_parking = true;
                 state.rng = StdRng::seed_from_u64(state.seed);
@@ -506,7 +431,7 @@ impl Foreground {
 
     pub async fn timer(&self, duration: Duration) {
         match self {
-            Self::Deterministic(executor) => {
+            Self::Deterministic { executor, .. } => {
                 let (tx, mut rx) = barrier::channel();
                 {
                     let mut state = executor.state.lock();
@@ -523,8 +448,8 @@ impl Foreground {
 
     pub fn advance_clock(&self, duration: Duration) {
         match self {
-            Self::Deterministic(executor) => {
+            Self::Deterministic { cx_id, executor } => {
-                executor.run_until_parked();
+                executor.run_until_parked(*cx_id);
 
                 let mut state = executor.state.lock();
                 state.now += duration;
@@ -541,7 +466,7 @@ impl Foreground {
 
     pub fn set_block_on_ticks(&self, range: RangeInclusive<usize>) {
         match self {
-            Self::Deterministic(executor) => executor.state.lock().block_on_ticks = range,
+            Self::Deterministic { executor, .. } => executor.state.lock().block_on_ticks = range,
             _ => panic!("this method can only be called on a deterministic executor"),
         }
     }
@@ -579,7 +504,7 @@ impl Background {
         let future = any_future(future);
         let any_task = match self {
             Self::Production { executor, .. } => executor.spawn(future),
-            Self::Deterministic { executor, .. } => executor.spawn(future),
+            Self::Deterministic { executor } => executor.spawn(future),
         };
         Task::send(any_task)
     }
@@ -646,14 +571,6 @@ impl<'a> Scope<'a> {
     }
 }
 
-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 }),
-    )
-}
-
 impl<T> Task<T> {
     pub fn ready(value: T) -> Self {
         Self::Ready(Some(value))

crates/gpui/src/test.rs

@@ -28,7 +28,12 @@ pub fn run_test(
     mut starting_seed: u64,
     max_retries: usize,
     test_fn: &mut (dyn RefUnwindSafe
-              + Fn(&mut MutableAppContext, Rc<platform::test::ForegroundPlatform>, u64)),
+              + Fn(
+        &mut MutableAppContext,
+        Rc<platform::test::ForegroundPlatform>,
+        Arc<executor::Deterministic>,
+        u64,
+    )),
 ) {
     let is_randomized = num_iterations > 1;
     if is_randomized {
@@ -60,16 +65,16 @@ pub fn run_test(
                     dbg!(seed);
                 }
 
-                let (foreground, background) = executor::deterministic(seed);
+                let deterministic = executor::Deterministic::new(seed);
                 let mut cx = TestAppContext::new(
                     foreground_platform.clone(),
                     platform.clone(),
-                    foreground.clone(),
+                    deterministic.build_foreground(usize::MAX),
-                    background.clone(),
+                    deterministic.build_background(),
                     font_cache.clone(),
                     0,
                 );
-                cx.update(|cx| test_fn(cx, foreground_platform.clone(), seed));
+                cx.update(|cx| test_fn(cx, foreground_platform.clone(), deterministic, seed));
 
                 atomic_seed.fetch_add(1, SeqCst);
             }

crates/gpui_macros/src/gpui_macros.rs

@@ -77,8 +77,8 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
                                 #namespace::TestAppContext::new(
                                     foreground_platform.clone(),
                                     cx.platform().clone(),
-                                    cx.foreground().clone(),
+                                    deterministic.build_foreground(#ix),
-                                    cx.background().clone(),
+                                    deterministic.build_background(),
                                     cx.font_cache().clone(),
                                     #first_entity_id,
                                 ),
@@ -115,7 +115,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
                     #num_iterations as u64,
                     #starting_seed as u64,
                     #max_retries,
-                    &mut |cx, foreground_platform, seed| cx.foreground().run(#inner_fn_name(#inner_fn_args))
+                    &mut |cx, foreground_platform, deterministic, seed| cx.foreground().run(#inner_fn_name(#inner_fn_args))
                 );
             }
         }
@@ -147,7 +147,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
                     #num_iterations as u64,
                     #starting_seed as u64,
                     #max_retries,
-                    &mut |cx, _, seed| #inner_fn_name(#inner_fn_args)
+                    &mut |cx, _, _, seed| #inner_fn_name(#inner_fn_args)
                 );
             }
         }

crates/server/src/rpc.rs

@@ -1794,7 +1794,7 @@ mod tests {
         });
     }
 
-    #[gpui::test]
+    #[gpui::test(iterations = 100)]
     async fn test_editing_while_guest_opens_buffer(
         mut cx_a: TestAppContext,
         mut cx_b: TestAppContext,