Nathan SoboandAntonio Scandurra
1ae326432e
Extracts and cleans up GPUI's scheduler code into a new `scheduler` crate, making it pluggable by external runtimes. This will enable deterministic integration testing with cloud components by providing a unified test scheduler across Zed and backend code. In Zed, it will replace the existing GPUI scheduler for consistent async task management across platforms. ## Changes - **Core Implementation**: `TestScheduler` with seed-based randomization, session tracking (`SessionId`), and foreground/background task separation for reproducible testing. - **Executors**: `ForegroundExecutor` (!Send, thread-local) and `BackgroundExecutor` (Send, with blocking/timeout support) as GPUI-compatible wrappers. - **Clock and Timer**: Controllable `TestClock` and future-based `Timer` for time-sensitive tests. - **Testing APIs**: `once()`, `with_seed()`, and `many()` methods for configurable test runs. - **Dependencies**: Added `async-task`, `chrono`, `futures`, etc., with updates to `Cargo.toml` and lock file. ## Benefits - **Integration Testing**: Facilitates reliable async tests involving cloud sessions, reducing flakiness via deterministic execution. - **Pluggability**: Trait-based design (`Scheduler`) allows easy integration into non-GPUI runtimes while maintaining GPUI compatibility. - **Cleanup**: Refactors GPUI scheduler logic for clarity, correctness (no `unwrap()`, proper error handling), and extensibility. Follows Rust guidelines; run `./script/clippy` for verification. - [x] Define and test a core scheduler that we think can power our cloud code and GPUI - [ ] Replace GPUI's scheduler Release Notes: - N/A --------- Co-authored-by: Antonio Scandurra <me@as-cii.com>
64 lines
1.6 KiB
Rust
64 lines
1.6 KiB
Rust
mod clock;
|
|
mod executor;
|
|
mod test_scheduler;
|
|
#[cfg(test)]
|
|
mod tests;
|
|
|
|
pub use clock::*;
|
|
pub use executor::*;
|
|
pub use test_scheduler::*;
|
|
|
|
use async_task::Runnable;
|
|
use futures::{FutureExt as _, channel::oneshot, future::LocalBoxFuture};
|
|
use std::{
|
|
future::Future,
|
|
pin::Pin,
|
|
task::{Context, Poll},
|
|
time::Duration,
|
|
};
|
|
|
|
pub trait Scheduler: Send + Sync {
|
|
fn block(&self, future: LocalBoxFuture<()>, timeout: Option<Duration>);
|
|
fn schedule_foreground(&self, session_id: SessionId, runnable: Runnable);
|
|
fn schedule_background(&self, runnable: Runnable);
|
|
fn timer(&self, timeout: Duration) -> Timer;
|
|
fn is_main_thread(&self) -> bool;
|
|
}
|
|
|
|
impl dyn Scheduler {
|
|
pub fn block_on<Fut: Future>(&self, future: Fut) -> Fut::Output {
|
|
let mut output = None;
|
|
self.block(async { output = Some(future.await) }.boxed_local(), None);
|
|
output.unwrap()
|
|
}
|
|
|
|
pub fn block_with_timeout<Fut: Unpin + Future>(
|
|
&self,
|
|
future: &mut Fut,
|
|
timeout: Duration,
|
|
) -> Option<Fut::Output> {
|
|
let mut output = None;
|
|
self.block(
|
|
async { output = Some(future.await) }.boxed_local(),
|
|
Some(timeout),
|
|
);
|
|
output
|
|
}
|
|
}
|
|
|
|
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
|
|
pub struct SessionId(u16);
|
|
|
|
pub struct Timer(oneshot::Receiver<()>);
|
|
|
|
impl Future for Timer {
|
|
type Output = ();
|
|
|
|
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<()> {
|
|
match self.0.poll_unpin(cx) {
|
|
Poll::Ready(_) => Poll::Ready(()),
|
|
Poll::Pending => Poll::Pending,
|
|
}
|
|
}
|
|
}
|