e9a0ef49f9
# Objective The goal of `bevy_platform_support` is to provide a set of platform agnostic APIs, alongside platform-specific functionality. This is a high traffic crate (providing things like HashMap and Instant). Especially in light of https://github.com/bevyengine/bevy/discussions/18799, it deserves a friendlier / shorter name. Given that it hasn't had a full release yet, getting this change in before Bevy 0.16 makes sense. ## Solution - Rename `bevy_platform_support` to `bevy_platform`.
78 lines
3.2 KiB
Rust
78 lines
3.2 KiB
Rust
use core::hash::{BuildHasher, Hasher};
|
|
|
|
#[cfg(feature = "bevy_reflect")]
|
|
use bevy_reflect::{std_traits::ReflectDefault, Reflect};
|
|
|
|
/// A [`BuildHasher`] that results in a [`EntityHasher`].
|
|
#[derive(Debug, Default, Clone)]
|
|
#[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Default, Clone))]
|
|
pub struct EntityHash;
|
|
|
|
impl BuildHasher for EntityHash {
|
|
type Hasher = EntityHasher;
|
|
|
|
fn build_hasher(&self) -> Self::Hasher {
|
|
Self::Hasher::default()
|
|
}
|
|
}
|
|
|
|
/// A very fast hash that is only designed to work on generational indices
|
|
/// like [`Entity`](super::Entity). It will panic if attempting to hash a type containing
|
|
/// non-u64 fields.
|
|
///
|
|
/// This is heavily optimized for typical cases, where you have mostly live
|
|
/// entities, and works particularly well for contiguous indices.
|
|
///
|
|
/// If you have an unusual case -- say all your indices are multiples of 256
|
|
/// or most of the entities are dead generations -- then you might want also to
|
|
/// try [`DefaultHasher`](bevy_platform::hash::DefaultHasher) for a slower hash
|
|
/// computation but fewer lookup conflicts.
|
|
#[derive(Debug, Default)]
|
|
pub struct EntityHasher {
|
|
hash: u64,
|
|
}
|
|
|
|
impl Hasher for EntityHasher {
|
|
#[inline]
|
|
fn finish(&self) -> u64 {
|
|
self.hash
|
|
}
|
|
|
|
fn write(&mut self, _bytes: &[u8]) {
|
|
panic!("EntityHasher can only hash u64 fields.");
|
|
}
|
|
|
|
#[inline]
|
|
fn write_u64(&mut self, bits: u64) {
|
|
// SwissTable (and thus `hashbrown`) cares about two things from the hash:
|
|
// - H1: low bits (masked by `2ⁿ-1`) to pick the slot in which to store the item
|
|
// - H2: high 7 bits are used to SIMD optimize hash collision probing
|
|
// For more see <https://abseil.io/about/design/swisstables#metadata-layout>
|
|
|
|
// This hash function assumes that the entity ids are still well-distributed,
|
|
// so for H1 leaves the entity id alone in the low bits so that id locality
|
|
// will also give memory locality for things spawned together.
|
|
// For H2, take advantage of the fact that while multiplication doesn't
|
|
// spread entropy to the low bits, it's incredibly good at spreading it
|
|
// upward, which is exactly where we need it the most.
|
|
|
|
// While this does include the generation in the output, it doesn't do so
|
|
// *usefully*. H1 won't care until you have over 3 billion entities in
|
|
// the table, and H2 won't care until something hits generation 33 million.
|
|
// Thus the comment suggesting that this is best for live entities,
|
|
// where there won't be generation conflicts where it would matter.
|
|
|
|
// The high 32 bits of this are ⅟φ for Fibonacci hashing. That works
|
|
// particularly well for hashing for the same reason as described in
|
|
// <https://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/>
|
|
// It loses no information because it has a modular inverse.
|
|
// (Specifically, `0x144c_bc89_u32 * 0x9e37_79b9_u32 == 1`.)
|
|
//
|
|
// The low 32 bits make that part of the just product a pass-through.
|
|
const UPPER_PHI: u64 = 0x9e37_79b9_0000_0001;
|
|
|
|
// This is `(MAGIC * index + generation) << 32 + index`, in a single instruction.
|
|
self.hash = bits.wrapping_mul(UPPER_PHI);
|
|
}
|
|
}
|