From 271d700ef775d5dd04b19c70b1c4b8d167357615 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Sat, 5 Jun 2021 23:48:40 -0600
Subject: [PATCH 01/17] Handle TaskPool panicking threads

---
 crates/bevy_core/src/lib.rs               |   6 +
 crates/bevy_core/src/task_pool_options.rs |  78 ++++++---
 crates/bevy_tasks/Cargo.toml              |   2 +
 crates/bevy_tasks/src/lib.rs              |   7 +-
 crates/bevy_tasks/src/task_pool.rs        | 196 +++++++++++++++++++---
 crates/bevy_tasks/src/usages.rs           |  10 ++
 6 files changed, 249 insertions(+), 50 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 75fd87adb5ebb..c03836345a3b3 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -23,8 +23,10 @@ use bevy_ecs::{
     schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
     system::{IntoExclusiveSystem, IntoSystem},
 };
+use bevy_tasks::{AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool};
 use bevy_utils::HashSet;
 use std::ops::Range;
+use task_pool_options::handle_task_pool_panicking_threads_system;
 
 /// Adds core functionality to Apps.
 #[derive(Default)]
@@ -46,6 +48,10 @@ impl Plugin for CorePlugin {
             .unwrap_or_else(DefaultTaskPoolOptions::default)
             .create_default_pools(app.world_mut());
 
+        app.add_system(handle_task_pool_panicking_threads_system::<IoTaskPool>.system())
+            .add_system(handle_task_pool_panicking_threads_system::<ComputeTaskPool>.system())
+            .add_system(handle_task_pool_panicking_threads_system::<AsyncComputeTaskPool>.system());
+
         app.init_resource::<Time>()
             .init_resource::<EntityLabels>()
             .init_resource::<FixedTimesteps>()
diff --git a/crates/bevy_core/src/task_pool_options.rs b/crates/bevy_core/src/task_pool_options.rs
index 19c9dad5bfe2f..2ccaa7b432bdc 100644
--- a/crates/bevy_core/src/task_pool_options.rs
+++ b/crates/bevy_core/src/task_pool_options.rs
@@ -1,10 +1,22 @@
-use bevy_ecs::world::World;
-use bevy_tasks::{AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolBuilder};
+use bevy_ecs::{system::Res, world::World};
+use bevy_tasks::{
+    AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolBuilder, TaskPoolTrait,
+    ThreadPanicPolicy,
+};
 use bevy_utils::tracing::trace;
 
+/// DOCS: todo
+#[derive(Clone, Debug)]
+pub struct TaskPoolPolicies {
+    /// Used to determine number of threads to allocate
+    pub assignment_policy: TaskPoolThreadAssignmentPolicy,
+    /// Used to determine the panic policy of the task pool
+    pub panic_policy: ThreadPanicPolicy,
+}
+
 /// Defines a simple way to determine how many threads to use given the number of remaining cores
 /// and number of total cores
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct TaskPoolThreadAssignmentPolicy {
     /// Force using at least this many threads
     pub min_threads: usize,
@@ -42,13 +54,12 @@ pub struct DefaultTaskPoolOptions {
     /// If the number of physical cores is grater than max_total_threads, force using
     /// max_total_threads
     pub max_total_threads: usize,
-
-    /// Used to determine number of IO threads to allocate
-    pub io: TaskPoolThreadAssignmentPolicy,
-    /// Used to determine number of async compute threads to allocate
-    pub async_compute: TaskPoolThreadAssignmentPolicy,
-    /// Used to determine number of compute threads to allocate
-    pub compute: TaskPoolThreadAssignmentPolicy,
+    /// Used to configure the IOTaskPool's inner policies
+    pub io: TaskPoolPolicies,
+    /// Used to configure the AsyncTaskPool's inner policies
+    pub async_compute: TaskPoolPolicies,
+    /// Used to configure the ComputeTaskPool's inner policies
+    pub compute: TaskPoolPolicies,
 }
 
 impl Default for DefaultTaskPoolOptions {
@@ -59,24 +70,33 @@ impl Default for DefaultTaskPoolOptions {
             max_total_threads: std::usize::MAX,
 
             // Use 25% of cores for IO, at least 1, no more than 4
-            io: TaskPoolThreadAssignmentPolicy {
-                min_threads: 1,
-                max_threads: 4,
-                percent: 0.25,
+            io: TaskPoolPolicies {
+                assignment_policy: TaskPoolThreadAssignmentPolicy {
+                    min_threads: 1,
+                    max_threads: 4,
+                    percent: 0.25,
+                },
+                panic_policy: ThreadPanicPolicy::Restart,
             },
 
             // Use 25% of cores for async compute, at least 1, no more than 4
-            async_compute: TaskPoolThreadAssignmentPolicy {
-                min_threads: 1,
-                max_threads: 4,
-                percent: 0.25,
+            async_compute: TaskPoolPolicies {
+                assignment_policy: TaskPoolThreadAssignmentPolicy {
+                    min_threads: 1,
+                    max_threads: 4,
+                    percent: 0.25,
+                },
+                panic_policy: ThreadPanicPolicy::Restart,
             },
 
             // Use all remaining cores for compute (at least 1)
-            compute: TaskPoolThreadAssignmentPolicy {
-                min_threads: 1,
-                max_threads: std::usize::MAX,
-                percent: 1.0, // This 1.0 here means "whatever is left over"
+            compute: TaskPoolPolicies {
+                assignment_policy: TaskPoolThreadAssignmentPolicy {
+                    min_threads: 1,
+                    max_threads: std::usize::MAX,
+                    percent: 1.0, // This 1.0 here means "whatever is left over"
+                },
+                panic_policy: ThreadPanicPolicy::Restart,
             },
         }
     }
@@ -104,6 +124,7 @@ impl DefaultTaskPoolOptions {
             // Determine the number of IO threads we will use
             let io_threads = self
                 .io
+                .assignment_policy
                 .get_number_of_threads(remaining_threads, total_threads);
 
             trace!("IO Threads: {}", io_threads);
@@ -113,6 +134,7 @@ impl DefaultTaskPoolOptions {
                 TaskPoolBuilder::default()
                     .num_threads(io_threads)
                     .thread_name("IO Task Pool".to_string())
+                    .panic_policy(self.io.panic_policy)
                     .build(),
             ));
         }
@@ -121,6 +143,7 @@ impl DefaultTaskPoolOptions {
             // Determine the number of async compute threads we will use
             let async_compute_threads = self
                 .async_compute
+                .assignment_policy
                 .get_number_of_threads(remaining_threads, total_threads);
 
             trace!("Async Compute Threads: {}", async_compute_threads);
@@ -130,6 +153,7 @@ impl DefaultTaskPoolOptions {
                 TaskPoolBuilder::default()
                     .num_threads(async_compute_threads)
                     .thread_name("Async Compute Task Pool".to_string())
+                    .panic_policy(self.async_compute.panic_policy)
                     .build(),
             ));
         }
@@ -139,6 +163,7 @@ impl DefaultTaskPoolOptions {
             // This is intentionally last so that an end user can specify 1.0 as the percent
             let compute_threads = self
                 .compute
+                .assignment_policy
                 .get_number_of_threads(remaining_threads, total_threads);
 
             trace!("Compute Threads: {}", compute_threads);
@@ -146,8 +171,17 @@ impl DefaultTaskPoolOptions {
                 TaskPoolBuilder::default()
                     .num_threads(compute_threads)
                     .thread_name("Compute Task Pool".to_string())
+                    .panic_policy(self.compute.panic_policy)
                     .build(),
             ));
         }
     }
 }
+
+pub(crate) fn handle_task_pool_panicking_threads_system<
+    T: TaskPoolTrait + Send + Sync + 'static,
+>(
+    task_pool: Res<T>,
+) {
+    bevy_tasks::handle_task_pool_panicking_threads(&**task_pool);
+}
diff --git a/crates/bevy_tasks/Cargo.toml b/crates/bevy_tasks/Cargo.toml
index f2c1bf41f396b..7284331378d89 100644
--- a/crates/bevy_tasks/Cargo.toml
+++ b/crates/bevy_tasks/Cargo.toml
@@ -16,6 +16,8 @@ keywords = ["bevy"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+tracing = { version = "0.1", features = ["release_max_level_info"] }
+parking_lot = "0.11.0"
 futures-lite = "1.4.0"
 event-listener = "2.4.0"
 async-executor = "1.3.0"
diff --git a/crates/bevy_tasks/src/lib.rs b/crates/bevy_tasks/src/lib.rs
index 08d7dfc42b988..807ecadcbc81f 100644
--- a/crates/bevy_tasks/src/lib.rs
+++ b/crates/bevy_tasks/src/lib.rs
@@ -7,7 +7,7 @@ pub use task::Task;
 #[cfg(not(target_arch = "wasm32"))]
 mod task_pool;
 #[cfg(not(target_arch = "wasm32"))]
-pub use task_pool::{Scope, TaskPool, TaskPoolBuilder};
+pub use task_pool::{Scope, TaskPool, TaskPoolBuilder, ThreadPanicPolicy};
 
 #[cfg(target_arch = "wasm32")]
 mod single_threaded_task_pool;
@@ -15,7 +15,10 @@ mod single_threaded_task_pool;
 pub use single_threaded_task_pool::{Scope, TaskPool, TaskPoolBuilder};
 
 mod usages;
-pub use usages::{AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool};
+pub use usages::{
+    handle_task_pool_panicking_threads, AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool,
+    TaskPoolTrait,
+};
 
 mod countdown_event;
 pub use countdown_event::CountdownEvent;
diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index 9331799120583..f9e8d318f0be6 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -1,15 +1,30 @@
+use futures_lite::{future, pin};
+use parking_lot::RwLock;
 use std::{
     future::Future,
     mem,
     pin::Pin,
-    sync::Arc,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
     thread::{self, JoinHandle},
 };
-
-use futures_lite::{future, pin};
+use tracing::warn;
 
 use crate::Task;
 
+/// The policy used when a [`TaskPool`]'s thread panics
+#[derive(Copy, Clone, Debug)]
+pub enum ThreadPanicPolicy {
+    /// Propagate the panic to the main thread, causing the main
+    /// thread to panic as well.
+    Propagate,
+    /// Restart the thread by joining the panicked thread and
+    /// spawning another one in it's place.
+    Restart,
+}
+
 /// Used to create a TaskPool
 #[derive(Debug, Default, Clone)]
 pub struct TaskPoolBuilder {
@@ -21,6 +36,8 @@ pub struct TaskPoolBuilder {
     /// Allows customizing the name of the threads - helpful for debugging. If set, threads will
     /// be named <thread_name> (<thread_index>), i.e. "MyThreadPool (2)"
     thread_name: Option<String>,
+    /// Allows customizing the policy for when a [`TaskPool`]'s thread(s) panic.
+    panic_policy: Option<ThreadPanicPolicy>,
 }
 
 impl TaskPoolBuilder {
@@ -49,19 +66,53 @@ impl TaskPoolBuilder {
         self
     }
 
+    pub fn panic_policy(mut self, policy: ThreadPanicPolicy) -> Self {
+        self.panic_policy = Some(policy);
+        self
+    }
+
     /// Creates a new ThreadPoolBuilder based on the current options.
     pub fn build(self) -> TaskPool {
         TaskPool::new_internal(
             self.num_threads,
             self.stack_size,
             self.thread_name.as_deref(),
+            self.panic_policy,
         )
     }
 }
 
+#[derive(Debug)]
+struct ThreadState {
+    handle: JoinHandle<()>,
+    panicking: Arc<AtomicBool>,
+}
+
+impl ThreadState {
+    pub fn panicking(&self) -> bool {
+        self.panicking.load(Ordering::Acquire)
+    }
+
+    pub fn thread(&self) -> &std::thread::Thread {
+        self.handle.thread()
+    }
+}
+
+struct PanicState {
+    panicking: Arc<AtomicBool>,
+}
+
+impl Drop for PanicState {
+    fn drop(&mut self) {
+        if thread::panicking() {
+            self.panicking.store(true, Ordering::Release);
+        }
+    }
+}
+
 #[derive(Debug)]
 struct TaskPoolInner {
-    threads: Vec<JoinHandle<()>>,
+    threads: Vec<ThreadState>,
     shutdown_tx: async_channel::Sender<()>,
 }
 
@@ -70,8 +121,8 @@ impl Drop for TaskPoolInner {
         self.shutdown_tx.close();
 
         let panicking = thread::panicking();
-        for join_handle in self.threads.drain(..) {
-            let res = join_handle.join();
+        for state in self.threads.drain(..) {
+            let res = state.handle.join();
             if !panicking {
                 res.expect("Task thread panicked while executing.");
             }
@@ -91,7 +142,14 @@ pub struct TaskPool {
     executor: Arc<async_executor::Executor<'static>>,
 
     /// Inner state of the pool
-    inner: Arc<TaskPoolInner>,
+    inner: Arc<RwLock<TaskPoolInner>>,
+
+    /// Panic policy of the inner thread pool.
+    panic_policy: ThreadPanicPolicy,
+
+    /// Receiving channel used when an inner thread panics and
+    /// another one is spawned in its place.
+    shutdown_rx: async_channel::Receiver<()>,
 }
 
 impl TaskPool {
@@ -104,10 +162,102 @@ impl TaskPool {
         TaskPoolBuilder::new().build()
     }
 
+    fn any_panicking_threads(&self) -> bool {
+        self.inner
+            .read()
+            .threads
+            .iter()
+            .any(|state| state.panicking())
+    }
+
+    pub(crate) fn handle_panicking_threads(&self) {
+        match self.panic_policy {
+            ThreadPanicPolicy::Propagate => {
+                if self.any_panicking_threads() {
+                    for state in self.inner.write().threads.drain(..) {
+                        let thread = state.thread().clone();
+                        if let Err(err) = state.handle.join() {
+                            panic!(
+                                "TaskPool's inner thread '{:?}' panicked with error: {:?}",
+                                thread, err
+                            );
+                        }
+                    }
+                }
+            }
+            ThreadPanicPolicy::Restart => {
+                if self.any_panicking_threads() {
+                    for (idx, state) in self
+                        .inner
+                        .write()
+                        .threads
+                        .iter_mut()
+                        .filter(|state| state.panicking())
+                        .enumerate()
+                    {
+                        let thread_name = match state.thread().name() {
+                            Some(name) => name.to_owned(),
+                            None => format!("TaskPool ({})", idx),
+                        };
+
+                        let old_state = std::mem::replace(
+                            state,
+                            Self::spawn_thread_internal(
+                                None,
+                                thread_name,
+                                self.executor.clone(),
+                                self.shutdown_rx.clone(),
+                            ),
+                        );
+
+                        // join the panicked thread handle
+                        let panic_error = old_state.handle.join().unwrap_err();
+
+                        warn!(
+                            "TaskPool's inner thread '{:?}' panicked with error: {:?}",
+                            state.thread(),
+                            panic_error
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    fn spawn_thread_internal(
+        stack_size: Option<usize>,
+        thread_name: String,
+        executor: Arc<async_executor::Executor<'static>>,
+        shutdown_rx: async_channel::Receiver<()>,
+    ) -> ThreadState {
+        let mut thread_builder = thread::Builder::new().name(thread_name);
+
+        if let Some(stack_size) = stack_size {
+            thread_builder = thread_builder.stack_size(stack_size);
+        }
+
+        let panicking = Arc::new(AtomicBool::new(false));
+        let panicking_clone = panicking.clone();
+
+        let handle = thread_builder
+            .spawn(move || {
+                let _panic_state = PanicState {
+                    panicking: panicking_clone,
+                };
+                let shutdown_future = executor.run(shutdown_rx.recv());
+                // Use unwrap_err because we expect a Closed error
+                future::block_on(shutdown_future).unwrap_err();
+            })
+            .expect("Failed to spawn thread.");
+
+        ThreadState { handle, panicking }
+    }
+
     fn new_internal(
         num_threads: Option<usize>,
         stack_size: Option<usize>,
         thread_name: Option<&str>,
+        panic_policy: Option<ThreadPanicPolicy>,
     ) -> Self {
         let (shutdown_tx, shutdown_rx) = async_channel::unbounded::<()>();
 
@@ -117,43 +267,37 @@ impl TaskPool {
 
         let threads = (0..num_threads)
             .map(|i| {
-                let ex = Arc::clone(&executor);
-                let shutdown_rx = shutdown_rx.clone();
-
                 let thread_name = if let Some(thread_name) = thread_name {
                     format!("{} ({})", thread_name, i)
                 } else {
                     format!("TaskPool ({})", i)
                 };
 
-                let mut thread_builder = thread::Builder::new().name(thread_name);
-
-                if let Some(stack_size) = stack_size {
-                    thread_builder = thread_builder.stack_size(stack_size);
-                }
-
-                thread_builder
-                    .spawn(move || {
-                        let shutdown_future = ex.run(shutdown_rx.recv());
-                        // Use unwrap_err because we expect a Closed error
-                        future::block_on(shutdown_future).unwrap_err();
-                    })
-                    .expect("Failed to spawn thread.")
+                Self::spawn_thread_internal(
+                    stack_size,
+                    thread_name,
+                    executor.clone(),
+                    shutdown_rx.clone(),
+                )
             })
             .collect();
 
+        let panic_policy = panic_policy.unwrap_or(ThreadPanicPolicy::Restart);
+
         Self {
             executor,
-            inner: Arc::new(TaskPoolInner {
+            inner: Arc::new(RwLock::new(TaskPoolInner {
                 threads,
                 shutdown_tx,
-            }),
+            })),
+            panic_policy,
+            shutdown_rx,
         }
     }
 
     /// Return the number of threads owned by the task pool
     pub fn thread_num(&self) -> usize {
-        self.inner.threads.len()
+        self.inner.read().threads.len()
     }
 
     /// Allows spawning non-`static futures on the thread pool. The function takes a callback,
diff --git a/crates/bevy_tasks/src/usages.rs b/crates/bevy_tasks/src/usages.rs
index 7adf60639b116..3d0e754aff1de 100644
--- a/crates/bevy_tasks/src/usages.rs
+++ b/crates/bevy_tasks/src/usages.rs
@@ -50,3 +50,13 @@ impl Deref for IoTaskPool {
         &self.0
     }
 }
+
+/// TODO: RENAME
+pub trait TaskPoolTrait: Deref<Target = TaskPool> {}
+
+impl<T> TaskPoolTrait for T where T: Deref<Target = TaskPool> {}
+
+#[doc(hidden)]
+pub fn handle_task_pool_panicking_threads(task_pool: &TaskPool) {
+    task_pool.handle_panicking_threads();
+}

From 8ad299fb26a1f73002212b1664cce0f939181c2d Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Sun, 6 Jun 2021 00:31:08 -0600
Subject: [PATCH 02/17] appease the wasm gods

---
 crates/bevy_core/src/lib.rs               | 1 +
 crates/bevy_core/src/task_pool_options.rs | 1 +
 crates/bevy_tasks/src/lib.rs              | 9 ++++-----
 crates/bevy_tasks/src/task_pool.rs        | 5 +++++
 crates/bevy_tasks/src/usages.rs           | 5 -----
 5 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index c03836345a3b3..2576e092aae24 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -48,6 +48,7 @@ impl Plugin for CorePlugin {
             .unwrap_or_else(DefaultTaskPoolOptions::default)
             .create_default_pools(app.world_mut());
 
+        #[cfg(not(target_arch = "wasm32"))]
         app.add_system(handle_task_pool_panicking_threads_system::<IoTaskPool>.system())
             .add_system(handle_task_pool_panicking_threads_system::<ComputeTaskPool>.system())
             .add_system(handle_task_pool_panicking_threads_system::<AsyncComputeTaskPool>.system());
diff --git a/crates/bevy_core/src/task_pool_options.rs b/crates/bevy_core/src/task_pool_options.rs
index 2ccaa7b432bdc..19f6a6ea928cd 100644
--- a/crates/bevy_core/src/task_pool_options.rs
+++ b/crates/bevy_core/src/task_pool_options.rs
@@ -178,6 +178,7 @@ impl DefaultTaskPoolOptions {
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn handle_task_pool_panicking_threads_system<
     T: TaskPoolTrait + Send + Sync + 'static,
 >(
diff --git a/crates/bevy_tasks/src/lib.rs b/crates/bevy_tasks/src/lib.rs
index 807ecadcbc81f..c1328034afe27 100644
--- a/crates/bevy_tasks/src/lib.rs
+++ b/crates/bevy_tasks/src/lib.rs
@@ -7,7 +7,9 @@ pub use task::Task;
 #[cfg(not(target_arch = "wasm32"))]
 mod task_pool;
 #[cfg(not(target_arch = "wasm32"))]
-pub use task_pool::{Scope, TaskPool, TaskPoolBuilder, ThreadPanicPolicy};
+pub use task_pool::{
+    handle_task_pool_panicking_threads, Scope, TaskPool, TaskPoolBuilder, ThreadPanicPolicy,
+};
 
 #[cfg(target_arch = "wasm32")]
 mod single_threaded_task_pool;
@@ -15,10 +17,7 @@ mod single_threaded_task_pool;
 pub use single_threaded_task_pool::{Scope, TaskPool, TaskPoolBuilder};
 
 mod usages;
-pub use usages::{
-    handle_task_pool_panicking_threads, AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool,
-    TaskPoolTrait,
-};
+pub use usages::{AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolTrait};
 
 mod countdown_event;
 pub use countdown_event::CountdownEvent;
diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index f9e8d318f0be6..5cd2f24838fe8 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -394,6 +394,11 @@ impl Default for TaskPool {
     }
 }
 
+#[doc(hidden)]
+pub fn handle_task_pool_panicking_threads(task_pool: &TaskPool) {
+    task_pool.handle_panicking_threads();
+}
+
 #[derive(Debug)]
 pub struct Scope<'scope, T> {
     executor: &'scope async_executor::Executor<'scope>,
diff --git a/crates/bevy_tasks/src/usages.rs b/crates/bevy_tasks/src/usages.rs
index 3d0e754aff1de..34c5bc4bbd704 100644
--- a/crates/bevy_tasks/src/usages.rs
+++ b/crates/bevy_tasks/src/usages.rs
@@ -55,8 +55,3 @@ impl Deref for IoTaskPool {
 pub trait TaskPoolTrait: Deref<Target = TaskPool> {}
 
 impl<T> TaskPoolTrait for T where T: Deref<Target = TaskPool> {}
-
-#[doc(hidden)]
-pub fn handle_task_pool_panicking_threads(task_pool: &TaskPool) {
-    task_pool.handle_panicking_threads();
-}

From 58cec2ea53c80439f700b3b6b6730d0f211ecfe2 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 13:24:53 -0600
Subject: [PATCH 03/17] refactor PanicPolicy to task_pool_common

---
 crates/bevy_tasks/src/lib.rs                       |  7 ++++---
 crates/bevy_tasks/src/single_threaded_task_pool.rs |  5 +++++
 crates/bevy_tasks/src/task_pool.rs                 | 14 +-------------
 crates/bevy_tasks/src/task_pool_common.rs          | 10 ++++++++++
 4 files changed, 20 insertions(+), 16 deletions(-)
 create mode 100644 crates/bevy_tasks/src/task_pool_common.rs

diff --git a/crates/bevy_tasks/src/lib.rs b/crates/bevy_tasks/src/lib.rs
index c1328034afe27..6b159c0ec13a9 100644
--- a/crates/bevy_tasks/src/lib.rs
+++ b/crates/bevy_tasks/src/lib.rs
@@ -4,12 +4,13 @@ pub use slice::{ParallelSlice, ParallelSliceMut};
 mod task;
 pub use task::Task;
 
+mod task_pool_common;
+pub use task_pool_common::ThreadPanicPolicy;
+
 #[cfg(not(target_arch = "wasm32"))]
 mod task_pool;
 #[cfg(not(target_arch = "wasm32"))]
-pub use task_pool::{
-    handle_task_pool_panicking_threads, Scope, TaskPool, TaskPoolBuilder, ThreadPanicPolicy,
-};
+pub use task_pool::{handle_task_pool_panicking_threads, Scope, TaskPool, TaskPoolBuilder};
 
 #[cfg(target_arch = "wasm32")]
 mod single_threaded_task_pool;
diff --git a/crates/bevy_tasks/src/single_threaded_task_pool.rs b/crates/bevy_tasks/src/single_threaded_task_pool.rs
index 8f248e1005c38..bd4708eb72775 100644
--- a/crates/bevy_tasks/src/single_threaded_task_pool.rs
+++ b/crates/bevy_tasks/src/single_threaded_task_pool.rs
@@ -3,6 +3,7 @@ use std::{
     mem,
     sync::{Arc, Mutex},
 };
+use crate::ThreadPanicPolicy;
 
 /// Used to create a TaskPool
 #[derive(Debug, Default, Clone)]
@@ -26,6 +27,10 @@ impl TaskPoolBuilder {
         self
     }
 
+    pub fn panic_policy(self, _policy: ThreadPanicPolicy) -> Self {
+        self
+    }
+
     pub fn build(self) -> TaskPool {
         TaskPool::new_internal()
     }
diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index 5cd2f24838fe8..1515163c86407 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -1,3 +1,4 @@
+use crate::{Task, ThreadPanicPolicy};
 use futures_lite::{future, pin};
 use parking_lot::RwLock;
 use std::{
@@ -12,19 +13,6 @@ use std::{
 };
 use tracing::warn;
 
-use crate::Task;
-
-/// The policy used when a [`TaskPool`]'s thread panics
-#[derive(Copy, Clone, Debug)]
-pub enum ThreadPanicPolicy {
-    /// Propagate the panic to the main thread, causing the main
-    /// thread to panic as well.
-    Propagate,
-    /// Restart the thread by joining the panicked thread and
-    /// spawning another one in it's place.
-    Restart,
-}
-
 /// Used to create a TaskPool
 #[derive(Debug, Default, Clone)]
 pub struct TaskPoolBuilder {
diff --git a/crates/bevy_tasks/src/task_pool_common.rs b/crates/bevy_tasks/src/task_pool_common.rs
new file mode 100644
index 0000000000000..0fc819c6a666e
--- /dev/null
+++ b/crates/bevy_tasks/src/task_pool_common.rs
@@ -0,0 +1,10 @@
+/// The policy used when a task pool's internal thread panics
+#[derive(Copy, Clone, Debug)]
+pub enum ThreadPanicPolicy {
+    /// Propagate the panic to the main thread, causing the main
+    /// thread to panic as well.
+    Propagate,
+    /// Restart the thread by joining the panicked thread and
+    /// spawning another one in it's place.
+    Restart,
+}

From 036b32101f2a39ec53af21d78b5dea1658553763 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 13:26:22 -0600
Subject: [PATCH 04/17] rename panic policy

---
 crates/bevy_core/src/task_pool_options.rs        | 12 ++++++------
 crates/bevy_tasks/src/lib.rs                     |  2 +-
 .../bevy_tasks/src/single_threaded_task_pool.rs  |  4 ++--
 crates/bevy_tasks/src/task_pool.rs               | 16 ++++++++--------
 crates/bevy_tasks/src/task_pool_common.rs        |  2 +-
 5 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_core/src/task_pool_options.rs b/crates/bevy_core/src/task_pool_options.rs
index 19f6a6ea928cd..fa1717d6b6de4 100644
--- a/crates/bevy_core/src/task_pool_options.rs
+++ b/crates/bevy_core/src/task_pool_options.rs
@@ -1,7 +1,7 @@
 use bevy_ecs::{system::Res, world::World};
 use bevy_tasks::{
-    AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolBuilder, TaskPoolTrait,
-    ThreadPanicPolicy,
+    AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolBuilder, TaskPoolThreadPanicPolicy,
+    TaskPoolTrait,
 };
 use bevy_utils::tracing::trace;
 
@@ -11,7 +11,7 @@ pub struct TaskPoolPolicies {
     /// Used to determine number of threads to allocate
     pub assignment_policy: TaskPoolThreadAssignmentPolicy,
     /// Used to determine the panic policy of the task pool
-    pub panic_policy: ThreadPanicPolicy,
+    pub panic_policy: TaskPoolThreadPanicPolicy,
 }
 
 /// Defines a simple way to determine how many threads to use given the number of remaining cores
@@ -76,7 +76,7 @@ impl Default for DefaultTaskPoolOptions {
                     max_threads: 4,
                     percent: 0.25,
                 },
-                panic_policy: ThreadPanicPolicy::Restart,
+                panic_policy: TaskPoolThreadPanicPolicy::Restart,
             },
 
             // Use 25% of cores for async compute, at least 1, no more than 4
@@ -86,7 +86,7 @@ impl Default for DefaultTaskPoolOptions {
                     max_threads: 4,
                     percent: 0.25,
                 },
-                panic_policy: ThreadPanicPolicy::Restart,
+                panic_policy: TaskPoolThreadPanicPolicy::Restart,
             },
 
             // Use all remaining cores for compute (at least 1)
@@ -96,7 +96,7 @@ impl Default for DefaultTaskPoolOptions {
                     max_threads: std::usize::MAX,
                     percent: 1.0, // This 1.0 here means "whatever is left over"
                 },
-                panic_policy: ThreadPanicPolicy::Restart,
+                panic_policy: TaskPoolThreadPanicPolicy::Restart,
             },
         }
     }
diff --git a/crates/bevy_tasks/src/lib.rs b/crates/bevy_tasks/src/lib.rs
index 6b159c0ec13a9..7439ef9baeaaa 100644
--- a/crates/bevy_tasks/src/lib.rs
+++ b/crates/bevy_tasks/src/lib.rs
@@ -5,7 +5,7 @@ mod task;
 pub use task::Task;
 
 mod task_pool_common;
-pub use task_pool_common::ThreadPanicPolicy;
+pub use task_pool_common::TaskPoolThreadPanicPolicy;
 
 #[cfg(not(target_arch = "wasm32"))]
 mod task_pool;
diff --git a/crates/bevy_tasks/src/single_threaded_task_pool.rs b/crates/bevy_tasks/src/single_threaded_task_pool.rs
index bd4708eb72775..6193313aa0ad0 100644
--- a/crates/bevy_tasks/src/single_threaded_task_pool.rs
+++ b/crates/bevy_tasks/src/single_threaded_task_pool.rs
@@ -3,7 +3,7 @@ use std::{
     mem,
     sync::{Arc, Mutex},
 };
-use crate::ThreadPanicPolicy;
+use crate::TaskPoolThreadPanicPolicy;
 
 /// Used to create a TaskPool
 #[derive(Debug, Default, Clone)]
@@ -27,7 +27,7 @@ impl TaskPoolBuilder {
         self
     }
 
-    pub fn panic_policy(self, _policy: ThreadPanicPolicy) -> Self {
+    pub fn panic_policy(self, _policy: TaskPoolThreadPanicPolicy) -> Self {
         self
     }
 
diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index 1515163c86407..5f5d96a49f955 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -1,4 +1,4 @@
-use crate::{Task, ThreadPanicPolicy};
+use crate::{Task, TaskPoolThreadPanicPolicy};
 use futures_lite::{future, pin};
 use parking_lot::RwLock;
 use std::{
@@ -25,7 +25,7 @@ pub struct TaskPoolBuilder {
     /// be named <thread_name> (<thread_index>), i.e. "MyThreadPool (2)"
     thread_name: Option<String>,
     /// Allows customizing the policy for when a [`TaskPool`]'s thread(s) panic.
-    panic_policy: Option<ThreadPanicPolicy>,
+    panic_policy: Option<TaskPoolThreadPanicPolicy>,
 }
 
 impl TaskPoolBuilder {
@@ -54,7 +54,7 @@ impl TaskPoolBuilder {
         self
     }
 
-    pub fn panic_policy(mut self, policy: ThreadPanicPolicy) -> Self {
+    pub fn panic_policy(mut self, policy: TaskPoolThreadPanicPolicy) -> Self {
         self.panic_policy = Some(policy);
         self
     }
@@ -133,7 +133,7 @@ pub struct TaskPool {
     inner: Arc<RwLock<TaskPoolInner>>,
 
     /// Panic policy of the inner thread pool.
-    panic_policy: ThreadPanicPolicy,
+    panic_policy: TaskPoolThreadPanicPolicy,
 
     /// Receiving channel used when an inner thread panics and
     /// another one is spawned in its place.
@@ -160,7 +160,7 @@ impl TaskPool {
 
     pub(crate) fn handle_panicking_threads(&self) {
         match self.panic_policy {
-            ThreadPanicPolicy::Propagate => {
+            TaskPoolThreadPanicPolicy::Propagate => {
                 if self.any_panicking_threads() {
                     for state in self.inner.write().threads.drain(..) {
                         let thread = state.thread().clone();
@@ -173,7 +173,7 @@ impl TaskPool {
                     }
                 }
             }
-            ThreadPanicPolicy::Restart => {
+            TaskPoolThreadPanicPolicy::Restart => {
                 if self.any_panicking_threads() {
                     for (idx, state) in self
                         .inner
@@ -245,7 +245,7 @@ impl TaskPool {
         num_threads: Option<usize>,
         stack_size: Option<usize>,
         thread_name: Option<&str>,
-        panic_policy: Option<ThreadPanicPolicy>,
+        panic_policy: Option<TaskPoolThreadPanicPolicy>,
     ) -> Self {
         let (shutdown_tx, shutdown_rx) = async_channel::unbounded::<()>();
 
@@ -270,7 +270,7 @@ impl TaskPool {
             })
             .collect();
 
-        let panic_policy = panic_policy.unwrap_or(ThreadPanicPolicy::Restart);
+        let panic_policy = panic_policy.unwrap_or(TaskPoolThreadPanicPolicy::Restart);
 
         Self {
             executor,
diff --git a/crates/bevy_tasks/src/task_pool_common.rs b/crates/bevy_tasks/src/task_pool_common.rs
index 0fc819c6a666e..d8f65902448e7 100644
--- a/crates/bevy_tasks/src/task_pool_common.rs
+++ b/crates/bevy_tasks/src/task_pool_common.rs
@@ -1,6 +1,6 @@
 /// The policy used when a task pool's internal thread panics
 #[derive(Copy, Clone, Debug)]
-pub enum ThreadPanicPolicy {
+pub enum TaskPoolThreadPanicPolicy {
     /// Propagate the panic to the main thread, causing the main
     /// thread to panic as well.
     Propagate,

From 8ee3ec06d8744d3abb24daaad3a56182da298398 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 13:31:00 -0600
Subject: [PATCH 05/17] move conditional check outside of match

---
 crates/bevy_tasks/src/task_pool.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index 5f5d96a49f955..5f24a85d05cda 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -159,9 +159,9 @@ impl TaskPool {
     }
 
     pub(crate) fn handle_panicking_threads(&self) {
-        match self.panic_policy {
-            TaskPoolThreadPanicPolicy::Propagate => {
-                if self.any_panicking_threads() {
+        if self.any_panicking_threads() {
+            match self.panic_policy {
+                TaskPoolThreadPanicPolicy::Propagate => {
                     for state in self.inner.write().threads.drain(..) {
                         let thread = state.thread().clone();
                         if let Err(err) = state.handle.join() {
@@ -172,9 +172,7 @@ impl TaskPool {
                         }
                     }
                 }
-            }
-            TaskPoolThreadPanicPolicy::Restart => {
-                if self.any_panicking_threads() {
+                TaskPoolThreadPanicPolicy::Restart => {
                     for (idx, state) in self
                         .inner
                         .write()

From 8f74d1017275cca20c51ab0f8e4150c84adc69e2 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 13:37:14 -0600
Subject: [PATCH 06/17] format errors

---
 crates/bevy_tasks/src/single_threaded_task_pool.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_tasks/src/single_threaded_task_pool.rs b/crates/bevy_tasks/src/single_threaded_task_pool.rs
index 6193313aa0ad0..f76cd87d909de 100644
--- a/crates/bevy_tasks/src/single_threaded_task_pool.rs
+++ b/crates/bevy_tasks/src/single_threaded_task_pool.rs
@@ -1,9 +1,9 @@
+use crate::TaskPoolThreadPanicPolicy;
 use std::{
     future::Future,
     mem,
     sync::{Arc, Mutex},
 };
-use crate::TaskPoolThreadPanicPolicy;
 
 /// Used to create a TaskPool
 #[derive(Debug, Default, Clone)]

From fcfc0c87e9ca7b398c474c5d475c0e65902a4881 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 14:04:37 -0600
Subject: [PATCH 07/17] more wasm erros...

---
 crates/bevy_core/src/lib.rs               | 22 ++++++++++++++++------
 crates/bevy_core/src/task_pool_options.rs |  1 -
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 2576e092aae24..47bf11d7b8377 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -23,11 +23,8 @@ use bevy_ecs::{
     schedule::{ExclusiveSystemDescriptorCoercion, SystemLabel},
     system::{IntoExclusiveSystem, IntoSystem},
 };
-use bevy_tasks::{AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool};
 use bevy_utils::HashSet;
 use std::ops::Range;
-use task_pool_options::handle_task_pool_panicking_threads_system;
-
 /// Adds core functionality to Apps.
 #[derive(Default)]
 pub struct CorePlugin;
@@ -49,9 +46,22 @@ impl Plugin for CorePlugin {
             .create_default_pools(app.world_mut());
 
         #[cfg(not(target_arch = "wasm32"))]
-        app.add_system(handle_task_pool_panicking_threads_system::<IoTaskPool>.system())
-            .add_system(handle_task_pool_panicking_threads_system::<ComputeTaskPool>.system())
-            .add_system(handle_task_pool_panicking_threads_system::<AsyncComputeTaskPool>.system());
+        app.add_system(
+            task_pool_options::handle_task_pool_panicking_threads_system::<bevy_tasks::IoTaskPool>
+                .system(),
+        )
+        .add_system(
+            task_pool_options::handle_task_pool_panicking_threads_system::<
+                bevy_tasks::ComputeTaskPool,
+            >
+                .system(),
+        )
+        .add_system(
+            task_pool_options::handle_task_pool_panicking_threads_system::<
+                bevy_tasks::AsyncComputeTaskPool,
+            >
+                .system(),
+        );
 
         app.init_resource::<Time>()
             .init_resource::<EntityLabels>()
diff --git a/crates/bevy_core/src/task_pool_options.rs b/crates/bevy_core/src/task_pool_options.rs
index fa1717d6b6de4..d60e1790f7d17 100644
--- a/crates/bevy_core/src/task_pool_options.rs
+++ b/crates/bevy_core/src/task_pool_options.rs
@@ -178,7 +178,6 @@ impl DefaultTaskPoolOptions {
     }
 }
 
-#[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn handle_task_pool_panicking_threads_system<
     T: TaskPoolTrait + Send + Sync + 'static,
 >(

From 83500c55cf74b830a7afef2e97ef2f78fcef255a Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 15:04:41 -0600
Subject: [PATCH 08/17] replace newline

---
 crates/bevy_core/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 47bf11d7b8377..9c97e6bdf8b29 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -25,6 +25,7 @@ use bevy_ecs::{
 };
 use bevy_utils::HashSet;
 use std::ops::Range;
+
 /// Adds core functionality to Apps.
 #[derive(Default)]
 pub struct CorePlugin;

From 5974cac508786c321359e8ddc805f2c75438446b Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 15:07:59 -0600
Subject: [PATCH 09/17] wasm stuffffzzz

---
 crates/bevy_core/src/task_pool_options.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_core/src/task_pool_options.rs b/crates/bevy_core/src/task_pool_options.rs
index d60e1790f7d17..fbb4765534d0a 100644
--- a/crates/bevy_core/src/task_pool_options.rs
+++ b/crates/bevy_core/src/task_pool_options.rs
@@ -1,4 +1,6 @@
-use bevy_ecs::{system::Res, world::World};
+#[cfg(not(target_arch = "wasm32"))]
+use bevy_ecs::system::Res;
+use bevy_ecs::world::World;
 use bevy_tasks::{
     AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolBuilder, TaskPoolThreadPanicPolicy,
     TaskPoolTrait,
@@ -178,6 +180,7 @@ impl DefaultTaskPoolOptions {
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn handle_task_pool_panicking_threads_system<
     T: TaskPoolTrait + Send + Sync + 'static,
 >(

From b8ee81ad95d816764fbcf9bf3b80714b3f2a3ea2 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 15:21:52 -0600
Subject: [PATCH 10/17] add docs

---
 crates/bevy_core/src/task_pool_options.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_core/src/task_pool_options.rs b/crates/bevy_core/src/task_pool_options.rs
index fbb4765534d0a..777c500be1ca4 100644
--- a/crates/bevy_core/src/task_pool_options.rs
+++ b/crates/bevy_core/src/task_pool_options.rs
@@ -7,7 +7,7 @@ use bevy_tasks::{
 };
 use bevy_utils::tracing::trace;
 
-/// DOCS: todo
+/// The set of policies describing how the according task pool behaves
 #[derive(Clone, Debug)]
 pub struct TaskPoolPolicies {
     /// Used to determine number of threads to allocate

From 7e840cfa84cfa1a39b4e861963b7d876989060eb Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 16:35:03 -0600
Subject: [PATCH 11/17] use bevy_utils for tracing

---
 crates/bevy_tasks/Cargo.toml       | 2 +-
 crates/bevy_tasks/src/task_pool.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_tasks/Cargo.toml b/crates/bevy_tasks/Cargo.toml
index 7284331378d89..8e1da828d4f45 100644
--- a/crates/bevy_tasks/Cargo.toml
+++ b/crates/bevy_tasks/Cargo.toml
@@ -16,7 +16,7 @@ keywords = ["bevy"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-tracing = { version = "0.1", features = ["release_max_level_info"] }
+bevy_utils = { path = "../bevy_utils" }
 parking_lot = "0.11.0"
 futures-lite = "1.4.0"
 event-listener = "2.4.0"
diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index 5f24a85d05cda..297c98443e2e0 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -1,4 +1,5 @@
 use crate::{Task, TaskPoolThreadPanicPolicy};
+use bevy_utils::tracing::warn;
 use futures_lite::{future, pin};
 use parking_lot::RwLock;
 use std::{
@@ -11,7 +12,6 @@ use std::{
     },
     thread::{self, JoinHandle},
 };
-use tracing::warn;
 
 /// Used to create a TaskPool
 #[derive(Debug, Default, Clone)]

From f9e4ed3cfc9cc092d200757261b71303da465093 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Mon, 7 Jun 2021 16:39:25 -0600
Subject: [PATCH 12/17] rename task pool trait

---
 crates/bevy_core/src/task_pool_options.rs | 6 +++---
 crates/bevy_tasks/src/lib.rs              | 2 +-
 crates/bevy_tasks/src/usages.rs           | 5 ++---
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_core/src/task_pool_options.rs b/crates/bevy_core/src/task_pool_options.rs
index 777c500be1ca4..67d99e88c1e67 100644
--- a/crates/bevy_core/src/task_pool_options.rs
+++ b/crates/bevy_core/src/task_pool_options.rs
@@ -2,8 +2,8 @@
 use bevy_ecs::system::Res;
 use bevy_ecs::world::World;
 use bevy_tasks::{
-    AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolBuilder, TaskPoolThreadPanicPolicy,
-    TaskPoolTrait,
+    AsyncComputeTaskPool, ComputeTaskPool, DerefTaskPool, IoTaskPool, TaskPoolBuilder,
+    TaskPoolThreadPanicPolicy,
 };
 use bevy_utils::tracing::trace;
 
@@ -182,7 +182,7 @@ impl DefaultTaskPoolOptions {
 
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn handle_task_pool_panicking_threads_system<
-    T: TaskPoolTrait + Send + Sync + 'static,
+    T: DerefTaskPool + Send + Sync + 'static,
 >(
     task_pool: Res<T>,
 ) {
diff --git a/crates/bevy_tasks/src/lib.rs b/crates/bevy_tasks/src/lib.rs
index 7439ef9baeaaa..074f13e718b27 100644
--- a/crates/bevy_tasks/src/lib.rs
+++ b/crates/bevy_tasks/src/lib.rs
@@ -18,7 +18,7 @@ mod single_threaded_task_pool;
 pub use single_threaded_task_pool::{Scope, TaskPool, TaskPoolBuilder};
 
 mod usages;
-pub use usages::{AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolTrait};
+pub use usages::{AsyncComputeTaskPool, ComputeTaskPool, DerefTaskPool, IoTaskPool};
 
 mod countdown_event;
 pub use countdown_event::CountdownEvent;
diff --git a/crates/bevy_tasks/src/usages.rs b/crates/bevy_tasks/src/usages.rs
index 34c5bc4bbd704..9f33725af09ae 100644
--- a/crates/bevy_tasks/src/usages.rs
+++ b/crates/bevy_tasks/src/usages.rs
@@ -51,7 +51,6 @@ impl Deref for IoTaskPool {
     }
 }
 
-/// TODO: RENAME
-pub trait TaskPoolTrait: Deref<Target = TaskPool> {}
+pub trait DerefTaskPool: Deref<Target = TaskPool> {}
 
-impl<T> TaskPoolTrait for T where T: Deref<Target = TaskPool> {}
+impl<T> DerefTaskPool for T where T: Deref<Target = TaskPool> {}

From 534cda4629c100b37ff701493fdf6bb8f8424013 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Tue, 8 Jun 2021 16:20:56 -0600
Subject: [PATCH 13/17] specify bevy_utils version

---
 crates/bevy_tasks/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_tasks/Cargo.toml b/crates/bevy_tasks/Cargo.toml
index 8e1da828d4f45..a36d81becfd3c 100644
--- a/crates/bevy_tasks/Cargo.toml
+++ b/crates/bevy_tasks/Cargo.toml
@@ -16,7 +16,7 @@ keywords = ["bevy"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy_utils = { path = "../bevy_utils" }
+bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 parking_lot = "0.11.0"
 futures-lite = "1.4.0"
 event-listener = "2.4.0"

From 57565f3e3e64499e29f62f50e021fdabbc93ec96 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Tue, 8 Jun 2021 16:46:33 -0600
Subject: [PATCH 14/17] add testing

---
 crates/bevy_tasks/src/task_pool.rs | 54 ++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index 297c98443e2e0..fb0b2b584f03f 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -525,4 +525,58 @@ mod tests {
         assert!(!thread_check_failed.load(Ordering::Acquire));
         assert_eq!(count.load(Ordering::Acquire), 200);
     }
+
+    #[test]
+    fn test_restart_panic_policy() {
+        std::panic::set_hook(Box::new(|_| {}));
+
+        let pool = Arc::new(
+            TaskPoolBuilder::new()
+                .panic_policy(TaskPoolThreadPanicPolicy::Restart)
+                .num_threads(1)
+                .build(),
+        );
+
+        pool.spawn(async {
+            panic!("oh no!");
+        })
+        .detach();
+
+        while !pool.any_panicking_threads() {}
+        pool.handle_panicking_threads();
+
+        assert!(!pool.any_panicking_threads());
+
+        // even though the first thread panicked, `handle_panicking_threads` replaced it with
+        // a new thread. Allowing `spawn` to work again.
+        let success = Arc::new(AtomicBool::new(false));
+        let success_clone = success.clone();
+        pool.spawn(async move {
+            success_clone.store(true, Ordering::Release);
+        })
+        .detach();
+
+        while !success.load(Ordering::Acquire) {}
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_propagate_panic_policy() {
+        std::panic::set_hook(Box::new(|_| {}));
+
+        let pool = Arc::new(
+            TaskPoolBuilder::new()
+                .panic_policy(TaskPoolThreadPanicPolicy::Propagate)
+                .num_threads(1)
+                .build(),
+        );
+
+        pool.spawn(async {
+            panic!("");
+        })
+        .detach();
+
+        while !pool.any_panicking_threads() {}
+        pool.handle_panicking_threads();
+    }
 }

From 3358af80410be6c92adbe68fcfd08d80fa583134 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Tue, 8 Jun 2021 16:59:32 -0600
Subject: [PATCH 15/17] use unwind_resume in propagate path. Update testing

---
 crates/bevy_tasks/src/task_pool.rs | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index fb0b2b584f03f..0979338058a6f 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -1,5 +1,5 @@
 use crate::{Task, TaskPoolThreadPanicPolicy};
-use bevy_utils::tracing::warn;
+use bevy_utils::tracing::{error, warn};
 use futures_lite::{future, pin};
 use parking_lot::RwLock;
 use std::{
@@ -165,10 +165,8 @@ impl TaskPool {
                     for state in self.inner.write().threads.drain(..) {
                         let thread = state.thread().clone();
                         if let Err(err) = state.handle.join() {
-                            panic!(
-                                "TaskPool's inner thread '{:?}' panicked with error: {:?}",
-                                thread, err
-                            );
+                            error!("TaskPool's inner thread '{:?}' panicked!", thread);
+                            std::panic::resume_unwind(err);
                         }
                     }
                 }
@@ -543,12 +541,10 @@ mod tests {
         .detach();
 
         while !pool.any_panicking_threads() {}
-        pool.handle_panicking_threads();
-
-        assert!(!pool.any_panicking_threads());
 
-        // even though the first thread panicked, `handle_panicking_threads` replaced it with
-        // a new thread. Allowing `spawn` to work again.
+        // even though the first thread panicked, we can still queue up a task
+        // as the next call to `handle_panicking_threads` will replace the panicked
+        // thread with a new once.
         let success = Arc::new(AtomicBool::new(false));
         let success_clone = success.clone();
         pool.spawn(async move {
@@ -556,11 +552,14 @@ mod tests {
         })
         .detach();
 
+        pool.handle_panicking_threads();
+        assert!(!pool.any_panicking_threads());
+
         while !success.load(Ordering::Acquire) {}
     }
 
     #[test]
-    #[should_panic]
+    #[should_panic = "bevy"]
     fn test_propagate_panic_policy() {
         std::panic::set_hook(Box::new(|_| {}));
 
@@ -572,7 +571,7 @@ mod tests {
         );
 
         pool.spawn(async {
-            panic!("");
+            panic!("bevy");
         })
         .detach();
 

From 53753dd766941c58c5b85257d20a1e04a0a3df69 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Tue, 8 Jun 2021 17:02:38 -0600
Subject: [PATCH 16/17] moving restart warning to use old_state's threa name

---
 crates/bevy_tasks/src/task_pool.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index 0979338058a6f..f5cb40723c498 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -194,14 +194,13 @@ impl TaskPool {
                             ),
                         );
 
-                        // join the panicked thread handle
-                        let panic_error = old_state.handle.join().unwrap_err();
-
                         warn!(
-                            "TaskPool's inner thread '{:?}' panicked with error: {:?}",
-                            state.thread(),
-                            panic_error
+                            "TaskPool's inner thread '{:?}' panicked!",
+                            old_state.thread()
                         );
+
+                        // join the panicked thread handle
+                        old_state.handle.join().unwrap_err();
                     }
                 }
             }

From 4e8d5a1e483d1ad85e023a55b85d80f29a887e28 Mon Sep 17 00:00:00 2001
From: NathanW <nathansward@comcast.net>
Date: Tue, 8 Jun 2021 17:05:02 -0600
Subject: [PATCH 17/17] fix enumeration to match thread's index

---
 crates/bevy_tasks/src/task_pool.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index f5cb40723c498..9b83a6a4dbe87 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -176,8 +176,8 @@ impl TaskPool {
                         .write()
                         .threads
                         .iter_mut()
-                        .filter(|state| state.panicking())
                         .enumerate()
+                        .filter(|(_, state)| state.panicking())
                     {
                         let thread_name = match state.thread().name() {
                             Some(name) => name.to_owned(),