Optimize TaskPools for use in static variables.

.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

@@ -127,7 +127,6 @@ unused_qualifications = "warn"
 [features]
 default = [
   "std",
-  "async_executor",
   "android-game-activity",
   "android_shared_stdcxx",
   "animation",
@@ -566,9 +565,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"]
 

benches/benches/bevy_ecs/iteration/heavy_compute.rs

@@ -1,5 +1,5 @@
 use bevy_ecs::prelude::*;
-use bevy_tasks::{ComputeTaskPool, TaskPool};
+use bevy_tasks::{ComputeTaskPool, TaskPoolBuilder};
 use criterion::Criterion;
 use glam::*;
 
@@ -20,7 +20,7 @@ pub fn heavy_compute(c: &mut Criterion) {
     group.warm_up_time(core::time::Duration::from_millis(500));
     group.measurement_time(core::time::Duration::from_secs(4));
     group.bench_function("base", |b| {
-        ComputeTaskPool::get_or_init(TaskPool::default);
+        ComputeTaskPool::get_or_init(TaskPoolBuilder::default);
 
         let mut world = World::default();
 

benches/benches/bevy_ecs/iteration/par_iter_simple.rs

@@ -1,5 +1,5 @@
 use bevy_ecs::prelude::*;
-use bevy_tasks::{ComputeTaskPool, TaskPool};
+use bevy_tasks::{ComputeTaskPool, TaskPoolBuilder};
 use glam::*;
 
 #[derive(Component, Copy, Clone)]
@@ -26,7 +26,7 @@ fn insert_if_bit_enabled<const B: u16>(entity: &mut EntityWorldMut, i: u16) {
 
 impl<'w> Benchmark<'w> {
     pub fn new(fragment: u16) -> Self {
-        ComputeTaskPool::get_or_init(TaskPool::default);
+        ComputeTaskPool::get_or_init(TaskPoolBuilder::default);
 
         let mut world = World::new();
 

benches/benches/bevy_ecs/iteration/par_iter_simple_foreach_hybrid.rs

@@ -1,5 +1,5 @@
 use bevy_ecs::prelude::*;
-use bevy_tasks::{ComputeTaskPool, TaskPool};
+use bevy_tasks::{ComputeTaskPool, TaskPoolBuilder};
 use rand::{prelude::SliceRandom, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 
@@ -18,7 +18,7 @@ pub struct Benchmark<'w>(World, QueryState<(&'w mut TableData, &'w SparseData)>)
 impl<'w> Benchmark<'w> {
     pub fn new() -> Self {
         let mut world = World::new();
-        ComputeTaskPool::get_or_init(TaskPool::default);
+        ComputeTaskPool::get_or_init(TaskPoolBuilder::default);
 
         let mut v = vec![];
         for _ in 0..100000 {

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

@@ -1476,8 +1476,7 @@ 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();
+        core::hint::spin_loop();
     }
     app.finish();
     app.cleanup();

crates/bevy_app/src/schedule_runner.rs

@@ -77,8 +77,7 @@ impl Plugin for ScheduleRunnerPlugin {
             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();
+                    core::hint::spin_loop();
                 }
                 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);
     }
 }
 
@@ -190,7 +172,7 @@ impl TaskPoolOptions {
                     builder
                 };
 
-                builder.build()
+                builder
             });
         }
 
@@ -220,7 +202,7 @@ impl TaskPoolOptions {
                     builder
                 };
 
-                builder.build()
+                builder
             });
         }
 
@@ -250,7 +232,7 @@ impl TaskPoolOptions {
                     builder
                 };
 
-                builder.build()
+                builder
             });
         }
     }

crates/bevy_asset/Cargo.toml

@@ -30,9 +30,7 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.18.0-dev", default-features = fa
 bevy_reflect = { path = "../bevy_reflect", version = "0.18.0-dev", default-features = false, features = [
   "uuid",
 ] }
-bevy_tasks = { path = "../bevy_tasks", version = "0.18.0-dev", default-features = false, features = [
-  "async_executor",
-] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.18.0-dev", default-features = false }
 bevy_utils = { path = "../bevy_utils", version = "0.18.0-dev", default-features = false }
 bevy_platform = { path = "../bevy_platform", version = "0.18.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/lib.rs

@@ -170,7 +170,7 @@ mod tests {
     };
     use alloc::{string::String, sync::Arc, vec, vec::Vec};
     use bevy_platform::collections::HashSet;
-    use bevy_tasks::{ComputeTaskPool, TaskPool};
+    use bevy_tasks::{ComputeTaskPool, TaskPoolBuilder};
     use core::{
         any::TypeId,
         marker::PhantomData,
@@ -495,7 +495,7 @@ mod tests {
 
     #[test]
     fn par_for_each_dense() {
-        ComputeTaskPool::get_or_init(TaskPool::default);
+        ComputeTaskPool::get_or_init(TaskPoolBuilder::default);
         let mut world = World::new();
         let e1 = world.spawn(A(1)).id();
         let e2 = world.spawn(A(2)).id();
@@ -517,7 +517,7 @@ mod tests {
 
     #[test]
     fn par_for_each_sparse() {
-        ComputeTaskPool::get_or_init(TaskPool::default);
+        ComputeTaskPool::get_or_init(TaskPoolBuilder::default);
         let mut world = World::new();
         let e1 = world.spawn(SparseStored(1)).id();
         let e2 = world.spawn(SparseStored(2)).id();

crates/bevy_ecs/src/query/state.rs

@@ -1345,7 +1345,7 @@ impl<D: QueryData, F: QueryFilter> QueryState<D, F> {
     /// #[derive(Component, PartialEq, Debug)]
     /// struct A(usize);
     ///
-    /// # bevy_tasks::ComputeTaskPool::get_or_init(|| bevy_tasks::TaskPool::new());
+    /// # bevy_tasks::ComputeTaskPool::get_or_init(|| bevy_tasks::TaskPoolBuilder::default());
     ///
     /// let mut world = World::new();
     ///

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

@@ -9,7 +9,7 @@ use core::any::TypeId;
 pub use self::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, TaskPoolBuilder};
 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,
+        ComputeTaskPool::get_or_init(TaskPoolBuilder::default).scope_with_executor(
             thread_executor,
             |scope| {
                 let context = Context {
@@ -871,20 +868,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);
 
-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_ecs/src/schedule/mod.rs

@@ -111,12 +111,12 @@ mod tests {
         #[cfg(not(miri))]
         fn parallel_execution() {
             use alloc::sync::Arc;
-            use bevy_tasks::{ComputeTaskPool, TaskPool};
+            use bevy_tasks::{ComputeTaskPool, TaskPoolBuilder};
             use std::sync::Barrier;
 
             let mut world = World::default();
             let mut schedule = Schedule::default();
-            let thread_count = ComputeTaskPool::get_or_init(TaskPool::default).thread_num();
+            let thread_count = ComputeTaskPool::get_or_init(TaskPoolBuilder::default).thread_num();
 
             let barrier = Arc::new(Barrier::new(thread_count));
 

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

@@ -409,15 +409,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"]