Start providing ways to specify priority

Author: james7132

crates/bevy_tasks/src/lib.rs

@@ -66,6 +66,8 @@ pub trait ConditionalSendFuture: Future + ConditionalSend {}
 
 impl<T: Future + ConditionalSend> ConditionalSendFuture for T {}
 
+use core::marker::PhantomData;
+
 use alloc::boxed::Box;
 
 /// An owned and dynamically typed Future used when you can't statically type your result or need to add some indirection.
@@ -201,3 +203,30 @@ pub(crate) struct Metadata {
     pub priority: TaskPriority,
     pub is_send: bool,
 }
+
+pub struct TaskBuilder<T> {
+    priority: TaskPriority,
+    marker_: PhantomData<*const T>
+}
+
+impl<T> TaskBuilder<T> {
+    pub fn with_priority(mut self, priority: TaskPriority) -> Self {
+        self.priority = priority;
+        self
+    }
+
+    pub fn build_metadata(self) -> Metadata {
+        Metadata { 
+            priority: self.priority, 
+            is_send: false,
+        }
+    }
+}
+
+pub struct ScopeTaskBuilder<'a: 'scope, 'scope: 'env, 'env, T> {
+    scope: &'a Scope<'scope, 'env, T>,
+}
+
+impl<'a, 'scope, 'env> ScopeTaskBuilder<'a, 'scope, 'env, T> {
+
+}

crates/bevy_tasks/src/task_pool.rs

@@ -1,6 +1,6 @@
 use alloc::{boxed::Box, format, string::String, vec::Vec};
 use core::{future::Future, marker::PhantomData, mem, panic::AssertUnwindSafe};
-use std::thread::{self, JoinHandle};
+use std::{sync::OnceLock, thread::{self, JoinHandle}};
 
 use crate::{bevy_executor::Executor, Metadata};
 use async_task::FallibleTask;
@@ -12,6 +12,9 @@ use crate::{block_on, Task};
 
 pub use crate::bevy_executor::ThreadSpawner;
 
+static EXECUTOR: Executor = Executor::new();
+static TASK_POOL: OnceLock<TaskPool> = OnceLock::new();
+
 struct CallOnDrop(Option<Arc<dyn Fn() + Send + Sync + 'static>>);
 
 impl Drop for CallOnDrop {
@@ -148,9 +151,16 @@ impl TaskPool {
         self.executor.current_thread_spawner()
     }
 
-    /// Create a `TaskPool` with the default configuration.
-    pub fn new() -> Self {
-        TaskPoolBuilder::new().build()
+    pub fn try_get() -> Option<&'static TaskPool> {
+        TASK_POOL.get()
+    }
+
+    pub fn get() -> &'static TaskPool {
+        Self::get_or_init(Default::default)
+    }
+
+    pub fn get_or_init(f: impl FnOnce() -> TaskPoolBuilder) -> &'static TaskPool {
+        TASK_POOL.get_or_init(|| f().build_static(&EXECUTOR))
     }
 
     fn new_internal(builder: TaskPoolBuilder, executor: &'static Executor) -> Self {
@@ -421,12 +431,6 @@ impl TaskPool {
     }
 }
 
-impl Default for TaskPool {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Drop for TaskPool {
     fn drop(&mut self) {
         self.shutdown_tx.close();
@@ -553,7 +557,7 @@ mod tests {
 
     #[test]
     fn test_spawn() {
-        let pool = TaskPool::new();
+        let pool = TaskPool::get();
 
         let foo = Box::new(42);
         let foo = &*foo;
@@ -636,7 +640,7 @@ mod tests {
 
     #[test]
     fn test_mixed_spawn_on_scope_and_spawn() {
-        let pool = TaskPool::new();
+        let pool = TaskPool::get();
 
         let foo = Box::new(42);
         let foo = &*foo;
@@ -681,7 +685,7 @@ mod tests {
 
     #[test]
     fn test_thread_locality() {
-        let pool = Arc::new(TaskPool::new());
+        let pool = TaskPool::get();
         let count = Arc::new(AtomicI32::new(0));
         let barrier = Arc::new(Barrier::new(101));
         let thread_check_failed = Arc::new(AtomicBool::new(false));
@@ -718,7 +722,7 @@ mod tests {
 
     #[test]
     fn test_nested_spawn() {
-        let pool = TaskPool::new();
+        let pool = TaskPool::get();
 
         let foo = Box::new(42);
         let foo = &*foo;
@@ -756,7 +760,7 @@ mod tests {
 
     #[test]
     fn test_nested_locality() {
-        let pool = Arc::new(TaskPool::new());
+        let pool = TaskPool::get();
         let count = Arc::new(AtomicI32::new(0));
         let barrier = Arc::new(Barrier::new(101));
         let thread_check_failed = Arc::new(AtomicBool::new(false));
@@ -795,7 +799,7 @@ mod tests {
     // This test will often freeze on other executors.
     #[test]
     fn test_nested_scopes() {
-        let pool = TaskPool::new();
+        let pool = TaskPool::get();
         let count = Arc::new(AtomicI32::new(0));
 
         pool.scope(|scope| {

crates/bevy_tasks/src/usages.rs

@@ -1,88 +1,4 @@
-use super::{TaskPool, TaskPoolBuilder};
-use bevy_platform::sync::OnceLock;
-use core::ops::Deref;
-
-crate::cfg::bevy_executor! {
-    if {
-        use crate::bevy_executor::Executor;
-    } else {
-        use crate::edge_executor::Executor;
-    }
-}
-
-macro_rules! taskpool {
-    ($(#[$attr:meta])* ($static:ident, $executor:ident, $type:ident)) => {
-        static $executor: Executor = Executor::new();
-        static $static: OnceLock<$type> = OnceLock::new();
-
-        $(#[$attr])*
-        #[derive(Debug)]
-        pub struct $type(TaskPool);
-
-        impl $type {
-            #[doc = concat!(" Gets the global [`", stringify!($type), "`] instance, or initializes it with `f`.")]
-            pub fn get_or_init(f: impl FnOnce() -> TaskPoolBuilder) -> &'static Self {
-                $static.get_or_init(|| Self(f().build_static(&$executor)))
-            }
-
-            #[doc = concat!(" Attempts to get the global [`", stringify!($type), "`] instance, \
-                or returns `None` if it is not initialized.")]
-            pub fn try_get() -> Option<&'static Self> {
-                $static.get()
-            }
-
-            #[doc = concat!(" Gets the global [`", stringify!($type), "`] instance.")]
-            #[doc = ""]
-            #[doc = " # Panics"]
-            #[doc = " Panics if the global instance has not been initialized yet."]
-            pub fn get() -> &'static Self {
-                $static.get().expect(
-                    concat!(
-                        "The ",
-                        stringify!($type),
-                        " has not been initialized yet. Please call ",
-                        stringify!($type),
-                        "::get_or_init beforehand."
-                    )
-                )
-            }
-        }
-
-        impl Deref for $type {
-            type Target = TaskPool;
-
-            fn deref(&self) -> &Self::Target {
-                &self.0
-            }
-        }
-    };
-}
-
-taskpool! {
-    /// A newtype for a task pool for CPU-intensive work that must be completed to
-    /// deliver the next frame
-    ///
-    /// See [`TaskPool`] documentation for details on Bevy tasks.
-    /// [`AsyncComputeTaskPool`] should be preferred if the work does not have to be
-    /// completed before the next frame.
-    (COMPUTE_TASK_POOL, COMPUTE_EXECUTOR, ComputeTaskPool)
-}
-
-taskpool! {
-    /// A newtype for a task pool for CPU-intensive work that may span across multiple frames
-    ///
-    /// See [`TaskPool`] documentation for details on Bevy tasks.
-    /// Use [`ComputeTaskPool`] if the work must be complete before advancing to the next frame.
-    (ASYNC_COMPUTE_TASK_POOL, ASYNC_COMPUTE_EXECUTOR, AsyncComputeTaskPool)
-}
-
-taskpool! {
-    /// A newtype for a task pool for IO-intensive work (i.e. tasks that spend very little time in a
-    /// "woken" state)
-    ///
-    /// See [`TaskPool`] documentation for details on Bevy tasks.
-    (IO_TASK_POOL, IO_EXECUTOR, IoTaskPool)
-}
+use super::TaskPool;
 
 crate::cfg::web! {
     if {} else {