Remove parking_lot dependency (#20630)

# Objective
Spend less time compiling what is already in the standard library.
Remove `parking_lot` from first party crate dependencies. Contribute to
#18978. Supercedes #18996.

## Solution
Use `bevy_platform::sync` types wherever possible.
`BevyManifest::shared` directly returned a mapped guard, but that could
be circumvented by just using a scope-like API instead.

The crate is still in the dependency tree, transitively, through `wgpu`,
but is now no longer required for any non-rendering crates.

## Testing
Ran tests locally.

Co-Authored-By: Zac Harrold <[email protected]>

Author: james7132

crates/bevy_animation/macros/src/animation_event.rs

@@ -5,9 +5,11 @@ use syn::{parse_macro_input, DeriveInput};
 
 pub fn derive_animation_event(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
-    let manifest = BevyManifest::shared();
-    let bevy_ecs = manifest.get_path("bevy_ecs");
-    let bevy_animation = manifest.get_path("bevy_animation");
+    let (bevy_ecs, bevy_animation) = BevyManifest::shared(|manifest| {
+        let bevy_ecs = manifest.get_path("bevy_ecs");
+        let bevy_animation = manifest.get_path("bevy_animation");
+        (bevy_ecs, bevy_animation)
+    });
 
     let generics = ast.generics;
     let (impl_generics, type_generics, where_clause) = generics.split_for_impl();

crates/bevy_asset/Cargo.toml

@@ -53,10 +53,6 @@ either = { version = "1.13", default-features = false }
 futures-io = { version = "0.3", default-features = false }
 futures-lite = { version = "2.0.1", default-features = false }
 blake3 = { version = "1.5", default-features = false }
-parking_lot = { version = "0.12", default-features = false, features = [
-  "arc_lock",
-  "send_guard",
-] }
 ron = { version = "0.10", default-features = false }
 serde = { version = "1", default-features = false, features = ["derive"] }
 thiserror = { version = "2", default-features = false }

crates/bevy_asset/macros/src/lib.rs

@@ -8,7 +8,7 @@ use quote::{format_ident, quote};
 use syn::{parse_macro_input, Data, DeriveInput, Path};
 
 pub(crate) fn bevy_asset_path() -> Path {
-    BevyManifest::shared().get_path("bevy_asset")
+    BevyManifest::shared(|manifest| manifest.get_path("bevy_asset"))
 }
 
 const DEPENDENCY_ATTRIBUTE: &str = "dependency";

crates/bevy_asset/src/assets.rs

@@ -572,7 +572,7 @@ impl<A: Asset> Assets<A> {
         // that `asset_server.load` calls that occur during it block, which ensures that
         // re-loads are kicked off appropriately. This function must be "transactional" relative
         // to other asset info operations
-        let mut infos = asset_server.data.infos.write();
+        let mut infos = asset_server.write_infos();
         while let Ok(drop_event) = assets.handle_provider.drop_receiver.try_recv() {
             let id = drop_event.id.typed();
 

crates/bevy_asset/src/io/embedded/embedded_watcher.rs

@@ -5,9 +5,9 @@ use crate::io::{
 };
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
 use bevy_platform::collections::HashMap;
+use bevy_platform::sync::{PoisonError, RwLock};
 use core::time::Duration;
 use notify_debouncer_full::{notify::RecommendedWatcher, Debouncer, RecommendedCache};
-use parking_lot::RwLock;
 use std::{
     fs::File,
     io::{BufReader, Read},
@@ -64,7 +64,12 @@ impl FilesystemEventHandler for EmbeddedEventHandler {
 
     fn get_path(&self, absolute_path: &Path) -> Option<(PathBuf, bool)> {
         let (local_path, is_meta) = get_asset_path(&self.root, absolute_path);
-        let final_path = self.root_paths.read().get(local_path.as_path())?.clone();
+        let final_path = self
+            .root_paths
+            .read()
+            .unwrap_or_else(PoisonError::into_inner)
+            .get(local_path.as_path())?
+            .clone();
         if is_meta {
             warn!("Meta file asset hot-reloading is not supported yet: {final_path:?}");
         }

crates/bevy_asset/src/io/embedded/mod.rs

@@ -12,6 +12,8 @@ use crate::AssetServer;
 use alloc::boxed::Box;
 use bevy_app::App;
 use bevy_ecs::{resource::Resource, world::World};
+#[cfg(feature = "embedded_watcher")]
+use bevy_platform::sync::{Arc, PoisonError, RwLock};
 use std::path::{Path, PathBuf};
 
 #[cfg(feature = "embedded_watcher")]
@@ -30,9 +32,7 @@ pub const EMBEDDED: &str = "embedded";
 pub struct EmbeddedAssetRegistry {
     dir: Dir,
     #[cfg(feature = "embedded_watcher")]
-    root_paths: alloc::sync::Arc<
-        parking_lot::RwLock<bevy_platform::collections::HashMap<Box<Path>, PathBuf>>,
-    >,
+    root_paths: Arc<RwLock<bevy_platform::collections::HashMap<Box<Path>, PathBuf>>>,
 }
 
 impl EmbeddedAssetRegistry {
@@ -51,6 +51,7 @@ impl EmbeddedAssetRegistry {
         #[cfg(feature = "embedded_watcher")]
         self.root_paths
             .write()
+            .unwrap_or_else(PoisonError::into_inner)
             .insert(full_path.into(), asset_path.to_owned());
         self.dir.insert_asset(asset_path, value);
     }
@@ -70,6 +71,7 @@ impl EmbeddedAssetRegistry {
         #[cfg(feature = "embedded_watcher")]
         self.root_paths
             .write()
+            .unwrap_or_else(PoisonError::into_inner)
             .insert(full_path.into(), asset_path.to_owned());
         self.dir.insert_meta(asset_path, value);
     }

crates/bevy_asset/src/io/gated.rs

@@ -1,9 +1,8 @@
 use crate::io::{AssetReader, AssetReaderError, PathStream, Reader};
 use alloc::{boxed::Box, sync::Arc};
 use async_channel::{Receiver, Sender};
-use bevy_platform::collections::HashMap;
-use parking_lot::RwLock;
-use std::path::Path;
+use bevy_platform::{collections::HashMap, sync::RwLock};
+use std::{path::Path, sync::PoisonError};
 
 /// A "gated" reader that will prevent asset reads from returning until
 /// a given path has been "opened" using [`GateOpener`].
@@ -32,7 +31,7 @@ impl GateOpener {
     /// Opens the `path` "gate", allowing a _single_ [`AssetReader`] operation to return for that path.
     /// If multiple operations are expected, call `open` the expected number of calls.
     pub fn open<P: AsRef<Path>>(&self, path: P) {
-        let mut gates = self.gates.write();
+        let mut gates = self.gates.write().unwrap_or_else(PoisonError::into_inner);
         let gates = gates
             .entry_ref(path.as_ref())
             .or_insert_with(async_channel::unbounded);
@@ -58,7 +57,7 @@ impl<R: AssetReader> GatedReader<R> {
 impl<R: AssetReader> AssetReader for GatedReader<R> {
     async fn read<'a>(&'a self, path: &'a Path) -> Result<impl Reader + 'a, AssetReaderError> {
         let receiver = {
-            let mut gates = self.gates.write();
+            let mut gates = self.gates.write().unwrap_or_else(PoisonError::into_inner);
             let gates = gates
                 .entry_ref(path.as_ref())
                 .or_insert_with(async_channel::unbounded);

crates/bevy_asset/src/io/memory.rs

@@ -1,10 +1,12 @@
 use crate::io::{AssetReader, AssetReaderError, PathStream, Reader};
 use alloc::{borrow::ToOwned, boxed::Box, sync::Arc, vec::Vec};
-use bevy_platform::collections::HashMap;
+use bevy_platform::{
+    collections::HashMap,
+    sync::{PoisonError, RwLock},
+};
 use core::{pin::Pin, task::Poll};
 use futures_io::AsyncRead;
 use futures_lite::{ready, Stream};
-use parking_lot::RwLock;
 use std::path::{Path, PathBuf};
 
 use super::AsyncSeekForward;
@@ -44,13 +46,17 @@ impl Dir {
         if let Some(parent) = path.parent() {
             dir = self.get_or_insert_dir(parent);
         }
-        dir.0.write().assets.insert(
-            path.file_name().unwrap().to_string_lossy().into(),
-            Data {
-                value: value.into(),
-                path: path.to_owned(),
-            },
-        );
+        dir.0
+            .write()
+            .unwrap_or_else(PoisonError::into_inner)
+            .assets
+            .insert(
+                path.file_name().unwrap().to_string_lossy().into(),
+                Data {
+                    value: value.into(),
+                    path: path.to_owned(),
+                },
+            );
     }
 
     /// Removes the stored asset at `path` and returns the `Data` stored if found and otherwise `None`.
@@ -60,21 +66,29 @@ impl Dir {
             dir = self.get_or_insert_dir(parent);
         }
         let key: Box<str> = path.file_name().unwrap().to_string_lossy().into();
-        dir.0.write().assets.remove(&key)
+        dir.0
+            .write()
+            .unwrap_or_else(PoisonError::into_inner)
+            .assets
+            .remove(&key)
     }
 
     pub fn insert_meta(&self, path: &Path, value: impl Into<Value>) {
         let mut dir = self.clone();
         if let Some(parent) = path.parent() {
             dir = self.get_or_insert_dir(parent);
         }
-        dir.0.write().metadata.insert(
-            path.file_name().unwrap().to_string_lossy().into(),
-            Data {
-                value: value.into(),
-                path: path.to_owned(),
-            },
-        );
+        dir.0
+            .write()
+            .unwrap_or_else(PoisonError::into_inner)
+            .metadata
+            .insert(
+                path.file_name().unwrap().to_string_lossy().into(),
+                Data {
+                    value: value.into(),
+                    path: path.to_owned(),
+                },
+            );
     }
 
     pub fn get_or_insert_dir(&self, path: &Path) -> Dir {
@@ -84,7 +98,7 @@ impl Dir {
             full_path.push(c);
             let name = c.as_os_str().to_string_lossy().into();
             dir = {
-                let dirs = &mut dir.0.write().dirs;
+                let dirs = &mut dir.0.write().unwrap_or_else(PoisonError::into_inner).dirs;
                 dirs.entry(name)
                     .or_insert_with(|| Dir::new(full_path.clone()))
                     .clone()
@@ -98,7 +112,13 @@ impl Dir {
         let mut dir = self.clone();
         for p in path.components() {
             let component = p.as_os_str().to_str().unwrap();
-            let next_dir = dir.0.read().dirs.get(component)?.clone();
+            let next_dir = dir
+                .0
+                .read()
+                .unwrap_or_else(PoisonError::into_inner)
+                .dirs
+                .get(component)?
+                .clone();
             dir = next_dir;
         }
         Some(dir)
@@ -110,8 +130,14 @@ impl Dir {
             dir = dir.get_dir(parent)?;
         }
 
-        path.file_name()
-            .and_then(|f| dir.0.read().assets.get(f.to_str().unwrap()).cloned())
+        path.file_name().and_then(|f| {
+            dir.0
+                .read()
+                .unwrap_or_else(PoisonError::into_inner)
+                .assets
+                .get(f.to_str().unwrap())
+                .cloned()
+        })
     }
 
     pub fn get_metadata(&self, path: &Path) -> Option<Data> {
@@ -120,12 +146,22 @@ impl Dir {
             dir = dir.get_dir(parent)?;
         }
 
-        path.file_name()
-            .and_then(|f| dir.0.read().metadata.get(f.to_str().unwrap()).cloned())
+        path.file_name().and_then(|f| {
+            dir.0
+                .read()
+                .unwrap_or_else(PoisonError::into_inner)
+                .metadata
+                .get(f.to_str().unwrap())
+                .cloned()
+        })
     }
 
     pub fn path(&self) -> PathBuf {
-        self.0.read().path.to_owned()
+        self.0
+            .read()
+            .unwrap_or_else(PoisonError::into_inner)
+            .path
+            .to_owned()
     }
 }
 
@@ -153,7 +189,7 @@ impl Stream for DirStream {
         _cx: &mut core::task::Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         let this = self.get_mut();
-        let dir = this.dir.0.read();
+        let dir = this.dir.0.read().unwrap_or_else(PoisonError::into_inner);
 
         let dir_index = this.dir_index;
         if let Some(dir_path) = dir

crates/bevy_asset/src/lib.rs

@@ -728,7 +728,10 @@ mod tests {
         prelude::*,
         schedule::{LogLevel, ScheduleBuildSettings},
     };
-    use bevy_platform::collections::{HashMap, HashSet};
+    use bevy_platform::{
+        collections::{HashMap, HashSet},
+        sync::Mutex,
+    };
     use bevy_reflect::TypePath;
     use core::time::Duration;
     use crossbeam_channel::Sender;
@@ -825,7 +828,7 @@ mod tests {
     /// A dummy [`CoolText`] asset reader that only succeeds after `failure_count` times it's read from for each asset.
     #[derive(Default, Clone)]
     pub struct UnstableMemoryAssetReader {
-        pub attempt_counters: Arc<std::sync::Mutex<HashMap<Box<Path>, usize>>>,
+        pub attempt_counters: Arc<Mutex<HashMap<Box<Path>, usize>>>,
         pub load_delay: Duration,
         memory_reader: MemoryAssetReader,
         failure_count: usize,

crates/bevy_asset/src/processor/mod.rs

@@ -58,11 +58,13 @@ use crate::{
 };
 use alloc::{borrow::ToOwned, boxed::Box, collections::VecDeque, sync::Arc, vec, vec::Vec};
 use bevy_ecs::prelude::*;
-use bevy_platform::collections::{HashMap, HashSet};
+use bevy_platform::{
+    collections::{HashMap, HashSet},
+    sync::{PoisonError, RwLock},
+};
 use bevy_tasks::IoTaskPool;
 use futures_io::ErrorKind;
 use futures_lite::{AsyncReadExt, AsyncWriteExt, StreamExt};
-use parking_lot::RwLock;
 use std::path::{Path, PathBuf};
 use thiserror::Error;
 use tracing::{debug, error, trace, warn};
@@ -533,7 +535,7 @@ impl AssetProcessor {
     async fn finish_processing_assets(&self) {
         self.try_reprocessing_queued().await;
         // clean up metadata in asset server
-        self.server.data.infos.write().consume_handle_drop_events();
+        self.server.write_infos().consume_handle_drop_events();
         self.set_state(ProcessorState::Finished).await;
     }
 
@@ -581,28 +583,49 @@ impl AssetProcessor {
 
     /// Register a new asset processor.
     pub fn register_processor<P: Process>(&self, processor: P) {
-        let mut process_plans = self.data.processors.write();
+        let mut process_plans = self
+            .data
+            .processors
+            .write()
+            .unwrap_or_else(PoisonError::into_inner);
         #[cfg(feature = "trace")]
         let processor = InstrumentedAssetProcessor(processor);
         process_plans.insert(core::any::type_name::<P>(), Arc::new(processor));
     }
 
     /// Set the default processor for the given `extension`. Make sure `P` is registered with [`AssetProcessor::register_processor`].
     pub fn set_default_processor<P: Process>(&self, extension: &str) {
-        let mut default_processors = self.data.default_processors.write();
+        let mut default_processors = self
+            .data
+            .default_processors
+            .write()
+            .unwrap_or_else(PoisonError::into_inner);
         default_processors.insert(extension.into(), core::any::type_name::<P>());
     }
 
     /// Returns the default processor for the given `extension`, if it exists.
     pub fn get_default_processor(&self, extension: &str) -> Option<Arc<dyn ErasedProcessor>> {
-        let default_processors = self.data.default_processors.read();
+        let default_processors = self
+            .data
+            .default_processors
+            .read()
+            .unwrap_or_else(PoisonError::into_inner);
         let key = default_processors.get(extension)?;
-        self.data.processors.read().get(key).cloned()
+        self.data
+            .processors
+            .read()
+            .unwrap_or_else(PoisonError::into_inner)
+            .get(key)
+            .cloned()
     }
 
     /// Returns the processor with the given `processor_type_name`, if it exists.
     pub fn get_processor(&self, processor_type_name: &str) -> Option<Arc<dyn ErasedProcessor>> {
-        let processors = self.data.processors.read();
+        let processors = self
+            .data
+            .processors
+            .read()
+            .unwrap_or_else(PoisonError::into_inner);
         processors.get(processor_type_name).cloned()
     }