Internalize task distinction into TaskPool

benches/benches/bevy_ecs/ecs_bench_suite/heavy_compute.rs

@@ -1,5 +1,5 @@
 use bevy_ecs::prelude::*;
-use bevy_tasks::{ComputeTaskPool, TaskPool};
+use bevy_tasks::TaskPool;
 use glam::*;
 
 #[derive(Component, Copy, Clone)]
@@ -18,7 +18,7 @@ pub struct Benchmark(World, Box<dyn System<In = (), Out = ()>>);
 
 impl Benchmark {
     pub fn new() -> Self {
-        ComputeTaskPool::init(TaskPool::default);
+        TaskPool::init(TaskPool::default);
 
         let mut world = World::default();
 

benches/benches/bevy_tasks/iter.rs

@@ -1,4 +1,4 @@
-use bevy_tasks::{ParallelIterator, TaskPoolBuilder};
+use bevy_tasks::{ParallelIterator, TaskPool};
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 
 struct ParChunks<'a, T>(std::slice::Chunks<'a, T>);
@@ -34,7 +34,7 @@ fn bench_overhead(c: &mut Criterion) {
     let mut v = (0..10000).collect::<Vec<usize>>();
     let mut group = c.benchmark_group("overhead_par_iter");
     for thread_count in &[1, 2, 4, 8, 16, 32] {
-        let pool = TaskPoolBuilder::new().num_threads(*thread_count).build();
+        let pool = TaskPool::build().threads(*thread_count).build();
         group.bench_with_input(
             BenchmarkId::new("threads", thread_count),
             thread_count,
@@ -69,7 +69,7 @@ fn bench_for_each(c: &mut Criterion) {
     let mut v = (0..10000).collect::<Vec<usize>>();
     let mut group = c.benchmark_group("for_each_par_iter");
     for thread_count in &[1, 2, 4, 8, 16, 32] {
-        let pool = TaskPoolBuilder::new().num_threads(*thread_count).build();
+        let pool = TaskPool::build().threads(*thread_count).build();
         group.bench_with_input(
             BenchmarkId::new("threads", thread_count),
             thread_count,
@@ -115,7 +115,7 @@ fn bench_many_maps(c: &mut Criterion) {
     let v = (0..10000).collect::<Vec<usize>>();
     let mut group = c.benchmark_group("many_maps_par_iter");
     for thread_count in &[1, 2, 4, 8, 16, 32] {
-        let pool = TaskPoolBuilder::new().num_threads(*thread_count).build();
+        let pool = TaskPool::build().threads(*thread_count).build();
         group.bench_with_input(
             BenchmarkId::new("threads", thread_count),
             thread_count,

crates/bevy_asset/src/asset_server.rs

@@ -7,7 +7,7 @@ use crate::{
 use anyhow::Result;
 use bevy_ecs::system::{Res, ResMut};
 use bevy_log::warn;
-use bevy_tasks::IoTaskPool;
+use bevy_tasks::{TaskGroup, TaskPool};
 use bevy_utils::{Entry, HashMap, Uuid};
 use crossbeam_channel::TryRecvError;
 use parking_lot::{Mutex, RwLock};
@@ -374,8 +374,8 @@ impl AssetServer {
     pub(crate) fn load_untracked(&self, asset_path: AssetPath<'_>, force: bool) -> HandleId {
         let server = self.clone();
         let owned_path = asset_path.to_owned();
-        IoTaskPool::get()
-            .spawn(async move {
+        TaskPool::get()
+            .spawn(TaskGroup::IO, async move {
                 if let Err(err) = server.load_async(owned_path, force).await {
                     warn!("{}", err);
                 }
@@ -616,7 +616,7 @@ mod test {
 
     fn setup(asset_path: impl AsRef<Path>) -> AssetServer {
         use crate::FileAssetIo;
-        IoTaskPool::init(Default::default);
+        TaskPool::init(Default::default);
         AssetServer::new(FileAssetIo::new(asset_path, false))
     }
 

crates/bevy_asset/src/debug_asset_server.rs

@@ -4,7 +4,7 @@ use bevy_ecs::{
     schedule::SystemLabel,
     system::{NonSendMut, Res, ResMut, SystemState},
 };
-use bevy_tasks::{IoTaskPool, TaskPoolBuilder};
+use bevy_tasks::TaskPool;
 use bevy_utils::HashMap;
 use std::{
     ops::{Deref, DerefMut},
@@ -58,9 +58,9 @@ impl<T: Asset> Default for HandleMap<T> {
 
 impl Plugin for DebugAssetServerPlugin {
     fn build(&self, app: &mut bevy_app::App) {
-        IoTaskPool::init(|| {
-            TaskPoolBuilder::default()
-                .num_threads(2)
+        TaskPool::init(|| {
+            TaskPool::build()
+                .max_threads(2)
                 .thread_name("Debug Asset Server IO Task Pool".to_string())
                 .build()
         });

crates/bevy_core/src/lib.rs

@@ -2,20 +2,19 @@
 //! This crate provides core functionality for Bevy Engine.
 
 mod name;
-mod task_pool_options;
 
 pub use bytemuck::{bytes_of, cast_slice, Pod, Zeroable};
 pub use name::*;
-pub use task_pool_options::*;
 
 pub mod prelude {
     //! The Bevy Core Prelude.
     #[doc(hidden)]
-    pub use crate::{DefaultTaskPoolOptions, Name};
+    pub use crate::Name;
 }
 
 use bevy_app::prelude::*;
 use bevy_ecs::entity::Entity;
+use bevy_tasks::TaskPool;
 use bevy_utils::HashSet;
 use std::ops::Range;
 
@@ -25,12 +24,8 @@ pub struct CorePlugin;
 
 impl Plugin for CorePlugin {
     fn build(&self, app: &mut App) {
-        // Setup the default bevy task pools
-        app.world
-            .get_resource::<DefaultTaskPoolOptions>()
-            .cloned()
-            .unwrap_or_default()
-            .create_default_pools();
+        // Setup the default bevy task pool if not already set up
+        app.world.init_resource::<TaskPool>();
 
         app.register_type::<Entity>().register_type::<Name>();
 

crates/bevy_ecs/src/lib.rs

@@ -59,7 +59,7 @@ mod tests {
         query::{Added, ChangeTrackers, Changed, FilteredAccess, With, Without, WorldQuery},
         world::{Mut, World},
     };
-    use bevy_tasks::{ComputeTaskPool, TaskPool};
+    use bevy_tasks::TaskPool;
     use std::{
         any::TypeId,
         sync::{
@@ -375,7 +375,7 @@ mod tests {
 
     #[test]
     fn par_for_each_dense() {
-        ComputeTaskPool::init(TaskPool::default);
+        TaskPool::init(TaskPool::default);
         let mut world = World::new();
         let e1 = world.spawn().insert(A(1)).id();
         let e2 = world.spawn().insert(A(2)).id();
@@ -397,7 +397,7 @@ mod tests {
 
     #[test]
     fn par_for_each_sparse() {
-        ComputeTaskPool::init(TaskPool::default);
+        TaskPool::init(TaskPool::default);
         let mut world = World::new();
         let e1 = world.spawn().insert(SparseStored(1)).id();
         let e2 = world.spawn().insert(SparseStored(2)).id();

crates/bevy_ecs/src/query/state.rs

@@ -10,7 +10,7 @@ use crate::{
     storage::TableId,
     world::{World, WorldId},
 };
-use bevy_tasks::ComputeTaskPool;
+use bevy_tasks::{TaskGroup, TaskPool};
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::Instrument;
 use fixedbitset::FixedBitSet;
@@ -750,7 +750,7 @@ impl<Q: WorldQuery, F: WorldQuery> QueryState<Q, F> {
     /// write-queries.
     ///
     /// # Panics
-    /// The [`ComputeTaskPool`] is not initialized. If using this from a query that is being
+    /// The [`TaskPool`] is not initialized. If using this from a query that is being
     /// initialized and run from the ECS scheduler, this should never panic.
     #[inline]
     pub fn par_for_each<'w, FN: Fn(ROQueryItem<'w, Q>) + Send + Sync + Clone>(
@@ -775,7 +775,7 @@ impl<Q: WorldQuery, F: WorldQuery> QueryState<Q, F> {
     /// Runs `func` on each query result in parallel.
     ///
     /// # Panics
-    /// The [`ComputeTaskPool`] is not initialized. If using this from a query that is being
+    /// The [`TaskPool`] is not initialized. If using this from a query that is being
     /// initialized and run from the ECS scheduler, this should never panic.
     #[inline]
     pub fn par_for_each_mut<'w, FN: Fn(QueryItem<'w, Q>) + Send + Sync + Clone>(
@@ -802,7 +802,7 @@ impl<Q: WorldQuery, F: WorldQuery> QueryState<Q, F> {
     /// This can only be called for read-only queries.
     ///
     /// # Panics
-    /// The [`ComputeTaskPool`] is not initialized. If using this from a query that is being
+    /// The [`TaskPool`] is not initialized. If using this from a query that is being
     /// initialized and run from the ECS scheduler, this should never panic.
     ///
     /// # Safety
@@ -918,7 +918,7 @@ impl<Q: WorldQuery, F: WorldQuery> QueryState<Q, F> {
     /// iter() method, but cannot be chained like a normal [`Iterator`].
     ///
     /// # Panics
-    /// The [`ComputeTaskPool`] is not initialized. If using this from a query that is being
+    /// The [`TaskPool`] is not initialized. If using this from a query that is being
     /// initialized and run from the ECS scheduler, this should never panic.
     ///
     /// # Safety
@@ -941,7 +941,7 @@ impl<Q: WorldQuery, F: WorldQuery> QueryState<Q, F> {
     ) {
         // NOTE: If you are changing query iteration code, remember to update the following places, where relevant:
         // QueryIter, QueryIterationCursor, QueryState::for_each_unchecked_manual, QueryState::many_for_each_unchecked_manual, QueryState::par_for_each_unchecked_manual
-        ComputeTaskPool::get().scope(|scope| {
+        TaskPool::get().scope(TaskGroup::Compute, |scope| {
             if QF::IS_DENSE && <QueryFetch<'static, F>>::IS_DENSE {
                 let tables = &world.storages().tables;
                 for table_id in &self.matched_table_ids {

crates/bevy_ecs/src/schedule/executor_parallel.rs

@@ -5,7 +5,7 @@ use crate::{
     world::World,
 };
 use async_channel::{Receiver, Sender};
-use bevy_tasks::{ComputeTaskPool, Scope, TaskPool};
+use bevy_tasks::{Scope, TaskGroup, TaskPool};
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::Instrument;
 use fixedbitset::FixedBitSet;
@@ -123,7 +123,7 @@ impl ParallelSystemExecutor for ParallelExecutor {
             }
         }
 
-        ComputeTaskPool::init(TaskPool::default).scope(|scope| {
+        TaskPool::init(TaskPool::default).scope(TaskGroup::Compute, |scope| {
             self.prepare_systems(scope, systems, world);
             let parallel_executor = async {
                 // All systems have been ran if there are no queued or running systems.

crates/bevy_ecs/src/system/commands/parallel_scope.rs

@@ -24,7 +24,6 @@ pub struct ParallelCommandsState {
 /// Example:
 /// ```
 /// # use bevy_ecs::prelude::*;
-/// # use bevy_tasks::ComputeTaskPool;
 /// #
 /// # #[derive(Component)]
 /// # struct Velocity;