use hashbrown for bevy hashmaps / hashsets

Author: cart

crates/bevy_asset/src/asset_server.rs

@@ -8,10 +8,10 @@ use anyhow::Result;
 use bevy_ecs::system::{Res, ResMut};
 use bevy_log::warn;
 use bevy_tasks::TaskPool;
-use bevy_utils::{HashMap, Uuid};
+use bevy_utils::{Entry, HashMap, Uuid};
 use crossbeam_channel::TryRecvError;
 use parking_lot::{Mutex, RwLock};
-use std::{collections::hash_map::Entry, path::Path, sync::Arc};
+use std::{path::Path, sync::Arc};
 use thiserror::Error;
 
 /// Errors that occur while loading assets with an `AssetServer`

crates/bevy_ecs/src/entity/map_entities.rs

@@ -1,6 +1,5 @@
 use crate::entity::Entity;
-use bevy_utils::HashMap;
-use std::collections::hash_map::Entry;
+use bevy_utils::{Entry, HashMap};
 use thiserror::Error;
 
 #[derive(Error, Debug)]

crates/bevy_input/src/input.rs

@@ -29,13 +29,13 @@ use bevy_ecs::schedule::State;
 /// * Call the [`Input::release`] method for each release event.
 /// * Call the [`Input::clear`] method at each frame start, before processing events.
 #[derive(Debug, Clone)]
-pub struct Input<T> {
+pub struct Input<T: Eq + Hash> {
     pressed: HashSet<T>,
     just_pressed: HashSet<T>,
     just_released: HashSet<T>,
 }
 
-impl<T> Default for Input<T> {
+impl<T: Eq + Hash> Default for Input<T> {
     fn default() -> Self {
         Self {
             pressed: Default::default(),

crates/bevy_reflect/Cargo.toml

@@ -25,6 +25,7 @@ thiserror = "1.0"
 serde = "1"
 smallvec = { version = "1.6", features = ["serde", "union", "const_generics"], optional = true }
 glam = { version = "0.20.0", features = ["serde"], optional = true }
+hashbrown = { version = "0.11", features = ["serde"], optional = true }
 
 [dev-dependencies]
 ron = "0.7.0"

crates/bevy_reflect/src/impls/std.rs

@@ -6,7 +6,7 @@ use crate::{
 };
 
 use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value};
-use bevy_utils::{AHashExt, Duration, HashMap, HashSet};
+use bevy_utils::{Duration, HashMap, HashSet};
 use serde::{Deserialize, Serialize};
 use std::{
     any::Any,

crates/bevy_reflect/src/map.rs

@@ -1,6 +1,6 @@
-use std::{any::Any, collections::hash_map::Entry};
+use std::any::Any;
 
-use bevy_utils::HashMap;
+use bevy_utils::{Entry, HashMap};
 
 use crate::{serde::Serializable, Reflect, ReflectMut, ReflectRef};
 

crates/bevy_reflect/src/struct_trait.rs

@@ -1,6 +1,6 @@
 use crate::{serde::Serializable, Reflect, ReflectMut, ReflectRef};
-use bevy_utils::HashMap;
-use std::{any::Any, borrow::Cow, collections::hash_map::Entry};
+use bevy_utils::{Entry, HashMap};
+use std::{any::Any, borrow::Cow};
 
 /// A reflected Rust regular struct type.
 ///

crates/bevy_render/src/render_resource/pipeline_cache.rs

@@ -10,8 +10,8 @@ use crate::{
 use bevy_app::EventReader;
 use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_ecs::system::{Res, ResMut};
-use bevy_utils::{tracing::error, HashMap, HashSet};
-use std::{collections::hash_map::Entry, hash::Hash, ops::Deref, sync::Arc};
+use bevy_utils::{tracing::error, Entry, HashMap, HashSet};
+use std::{hash::Hash, ops::Deref, sync::Arc};
 use thiserror::Error;
 use wgpu::{PipelineLayoutDescriptor, ShaderModule, VertexBufferLayout as RawVertexBufferLayout};
 

crates/bevy_render/src/texture/texture_cache.rs

@@ -3,7 +3,7 @@ use crate::{
     renderer::RenderDevice,
 };
 use bevy_ecs::prelude::ResMut;
-use bevy_utils::HashMap;
+use bevy_utils::{Entry, HashMap};
 use wgpu::{TextureDescriptor, TextureViewDescriptor};
 
 /// The internal representation of a [`CachedTexture`] used to track whether it was recently used
@@ -39,7 +39,7 @@ impl TextureCache {
         descriptor: TextureDescriptor<'static>,
     ) -> CachedTexture {
         match self.textures.entry(descriptor) {
-            std::collections::hash_map::Entry::Occupied(mut entry) => {
+            Entry::Occupied(mut entry) => {
                 for texture in entry.get_mut().iter_mut() {
                     if !texture.taken {
                         texture.frames_since_last_use = 0;
@@ -64,7 +64,7 @@ impl TextureCache {
                     default_view,
                 }
             }
-            std::collections::hash_map::Entry::Vacant(entry) => {
+            Entry::Vacant(entry) => {
                 let texture = render_device.create_texture(entry.key());
                 let default_view = texture.create_view(&TextureViewDescriptor::default());
                 entry.insert(vec![CachedTextureMeta {

crates/bevy_utils/Cargo.toml

@@ -14,6 +14,7 @@ ahash = "0.7.0"
 tracing = {version = "0.1", features = ["release_max_level_info"]}
 instant = { version = "0.1", features = ["wasm-bindgen"] }
 uuid = { version = "0.8", features = ["v4", "serde"] }
+hashbrown = { version = "0.11", features = ["serde"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = {version = "0.2.0", features = ["js"]}

crates/bevy_utils/src/lib.rs

@@ -3,6 +3,7 @@ pub mod label;
 
 pub use ahash::AHasher;
 pub use enum_variant_meta::*;
+pub type Entry<'a, K, V> = hashbrown::hash_map::Entry<'a, K, V, RandomState>;
 pub use instant::{Duration, Instant};
 pub use tracing;
 pub use uuid::Uuid;
@@ -32,7 +33,7 @@ impl std::hash::BuildHasher for FixedState {
     }
 }
 
-/// A [`HashMap`][std::collections::HashMap] implementing [`aHash`], a high
+/// A [`HashMap`][hashbrown::HashMap] implementing [`aHash`], a high
 /// speed keyed hashing algorithm intended for use in in-memory hashmaps.
 ///
 /// `aHash` is designed for performance and is NOT cryptographically secure.
@@ -50,7 +51,7 @@ impl std::hash::BuildHasher for FixedState {
 /// # }
 /// ```
 ///
-/// The standard library's [`HashMap::new`][std::collections::HashMap::new] is
+/// The standard library's [`HashMap::new`][hashbrown::HashMap::new] is
 /// implemented only for `HashMap`s which use the
 /// [`DefaultHasher`][std::collections::hash_map::DefaultHasher], so it's not
 /// available for Bevy's `HashMap`.
@@ -69,30 +70,30 @@ impl std::hash::BuildHasher for FixedState {
 /// ```
 ///
 /// [`aHash`]: https://github.com/tkaitchuck/aHash
-pub type HashMap<K, V> = std::collections::HashMap<K, V, RandomState>;
-
-pub trait AHashExt {
-    fn with_capacity(capacity: usize) -> Self;
-}
-
-impl<K, V> AHashExt for HashMap<K, V> {
-    /// Creates an empty `HashMap` with the specified capacity with aHash.
-    ///
-    /// The hash map will be able to hold at least `capacity` elements without
-    /// reallocating. If `capacity` is 0, the hash map will not allocate.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bevy_utils::{HashMap, AHashExt};
-    /// let mut map: HashMap<&str, i32> = HashMap::with_capacity(10);
-    /// assert!(map.capacity() >= 10);
-    /// ```
-    #[inline]
-    fn with_capacity(capacity: usize) -> Self {
-        HashMap::with_capacity_and_hasher(capacity, RandomState::default())
-    }
-}
+pub type HashMap<K, V> = hashbrown::HashMap<K, V, RandomState>;
+
+// pub trait AHashExt {
+//     fn with_capacity(capacity: usize) -> Self;
+// }
+
+// impl<K, V> AHashExt for HashMap<K, V> {
+//     /// Creates an empty `HashMap` with the specified capacity with aHash.
+//     ///
+//     /// The hash map will be able to hold at least `capacity` elements without
+//     /// reallocating. If `capacity` is 0, the hash map will not allocate.
+//     ///
+//     /// # Examples
+//     ///
+//     /// ```
+//     /// use bevy_utils::{HashMap, AHashExt};
+//     /// let mut map: HashMap<&str, i32> = HashMap::with_capacity(10);
+//     /// assert!(map.capacity() >= 10);
+//     /// ```
+//     #[inline]
+//     fn with_capacity(capacity: usize) -> Self {
+//         HashMap::with_capacity_and_hasher(capacity, RandomState::default())
+//     }
+// }
 
 /// A stable std hash map implementing `aHash`, a high speed keyed hashing algorithm
 /// intended for use in in-memory hashmaps.
@@ -101,26 +102,26 @@ impl<K, V> AHashExt for HashMap<K, V> {
 /// of insertions and deletions and not a random source.
 ///
 /// `aHash` is designed for performance and is NOT cryptographically secure.
-pub type StableHashMap<K, V> = std::collections::HashMap<K, V, FixedState>;
-
-impl<K, V> AHashExt for StableHashMap<K, V> {
-    /// Creates an empty `StableHashMap` with the specified capacity with `aHash`.
-    ///
-    /// The hash map will be able to hold at least `capacity` elements without
-    /// reallocating. If `capacity` is 0, the hash map will not allocate.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bevy_utils::{StableHashMap, AHashExt};
-    /// let mut map: StableHashMap<&str, i32> = StableHashMap::with_capacity(10);
-    /// assert!(map.capacity() >= 10);
-    /// ```
-    #[inline]
-    fn with_capacity(capacity: usize) -> Self {
-        StableHashMap::with_capacity_and_hasher(capacity, FixedState::default())
-    }
-}
+pub type StableHashMap<K, V> = hashbrown::HashMap<K, V, FixedState>;
+
+// impl<K, V> AHashExt for StableHashMap<K, V> {
+//     /// Creates an empty `StableHashMap` with the specified capacity with `aHash`.
+//     ///
+//     /// The hash map will be able to hold at least `capacity` elements without
+//     /// reallocating. If `capacity` is 0, the hash map will not allocate.
+//     ///
+//     /// # Examples
+//     ///
+//     /// ```
+//     /// use bevy_utils::{StableHashMap, AHashExt};
+//     /// let mut map: StableHashMap<&str, i32> = StableHashMap::with_capacity(10);
+//     /// assert!(map.capacity() >= 10);
+//     /// ```
+//     #[inline]
+//     fn with_capacity(capacity: usize) -> Self {
+//         StableHashMap::with_capacity_and_hasher(capacity, FixedState::default())
+//     }
+// }
 
 /// A [`HashSet`][std::collections::HashSet] implementing [`aHash`], a high
 /// speed keyed hashing algorithm intended for use in in-memory hashmaps.
@@ -159,26 +160,26 @@ impl<K, V> AHashExt for StableHashMap<K, V> {
 /// ```
 ///
 /// [`aHash`]: https://github.com/tkaitchuck/aHash
-pub type HashSet<K> = std::collections::HashSet<K, RandomState>;
-
-impl<K> AHashExt for HashSet<K> {
-    /// Creates an empty `HashSet` with the specified capacity with aHash.
-    ///
-    /// The hash set will be able to hold at least `capacity` elements without
-    /// reallocating. If `capacity` is 0, the hash set will not allocate.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bevy_utils::{HashSet, AHashExt};
-    /// let set: HashSet<i32> = HashSet::with_capacity(10);
-    /// assert!(set.capacity() >= 10);
-    /// ```
-    #[inline]
-    fn with_capacity(capacity: usize) -> Self {
-        HashSet::with_capacity_and_hasher(capacity, RandomState::default())
-    }
-}
+pub type HashSet<K> = hashbrown::HashSet<K, RandomState>;
+
+// impl<K> AHashExt for HashSet<K> {
+//     /// Creates an empty `HashSet` with the specified capacity with aHash.
+//     ///
+//     /// The hash set will be able to hold at least `capacity` elements without
+//     /// reallocating. If `capacity` is 0, the hash set will not allocate.
+//     ///
+//     /// # Examples
+//     ///
+//     /// ```
+//     /// use bevy_utils::{HashSet, AHashExt};
+//     /// let set: HashSet<i32> = HashSet::with_capacity(10);
+//     /// assert!(set.capacity() >= 10);
+//     /// ```
+//     #[inline]
+//     fn with_capacity(capacity: usize) -> Self {
+//         HashSet::with_capacity_and_hasher(capacity, RandomState::default())
+//     }
+// }
 
 /// A stable std hash set implementing `aHash`, a high speed keyed hashing algorithm
 /// intended for use in in-memory hashmaps.
@@ -187,23 +188,23 @@ impl<K> AHashExt for HashSet<K> {
 /// of insertions and deletions and not a random source.
 ///
 /// `aHash` is designed for performance and is NOT cryptographically secure.
-pub type StableHashSet<K> = std::collections::HashSet<K, FixedState>;
-
-impl<K> AHashExt for StableHashSet<K> {
-    /// Creates an empty `StableHashSet` with the specified capacity with `aHash`.
-    ///
-    /// The hash set will be able to hold at least `capacity` elements without
-    /// reallocating. If `capacity` is 0, the hash set will not allocate.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bevy_utils::{StableHashSet, AHashExt};
-    /// let set: StableHashSet<i32> = StableHashSet::with_capacity(10);
-    /// assert!(set.capacity() >= 10);
-    /// ```
-    #[inline]
-    fn with_capacity(capacity: usize) -> Self {
-        StableHashSet::with_capacity_and_hasher(capacity, FixedState::default())
-    }
-}
+pub type StableHashSet<K> = hashbrown::HashSet<K, FixedState>;
+
+// impl<K> AHashExt for StableHashSet<K> {
+//     /// Creates an empty `StableHashSet` with the specified capacity with `aHash`.
+//     ///
+//     /// The hash set will be able to hold at least `capacity` elements without
+//     /// reallocating. If `capacity` is 0, the hash set will not allocate.
+//     ///
+//     /// # Examples
+//     ///
+//     /// ```
+//     /// use bevy_utils::{StableHashSet, AHashExt};
+//     /// let set: StableHashSet<i32> = StableHashSet::with_capacity(10);
+//     /// assert!(set.capacity() >= 10);
+//     /// ```
+//     #[inline]
+//     fn with_capacity(capacity: usize) -> Self {
+//         StableHashSet::with_capacity_and_hasher(capacity, FixedState::default())
+//     }
+// }