Fragmenting value components

benches/benches/bevy_ecs/components/fragmenting_values.rs

@@ -0,0 +1,123 @@
+use bevy_ecs::prelude::*;
+use criterion::Criterion;
+use glam::*;
+
+#[derive(Component, PartialEq, Eq, Hash, Clone)]
+#[component(immutable, key=Self)]
+struct Fragmenting<const N: usize>(u32);
+
+#[derive(Component)]
+struct NonFragmenting<const N: usize>(Vec3);
+
+pub fn insert_fragmenting_value(c: &mut Criterion) {
+    let mut group = c.benchmark_group("insert_fragmenting_value");
+    group.warm_up_time(core::time::Duration::from_millis(500));
+    group.measurement_time(core::time::Duration::from_secs(5));
+    group.bench_function("base", |b| {
+        b.iter(move || {
+            let mut world = World::new();
+            world.spawn_batch((0..10_000).map(|_| {
+                (
+                    Fragmenting::<1>(1),
+                    NonFragmenting::<1>(Vec3::ONE),
+                    NonFragmenting::<2>(Vec3::ONE),
+                    NonFragmenting::<3>(Vec3::ONE),
+                )
+            }));
+        });
+    });
+    group.bench_function("unbatched", |b| {
+        b.iter(move || {
+            let mut world = World::new();
+            for _ in 0..10_000 {
+                world.spawn((
+                    Fragmenting::<1>(1),
+                    NonFragmenting::<1>(Vec3::ONE),
+                    NonFragmenting::<2>(Vec3::ONE),
+                    NonFragmenting::<3>(Vec3::ONE),
+                ));
+            }
+        });
+    });
+    group.bench_function("high_fragmentation_base", |b| {
+        b.iter(move || {
+            let mut world = World::new();
+            world.spawn_batch((0..10_000).map(|i| {
+                (
+                    Fragmenting::<1>(i % 100),
+                    NonFragmenting::<1>(Vec3::ONE),
+                    NonFragmenting::<2>(Vec3::ONE),
+                    NonFragmenting::<3>(Vec3::ONE),
+                )
+            }));
+        });
+    });
+    group.bench_function("high_fragmentation_unbatched", |b| {
+        b.iter(move || {
+            let mut world = World::new();
+            for i in 0..10_000 {
+                world.spawn((
+                    Fragmenting::<1>(i % 100),
+                    NonFragmenting::<1>(Vec3::ONE),
+                    NonFragmenting::<2>(Vec3::ONE),
+                    NonFragmenting::<3>(Vec3::ONE),
+                ));
+            }
+        });
+    });
+    group.finish();
+}
+
+pub fn add_remove_fragmenting_value(c: &mut Criterion) {
+    let mut group = c.benchmark_group("add_remove_fragmenting_value");
+    group.warm_up_time(core::time::Duration::from_millis(500));
+    group.measurement_time(core::time::Duration::from_secs(5));
+
+    group.bench_function("non_fragmenting", |b| {
+        let mut world = World::new();
+        let entities: Vec<_> = world
+            .spawn_batch((0..10_000).map(|_| {
+                (
+                    Fragmenting::<1>(1),
+                    NonFragmenting::<1>(Vec3::ONE),
+                    NonFragmenting::<2>(Vec3::ONE),
+                    NonFragmenting::<3>(Vec3::ONE),
+                )
+            }))
+            .collect();
+        b.iter(move || {
+            for entity in &entities {
+                world
+                    .entity_mut(*entity)
+                    .insert(NonFragmenting::<4>(Vec3::ZERO));
+            }
+
+            for entity in &entities {
+                world.entity_mut(*entity).remove::<NonFragmenting<4>>();
+            }
+        });
+    });
+
+    group.bench_function("fragmenting", |b| {
+        let mut world = World::new();
+        let entities: Vec<_> = world
+            .spawn_batch((0..10_000).map(|_| {
+                (
+                    Fragmenting::<1>(1),
+                    NonFragmenting::<1>(Vec3::ONE),
+                    NonFragmenting::<2>(Vec3::ONE),
+                    NonFragmenting::<3>(Vec3::ONE),
+                )
+            }))
+            .collect();
+        b.iter(move || {
+            for entity in &entities {
+                world.entity_mut(*entity).insert(Fragmenting::<2>(1));
+            }
+
+            for entity in &entities {
+                world.entity_mut(*entity).remove::<Fragmenting<2>>();
+            }
+        });
+    });
+}

benches/benches/bevy_ecs/components/mod.rs

@@ -5,11 +5,13 @@ mod add_remove_sparse_set;
 mod add_remove_table;
 mod add_remove_very_big_table;
 mod archetype_updates;
+mod fragmenting_values;
 mod insert_simple;
 mod insert_simple_unbatched;
 
 use archetype_updates::*;
 use criterion::{criterion_group, Criterion};
+use fragmenting_values::*;
 
 criterion_group!(
     benches,
@@ -19,6 +21,8 @@ criterion_group!(
     insert_simple,
     no_archetypes,
     added_archetypes,
+    insert_fragmenting_value,
+    add_remove_fragmenting_value
 );
 
 fn add_remove(c: &mut Criterion) {

crates/bevy_core_pipeline/src/oit/mod.rs

@@ -62,6 +62,7 @@ impl Default for OrderIndependentTransparencySettings {
 impl Component for OrderIndependentTransparencySettings {
     const STORAGE_TYPE: StorageType = StorageType::SparseSet;
     type Mutability = Mutable;
+    type Key = NoKey;
 
     fn on_add() -> Option<ComponentHook> {
         Some(|world, context| {

crates/bevy_ecs/macros/src/component.rs

@@ -201,13 +201,19 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
         )
     };
 
+    let key = attrs
+        .key
+        .map(ToTokens::into_token_stream)
+        .unwrap_or_else(|| quote! {#bevy_ecs_path::component::NoKey});
+
     // This puts `register_required` before `register_recursive_requires` to ensure that the constructors of _all_ top
     // level components are initialized first, giving them precedence over recursively defined constructors for the same component type
     TokenStream::from(quote! {
         #required_component_docs
         impl #impl_generics #bevy_ecs_path::component::Component for #struct_name #type_generics #where_clause {
             const STORAGE_TYPE: #bevy_ecs_path::component::StorageType = #storage;
             type Mutability = #mutable_type;
+            type Key = #key;
             fn register_required_components(
                 _requiree: #bevy_ecs_path::component::ComponentId,
                 required_components: &mut #bevy_ecs_path::component::RequiredComponentsRegistrator,
@@ -342,6 +348,7 @@ pub const MAP_ENTITIES: &str = "map_entities";
 
 pub const IMMUTABLE: &str = "immutable";
 pub const CLONE_BEHAVIOR: &str = "clone_behavior";
+pub const KEY: &str = "key";
 
 /// All allowed attribute value expression kinds for component hooks.
 /// This doesn't simply use general expressions because of conflicting needs:
@@ -460,6 +467,7 @@ struct Attrs {
     immutable: bool,
     clone_behavior: Option<Expr>,
     map_entities: Option<MapEntitiesAttributeKind>,
+    key: Option<Type>,
 }
 
 #[derive(Clone, Copy)]
@@ -500,6 +508,7 @@ fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
         immutable: false,
         clone_behavior: None,
         map_entities: None,
+        key: None,
     };
 
     let mut require_paths = HashSet::new();
@@ -541,6 +550,9 @@ fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
                 } else if nested.path.is_ident(MAP_ENTITIES) {
                     attrs.map_entities = Some(nested.input.parse::<MapEntitiesAttributeKind>()?);
                     Ok(())
+                } else if nested.path.is_ident(KEY) {
+                    attrs.key = Some(nested.value()?.parse()?);
+                    Ok(())
                 } else {
                     Err(nested.error("Unsupported attribute"))
                 }

crates/bevy_ecs/macros/src/lib.rs

@@ -164,6 +164,21 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             ) {
                 #(<#active_field_types as #ecs_path::bundle::Bundle>::get_component_ids(components, &mut *ids);)*
             }
+
+            #[allow(unused_variables)]
+            #[inline]
+            fn get_fragmenting_values<'a>(
+                &'a self,
+                components: &#ecs_path::component::Components,
+                values: &mut impl FnMut(#ecs_path::component::FragmentingValueBorrowed<'a>)
+            ) {
+                #(self.#active_field_tokens.get_fragmenting_values(components, &mut *values);)*
+            }
+
+            #[inline(always)]
+            fn count_fragmenting_values() -> usize {
+                0 #(+ <#active_field_types as #ecs_path::bundle::Bundle>::count_fragmenting_values())*
+            }
         }
     };