Vendor a fork of async_executor to allow for deeper integration with bevy_tasks

.github/workflows/ci.yml

@@ -91,6 +91,13 @@ jobs:
   miri:
     runs-on: macos-latest
     timeout-minutes: 60
+    env:
+      # -Zrandomize-layout makes sure we dont rely on the layout of anything that might change
+      RUSTFLAGS: -Zrandomize-layout
+      # https://github.com/rust-lang/miri#miri--z-flags-and-environment-variables
+      # -Zmiri-disable-isolation is needed because our executor uses `fastrand` which accesses system time.
+      # -Zmiri-ignore-leaks is necessary because a bunch of tests don't join all threads before finishing.
+      MIRIFLAGS: -Zmiri-ignore-leaks -Zmiri-disable-isolation
     steps:
       - uses: actions/checkout@v5
       - uses: actions/cache/restore@v4
@@ -111,17 +118,14 @@ jobs:
         with:
           toolchain: ${{ env.NIGHTLY_TOOLCHAIN }}
           components: miri
-      - name: CI job
+      - name: CI job (Tasks)
+        # To run the tests one item at a time for troubleshooting, use
+        # cargo --quiet test --lib -- --list | sed 's/: test$//' | MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-disable-weak-memory-emulation" xargs -n1 cargo miri test -p bevy_tasks --lib -- --exact
+        run: cargo miri test -p bevy_tasks --features bevy_executor --features multi_threaded
+      - name: CI job (ECS)
         # To run the tests one item at a time for troubleshooting, use
         # cargo --quiet test --lib -- --list | sed 's/: test$//' | MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-disable-weak-memory-emulation" xargs -n1 cargo miri test -p bevy_ecs --lib -- --exact
         run: cargo miri test -p bevy_ecs --features bevy_utils/debug
-        env:
-          # -Zrandomize-layout makes sure we dont rely on the layout of anything that might change
-          RUSTFLAGS: -Zrandomize-layout
-          # https://github.com/rust-lang/miri#miri--z-flags-and-environment-variables
-          # -Zmiri-disable-isolation is needed because our executor uses `fastrand` which accesses system time.
-          # -Zmiri-ignore-leaks is necessary because a bunch of tests don't join all threads before finishing.
-          MIRIFLAGS: -Zmiri-ignore-leaks -Zmiri-disable-isolation
 
   check-compiles:
     runs-on: ubuntu-latest

Cargo.toml

@@ -131,7 +131,6 @@ unused_qualifications = "warn"
 [features]
 default = [
   "std",
-  "async_executor",
   "android-game-activity",
   "android_shared_stdcxx",
   "animation",
@@ -586,9 +585,6 @@ custom_cursor = ["bevy_internal/custom_cursor"]
 # Experimental support for nodes that are ignored for UI layouting
 ghost_nodes = ["bevy_internal/ghost_nodes"]
 
-# Uses `async-executor` as a task execution backend.
-async_executor = ["std", "bevy_internal/async_executor"]
-
 # Allows access to the `std` crate.
 std = ["bevy_internal/std"]
 

crates/bevy_a11y/Cargo.toml

@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 keywords = ["bevy", "accessibility", "a11y"]
 
 [features]
-default = ["std", "bevy_reflect", "bevy_ecs/async_executor"]
+default = ["std", "bevy_reflect"]
 
 # Functionality
 

crates/bevy_app/src/app.rs

@@ -1401,10 +1401,7 @@ impl Plugin for HokeyPokey {
 type RunnerFn = Box<dyn FnOnce(App) -> AppExit>;
 
 fn run_once(mut app: App) -> AppExit {
-    while app.plugins_state() == PluginsState::Adding {
-        #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-        bevy_tasks::tick_global_task_pools_on_main_thread();
-    }
+    while app.plugins_state() == PluginsState::Adding {}
     app.finish();
     app.cleanup();
 

crates/bevy_app/src/schedule_runner.rs

@@ -76,10 +76,7 @@ impl Plugin for ScheduleRunnerPlugin {
         app.set_runner(move |mut app: App| {
             let plugins_state = app.plugins_state();
             if plugins_state != PluginsState::Cleaned {
-                while app.plugins_state() == PluginsState::Adding {
-                    #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-                    bevy_tasks::tick_global_task_pools_on_main_thread();
-                }
+                while app.plugins_state() == PluginsState::Adding {}
                 app.finish();
                 app.cleanup();
             }

crates/bevy_app/src/task_pool_plugin.rs

@@ -6,21 +6,6 @@ use bevy_tasks::{AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolBuil
 use core::fmt::Debug;
 use log::trace;
 
-cfg_if::cfg_if! {
-    if #[cfg(not(all(target_arch = "wasm32", feature = "web")))] {
-        use {crate::Last, bevy_tasks::tick_global_task_pools_on_main_thread};
-        use bevy_ecs::system::NonSendMarker;
-
-        /// A system used to check and advanced our task pools.
-        ///
-        /// Calls [`tick_global_task_pools_on_main_thread`],
-        /// and uses [`NonSendMarker`] to ensure that this system runs on the main thread
-        fn tick_global_task_pools(_main_thread_marker: NonSendMarker) {
-            tick_global_task_pools_on_main_thread();
-        }
-    }
-}
-
 /// Setup of default task pools: [`AsyncComputeTaskPool`], [`ComputeTaskPool`], [`IoTaskPool`].
 #[derive(Default)]
 pub struct TaskPoolPlugin {
@@ -32,9 +17,6 @@ impl Plugin for TaskPoolPlugin {
     fn build(&self, _app: &mut App) {
         // Setup the default bevy task pools
         self.task_pool_options.create_default_pools();
-
-        #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-        _app.add_systems(Last, tick_global_task_pools);
     }
 }
 

crates/bevy_asset/Cargo.toml

@@ -27,9 +27,7 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.17.0-dev", default-features = fa
 bevy_reflect = { path = "../bevy_reflect", version = "0.17.0-dev", default-features = false, features = [
   "uuid",
 ] }
-bevy_tasks = { path = "../bevy_tasks", version = "0.17.0-dev", default-features = false, features = [
-  "async_executor",
-] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.17.0-dev", default-features = false }
 bevy_utils = { path = "../bevy_utils", version = "0.17.0-dev", default-features = false }
 bevy_platform = { path = "../bevy_platform", version = "0.17.0-dev", default-features = false, features = [
   "std",

crates/bevy_ecs/Cargo.toml

@@ -11,7 +11,7 @@ categories = ["game-engines", "data-structures"]
 rust-version = "1.86.0"
 
 [features]
-default = ["std", "bevy_reflect", "async_executor", "backtrace"]
+default = ["std", "bevy_reflect", "backtrace"]
 
 # Functionality
 
@@ -49,12 +49,6 @@ bevy_debug_stepping = []
 ## This will often provide more detailed error messages.
 track_location = []
 
-# Executor Backend
-
-## Uses `async-executor` as a task execution backend.
-## This backend is incompatible with `no_std` targets.
-async_executor = ["std", "bevy_tasks/async_executor"]
-
 # Platform Compatibility
 
 ## Allows access to the `std` crate. Enabling this feature will prevent compilation

crates/bevy_ecs/src/schedule/executor/mod.rs

@@ -11,7 +11,7 @@ use core::any::TypeId;
 pub use self::{simple::SimpleExecutor, single_threaded::SingleThreadedExecutor};
 
 #[cfg(feature = "std")]
-pub use self::multi_threaded::{MainThreadExecutor, MultiThreadedExecutor};
+pub use self::multi_threaded::{MainThreadTaskSpawner, MultiThreadedExecutor};
 
 use fixedbitset::FixedBitSet;
 

crates/bevy_ecs/src/schedule/executor/multi_threaded.rs

@@ -1,7 +1,6 @@
 use alloc::{boxed::Box, vec::Vec};
 use bevy_platform::cell::SyncUnsafeCell;
-use bevy_platform::sync::Arc;
-use bevy_tasks::{ComputeTaskPool, Scope, TaskPool, ThreadExecutor};
+use bevy_tasks::{ComputeTaskPool, LocalTaskSpawner, Scope, TaskPool};
 use concurrent_queue::ConcurrentQueue;
 use core::{any::Any, panic::AssertUnwindSafe};
 use fixedbitset::FixedBitSet;
@@ -270,14 +269,12 @@ impl SystemExecutor for MultiThreadedExecutor {
         }
 
         let thread_executor = world
-            .get_resource::<MainThreadExecutor>()
+            .get_resource::<MainThreadTaskSpawner>()
             .map(|e| e.0.clone());
-        let thread_executor = thread_executor.as_deref();
 
         let environment = &Environment::new(self, schedule, world);
 
         ComputeTaskPool::get_or_init(TaskPool::default).scope_with_executor(
-            false,
             thread_executor,
             |scope| {
                 let context = Context {
@@ -864,20 +861,20 @@ unsafe fn evaluate_and_fold_conditions(
         .fold(true, |acc, res| acc && res)
 }
 
-/// New-typed [`ThreadExecutor`] [`Resource`] that is used to run systems on the main thread
+/// New-typed [`LocalTaskSpawner`] [`Resource`] that is used to run systems on the main thread
 #[derive(Resource, Clone)]
-pub struct MainThreadExecutor(pub Arc<ThreadExecutor<'static>>);
+pub struct MainThreadTaskSpawner(pub LocalTaskSpawner<'static>);
 
-impl Default for MainThreadExecutor {
+impl Default for MainThreadTaskSpawner {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl MainThreadExecutor {
+impl MainThreadTaskSpawner {
     /// Creates a new executor that can be used to run systems on the main thread.
     pub fn new() -> Self {
-        MainThreadExecutor(TaskPool::get_thread_executor())
+        MainThreadTaskSpawner(ComputeTaskPool::get().current_thread_spawner())
     }
 }
 

crates/bevy_input/Cargo.toml

@@ -9,7 +9,7 @@ license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
 [features]
-default = ["std", "bevy_reflect", "bevy_ecs/async_executor", "smol_str"]
+default = ["std", "bevy_reflect", "smol_str"]
 
 # Functionality
 

crates/bevy_input_focus/Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["bevy"]
 rust-version = "1.85.0"
 
 [features]
-default = ["std", "bevy_reflect", "bevy_ecs/async_executor"]
+default = ["std", "bevy_reflect"]
 
 # Functionality
 

crates/bevy_internal/Cargo.toml

@@ -383,15 +383,6 @@ libm = [
   "bevy_window?/libm",
 ]
 
-# Uses `async-executor` as a task execution backend.
-# This backend is incompatible with `no_std` targets.
-async_executor = [
-  "std",
-  "bevy_tasks/async_executor",
-  "bevy_ecs/async_executor",
-  "bevy_transform/async_executor",
-]
-
 # Enables use of browser APIs.
 # Note this is currently only applicable on `wasm32` architectures.
 web = ["bevy_app/web", "bevy_platform/web", "bevy_reflect/web"]

crates/bevy_render/src/pipelined_rendering.rs

@@ -3,7 +3,7 @@ use async_channel::{Receiver, Sender};
 use bevy_app::{App, AppExit, AppLabel, Plugin, SubApp};
 use bevy_ecs::{
     resource::Resource,
-    schedule::MainThreadExecutor,
+    schedule::MainThreadTaskSpawner,
     world::{Mut, World},
 };
 use bevy_tasks::ComputeTaskPool;
@@ -114,7 +114,7 @@ impl Plugin for PipelinedRenderingPlugin {
         if app.get_sub_app(RenderApp).is_none() {
             return;
         }
-        app.insert_resource(MainThreadExecutor::new());
+        app.insert_resource(MainThreadTaskSpawner::new());
 
         let mut sub_app = SubApp::new();
         sub_app.set_extract(renderer_extract);
@@ -136,7 +136,7 @@ impl Plugin for PipelinedRenderingPlugin {
             .expect("Unable to get RenderApp. Another plugin may have removed the RenderApp before PipelinedRenderingPlugin");
 
         // clone main thread executor to render world
-        let executor = app.world().get_resource::<MainThreadExecutor>().unwrap();
+        let executor = app.world().get_resource::<MainThreadTaskSpawner>().unwrap();
         render_app.world_mut().insert_resource(executor.clone());
 
         render_to_app_sender.send_blocking(render_app).unwrap();
@@ -181,12 +181,12 @@ impl Plugin for PipelinedRenderingPlugin {
 // This function waits for the rendering world to be received,
 // runs extract, and then sends the rendering world back to the render thread.
 fn renderer_extract(app_world: &mut World, _world: &mut World) {
-    app_world.resource_scope(|world, main_thread_executor: Mut<MainThreadExecutor>| {
+    app_world.resource_scope(|world, main_thread_executor: Mut<MainThreadTaskSpawner>| {
         world.resource_scope(|world, mut render_channels: Mut<RenderAppChannels>| {
             // we use a scope here to run any main thread tasks that the render world still needs to run
             // while we wait for the render world to be received.
             if let Some(mut render_app) = ComputeTaskPool::get()
-                .scope_with_executor(true, Some(&*main_thread_executor.0), |s| {
+                .scope_with_executor(Some(main_thread_executor.0.clone()), |s| {
                     s.spawn(async { render_channels.recv().await });
                 })
                 .pop()

crates/bevy_tasks/Cargo.toml

@@ -9,20 +9,24 @@ license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
 [features]
-default = ["async_executor", "futures-lite"]
+default = ["futures-lite"]
 
 # Enables multi-threading support.
 # Without this feature, all tasks will be run on a single thread.
-multi_threaded = [
-  "bevy_platform/std",
-  "dep:async-channel",
-  "dep:concurrent-queue",
-  "async_executor",
-]
+multi_threaded = ["bevy_platform/std", "dep:async-channel", "bevy_executor"]
 
-# Uses `async-executor` as a task execution backend.
+# Uses a Bevy-specific fork of `async-executor` as a task execution backend.
 # This backend is incompatible with `no_std` targets.
-async_executor = ["bevy_platform/std", "dep:async-executor", "futures-lite"]
+bevy_executor = [
+  "dep:fastrand",
+  "dep:slab",
+  "dep:thread_local",
+  "dep:crossbeam-utils",
+  "dep:pin-project-lite",
+  "futures-lite",
+  "async-task/std",
+  "concurrent-queue/std",
+]
 
 # Provide an implementation of `block_on` from  `futures-lite`.
 futures-lite = ["bevy_platform/std", "futures-lite/std"]
@@ -44,18 +48,19 @@ derive_more = { version = "2", default-features = false, features = [
   "deref",
   "deref_mut",
 ] }
-async-executor = { version = "1.11", optional = true }
+slab = { version = "0.4", optional = true }
+pin-project-lite = { version = "0.2", optional = true }
+thread_local = { version = "1.1", optional = true }
+fastrand = { version = "2.3", optional = true, default-features = false }
 async-channel = { version = "2.3.0", optional = true }
 async-io = { version = "2.0.0", optional = true }
-concurrent-queue = { version = "2.0.0", optional = true }
 atomic-waker = { version = "1", default-features = false }
-crossbeam-queue = { version = "0.3", default-features = false, features = [
-  "alloc",
-] }
+concurrent-queue = { version = "2.5", default-features = false }
+crossbeam-utils = { version = "0.8", default-features = false, optional = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-pin-project = "1"
 async-channel = "2.3.0"
+pin-project-lite = "0.2"
 
 [target.'cfg(not(all(target_has_atomic = "8", target_has_atomic = "16", target_has_atomic = "32", target_has_atomic = "64", target_has_atomic = "ptr")))'.dependencies]
 async-task = { version = "4.4.0", default-features = false, features = [
@@ -73,6 +78,7 @@ futures-lite = { version = "2.0.1", default-features = false, features = [
   "std",
 ] }
 async-channel = "2.3.0"
+async-io = "2.0.0"
 
 [lints]
 workspace = true

crates/bevy_tasks/README.md

@@ -14,8 +14,8 @@ a single thread and having that thread await the completion of those tasks. This
 generating the tasks from a slice of data. This library is intended for games and makes no attempt to ensure fairness
 or ordering of spawned tasks.
 
-It is based on [`async-executor`][async-executor], a lightweight executor that allows the end user to manage their own threads.
-`async-executor` is based on async-task, a core piece of async-std.
+It is based on a fork of [`async-executor`][async-executor], a lightweight executor that allows the end user to manage their own threads.
+`async-executor` is based on [`async-task`][async-task], a core piece of [`smol`][smol].
 
 ## Usage
 
@@ -40,4 +40,6 @@ To enable `no_std` support in this crate, you will need to disable default featu
 
 [bevy]: https://bevy.org
 [rayon]: https://github.com/rayon-rs/rayon
-[async-executor]: https://github.com/stjepang/async-executor
+[async-executor]: https://github.com/smol-rs/async-executor
+[smol]: https://github.com/smol-rs/smol
+[async-task]: https://github.com/smol-rs/async-task