Internalize task distinction into TaskPool

benches/benches/bevy_ecs/iteration/heavy_compute.rs

@@ -1,5 +1,5 @@
 use bevy_ecs::prelude::*;
-use bevy_tasks::{ComputeTaskPool, TaskPool};
+use bevy_tasks::TaskPool;
 use criterion::Criterion;
 use glam::*;
 
@@ -19,9 +19,8 @@ pub fn heavy_compute(c: &mut Criterion) {
     let mut group = c.benchmark_group("heavy_compute");
     group.warm_up_time(std::time::Duration::from_millis(500));
     group.measurement_time(std::time::Duration::from_secs(4));
+    TaskPool::init(TaskPool::default);
     group.bench_function("base", |b| {
-        ComputeTaskPool::init(TaskPool::default);
-
         let mut world = World::default();
 
         world.spawn_batch((0..1000).map(|_| {

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, Resource};
 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};
@@ -448,8 +448,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);
                 }
@@ -701,7 +701,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

@@ -8,7 +8,7 @@ use bevy_ecs::{
     schedule::SystemLabel,
     system::{NonSendMut, Res, ResMut, Resource, SystemState},
 };
-use bevy_tasks::{IoTaskPool, TaskPoolBuilder};
+use bevy_tasks::TaskPool;
 use bevy_utils::HashMap;
 use std::{
     ops::{Deref, DerefMut},
@@ -67,9 +67,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

@@ -4,47 +4,44 @@
 mod name;
 #[cfg(feature = "serialize")]
 mod serde;
-mod task_pool_options;
 
 use bevy_ecs::system::Resource;
 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::{CorePlugin, Name, TaskPoolOptions};
+    pub use crate::{CorePlugin, Name};
 }
 
 use bevy_app::prelude::*;
 use bevy_ecs::entity::Entity;
 use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
+use bevy_tasks::{TaskPool, TaskPoolBuilder};
 use bevy_utils::{Duration, HashSet, Instant};
 use std::borrow::Cow;
 use std::ops::Range;
 
 #[cfg(not(target_arch = "wasm32"))]
 use bevy_ecs::schedule::IntoSystemDescriptor;
-#[cfg(not(target_arch = "wasm32"))]
-use bevy_tasks::tick_global_task_pools_on_main_thread;
 
 /// Adds core functionality to Apps.
 #[derive(Default)]
 pub struct CorePlugin {
     /// Options for the [`TaskPool`](bevy_tasks::TaskPool) created at application start.
-    pub task_pool_options: TaskPoolOptions,
+    pub task_pool_builder: TaskPoolBuilder,
 }
 
 impl Plugin for CorePlugin {
     fn build(&self, app: &mut App) {
         // Setup the default bevy task pools
-        self.task_pool_options.create_default_pools();
+        TaskPool::init(|| self.task_pool_builder.clone().build());
 
         #[cfg(not(target_arch = "wasm32"))]
         app.add_system_to_stage(
             bevy_app::CoreStage::Last,
-            tick_global_task_pools_on_main_thread.at_end(),
+            TaskPool::flush_local_tasks.at_end(),
         );
 
         app.register_type::<Entity>().register_type::<Name>();
@@ -111,38 +108,22 @@ pub struct FrameCount(pub u32);
 #[cfg(test)]
 mod tests {
     use super::*;
-    use bevy_tasks::prelude::{AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool};
+    use bevy_tasks::prelude::TaskPool;
 
     #[test]
     fn runs_spawn_local_tasks() {
         let mut app = App::new();
         app.add_plugin(CorePlugin::default());
 
-        let (async_tx, async_rx) = crossbeam_channel::unbounded();
-        AsyncComputeTaskPool::get()
-            .spawn_local(async move {
-                async_tx.send(()).unwrap();
-            })
-            .detach();
-
-        let (compute_tx, compute_rx) = crossbeam_channel::unbounded();
-        ComputeTaskPool::get()
-            .spawn_local(async move {
-                compute_tx.send(()).unwrap();
-            })
-            .detach();
-
-        let (io_tx, io_rx) = crossbeam_channel::unbounded();
-        IoTaskPool::get()
+        let (tx, rx) = crossbeam_channel::unbounded();
+        TaskPool::get()
             .spawn_local(async move {
-                io_tx.send(()).unwrap();
+                tx.send(()).unwrap();
             })
             .detach();
 
         app.run();
 
-        async_rx.try_recv().unwrap();
-        compute_rx.try_recv().unwrap();
-        io_rx.try_recv().unwrap();
+        rx.try_recv().unwrap();
     }
 }

crates/bevy_ecs/src/lib.rs

@@ -62,7 +62,7 @@ mod tests {
         system::Resource,
         world::{Mut, World},
     };
-    use bevy_tasks::{ComputeTaskPool, TaskPool};
+    use bevy_tasks::TaskPool;
     use std::{
         any::TypeId,
         marker::PhantomData,
@@ -388,7 +388,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(A(1)).id();
         let e2 = world.spawn(A(2)).id();
@@ -410,7 +410,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(SparseStored(1)).id();
         let e2 = world.spawn(SparseStored(2)).id();