Staged Components

benches/benches/bevy_ecs/components/mod.rs

@@ -7,6 +7,7 @@ mod add_remove_very_big_table;
 mod archetype_updates;
 mod insert_simple;
 mod insert_simple_unbatched;
+mod registration;
 
 use archetype_updates::*;
 use criterion::{criterion_group, Criterion};
@@ -19,6 +20,7 @@ criterion_group!(
     insert_simple,
     no_archetypes,
     added_archetypes,
+    registration::bench_registration,
 );
 
 fn add_remove(c: &mut Criterion) {

benches/benches/bevy_ecs/components/registration.rs

@@ -0,0 +1,250 @@
+use core::hint::black_box;
+use std::ops::Deref;
+
+use bevy_ecs::component::{require, Component, Components, ComponentsWriter, StagedComponents};
+use bevy_utils::staging::{
+    ArcStageOnWrite, AtomicStageOnWrite, RefStageOnWrite, StagableWrites, StagableWritesCore,
+    StageOnWrite,
+};
+use criterion::Criterion;
+
+#[derive(Component, Default)]
+struct ComponentA0;
+
+#[derive(Component, Default)]
+struct ComponentA1;
+
+#[derive(Component, Default)]
+struct ComponentA2;
+
+#[derive(Component, Default)]
+struct ComponentA3;
+
+#[derive(Component, Default)]
+struct ComponentA4;
+
+#[derive(Component, Default)]
+struct ComponentA5;
+
+#[derive(Component, Default)]
+struct ComponentA6;
+
+#[derive(Component, Default)]
+struct ComponentA7;
+
+#[derive(Component, Default)]
+struct ComponentA8;
+
+#[derive(Component, Default)]
+struct ComponentA9;
+
+#[derive(Component, Default)]
+#[require(ComponentA0, ComponentA2)]
+struct ComponentB0;
+
+#[derive(Component, Default)]
+#[require(ComponentA0, ComponentA3, ComponentA7)]
+struct ComponentB1;
+
+#[derive(Component, Default)]
+#[require(ComponentA0, ComponentA2)]
+struct ComponentB2;
+
+#[derive(Component, Default)]
+#[require(ComponentA0, ComponentA1)]
+struct ComponentB3;
+
+#[derive(Component, Default)]
+#[require(ComponentA0, ComponentA1)]
+struct ComponentB4;
+
+#[derive(Component, Default)]
+#[require(ComponentA0, ComponentA1, ComponentA8, ComponentA4)]
+struct ComponentB5;
+
+#[derive(Component, Default)]
+#[require(ComponentA0, ComponentA1, ComponentA6)]
+struct ComponentB6;
+
+#[derive(Component, Default)]
+struct ComponentB7;
+
+#[derive(Component, Default)]
+struct ComponentB8;
+
+#[derive(Component, Default)]
+struct ComponentB9;
+
+#[derive(Component, Default)]
+struct ComponentC0;
+
+#[derive(Component, Default)]
+struct ComponentC1;
+
+#[derive(Component, Default)]
+#[require(ComponentB1)]
+struct ComponentC2;
+
+#[derive(Component, Default)]
+#[require(ComponentB1)]
+struct ComponentC3;
+
+#[derive(Component, Default)]
+#[require(ComponentB1, ComponentB2, ComponentB3, ComponentB4)]
+struct ComponentC4;
+
+#[derive(Component, Default)]
+#[require(ComponentB1, ComponentB2, ComponentB4)]
+struct ComponentC5;
+
+#[derive(Component, Default)]
+#[require(ComponentB1, ComponentB9, ComponentB3)]
+struct ComponentC6;
+
+#[derive(Component, Default)]
+#[require(ComponentB1, ComponentB8, ComponentB4)]
+struct ComponentC7;
+
+#[derive(Component, Default)]
+#[require(ComponentB1, ComponentB2, ComponentB6)]
+struct ComponentC8;
+
+#[derive(Component, Default)]
+#[require(ComponentB1, ComponentB5, ComponentB8)]
+struct ComponentC9;
+
+fn register_direct(components: &mut impl ComponentsWriter) {
+    components.register_component::<ComponentA0>();
+    components.register_component::<ComponentA1>();
+    components.register_component::<ComponentA2>();
+    components.register_component::<ComponentA3>();
+    components.register_component::<ComponentA4>();
+    components.register_component::<ComponentA5>();
+    components.register_component::<ComponentA6>();
+    components.register_component::<ComponentA7>();
+    components.register_component::<ComponentA8>();
+    components.register_component::<ComponentA9>();
+    components.register_component::<ComponentB0>();
+    components.register_component::<ComponentB1>();
+    components.register_component::<ComponentB2>();
+    components.register_component::<ComponentB3>();
+    components.register_component::<ComponentB4>();
+    components.register_component::<ComponentB5>();
+    components.register_component::<ComponentB6>();
+    components.register_component::<ComponentB7>();
+    components.register_component::<ComponentB8>();
+    components.register_component::<ComponentB9>();
+    components.register_component::<ComponentC0>();
+    components.register_component::<ComponentC1>();
+    components.register_component::<ComponentC2>();
+    components.register_component::<ComponentC3>();
+    components.register_component::<ComponentC4>();
+    components.register_component::<ComponentC5>();
+    components.register_component::<ComponentC6>();
+    components.register_component::<ComponentC7>();
+    components.register_component::<ComponentC8>();
+    components.register_component::<ComponentC9>();
+}
+
+fn register_synced(
+    mut components: impl StagableWrites<Core: StagableWritesCore<Staging = StagedComponents>>,
+) {
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA0>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA1>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA2>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA3>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA4>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA5>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA6>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA7>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA8>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentA9>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB0>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB1>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB2>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB3>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB4>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB5>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB6>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB7>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB8>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentB9>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC0>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC1>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC2>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC3>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC4>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC5>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC6>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC7>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC8>());
+    components.stage_scope_locked(|stager| stager.register_component::<ComponentC9>());
+}
+
+pub fn bench_registration(c: &mut Criterion) {
+    let mut group = c.benchmark_group("registration");
+    group.warm_up_time(core::time::Duration::from_millis(500));
+    group.measurement_time(core::time::Duration::from_secs(4));
+    group.bench_function("Components directly", |b| {
+        b.iter(move || {
+            let mut components = black_box(Components::default());
+            register_direct(&mut components);
+        });
+    });
+    group.bench_function("StageOnWrite stage", |b| {
+        b.iter(move || {
+            let mut components = black_box(StageOnWrite::<StagedComponents>::default());
+            register_direct(&mut components.stage());
+            components.apply_staged_for_full();
+        });
+    });
+    group.bench_function("AtomicStageOnWrite stage", |b| {
+        b.iter(move || {
+            let mut components = black_box(AtomicStageOnWrite::<StagedComponents>::default());
+            register_direct(&mut components.stage());
+            components.apply_staged_for_full();
+        });
+    });
+    group.bench_function("StageOnWrite lock", |b| {
+        b.iter(move || {
+            let mut components = black_box(StageOnWrite::<StagedComponents>::default());
+            register_direct(&mut RefStageOnWrite(&components).stage_lock().as_stager());
+            components.apply_staged_for_full();
+        });
+    });
+    group.bench_function("AtomicStageOnWrite lock", |b| {
+        b.iter(move || {
+            let mut components = black_box(AtomicStageOnWrite::<StagedComponents>::default());
+            register_direct(&mut RefStageOnWrite(&components).stage_lock().as_stager());
+            components.apply_staged_for_full();
+        });
+    });
+    group.bench_function("ArcStageOnWrite lock eager", |b| {
+        b.iter(move || {
+            let mut components = black_box(ArcStageOnWrite::<StagedComponents>::default());
+            components.stage_scope_locked_eager(|stager| register_direct(stager));
+        });
+    });
+    group.bench_function("StageOnWrite sync", |b| {
+        b.iter(move || {
+            let mut components = black_box(StageOnWrite::<StagedComponents>::default());
+            register_synced(RefStageOnWrite(&components));
+            components.apply_staged_for_full();
+        });
+    });
+    group.bench_function("AtomicStageOnWrite sync", |b| {
+        b.iter(move || {
+            let mut components = black_box(AtomicStageOnWrite::<StagedComponents>::default());
+            register_synced(RefStageOnWrite(&components));
+            components.apply_staged_for_full();
+        });
+    });
+    group.bench_function("ArcStageOnWrite sync eager", |b| {
+        b.iter(move || {
+            let components = black_box(ArcStageOnWrite::<StagedComponents>::default());
+            register_synced(RefStageOnWrite(components.0.deref()));
+            components.apply_staged_non_blocking();
+        });
+    });
+    group.finish();
+}

crates/bevy_asset/src/asset_changed.rs

@@ -4,7 +4,7 @@
 //! and triggers whenever the handle or the underlying asset changes.
 
 use crate::{AsAssetId, Asset, AssetId};
-use bevy_ecs::component::Components;
+use bevy_ecs::component::{Components, ComponentsReader};
 use bevy_ecs::{
     archetype::Archetype,
     component::{ComponentId, Tick},

crates/bevy_ecs/macros/src/component.rs

@@ -223,7 +223,7 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
             type Mutability = #mutable_type;
             fn register_required_components(
                 requiree: #bevy_ecs_path::component::ComponentId,
-                components: &mut #bevy_ecs_path::component::Components,
+                components: &mut impl #bevy_ecs_path::component::ComponentsWriter,
                 required_components: &mut #bevy_ecs_path::component::RequiredComponents,
                 inheritance_depth: u16,
                 recursion_check_stack: &mut #bevy_ecs_path::__macro_exports::Vec<#bevy_ecs_path::component::ComponentId>

crates/bevy_ecs/src/archetype.rs

@@ -21,7 +21,9 @@
 
 use crate::{
     bundle::BundleId,
-    component::{ComponentId, Components, RequiredComponentConstructor, StorageType},
+    component::{
+        ComponentId, Components, ComponentsReader, RequiredComponentConstructor, StorageType,
+    },
     entity::{Entity, EntityLocation},
     observer::Observers,
     storage::{ImmutableSparseSet, SparseArray, SparseSet, SparseSetIndex, TableId, TableRow},

crates/bevy_ecs/src/bundle.rs

@@ -11,8 +11,8 @@ use crate::{
     },
     change_detection::MaybeLocation,
     component::{
-        Component, ComponentId, Components, RequiredComponentConstructor, RequiredComponents,
-        StorageType, Tick,
+        Component, ComponentId, Components, ComponentsReader, ComponentsWriter,
+        RequiredComponentConstructor, RequiredComponents, StorageType, Tick,
     },
     entity::{Entities, Entity, EntityLocation},
     observer::Observers,
@@ -30,7 +30,7 @@ use variadics_please::all_tuples;
 
 /// The `Bundle` trait enables insertion and removal of [`Component`]s from an entity.
 ///
-/// Implementors of the `Bundle` trait are called 'bundles'.
+/// Implementers of the `Bundle` trait are called 'bundles'.
 ///
 /// Each bundle represents a static set of [`Component`] types.
 /// Currently, bundles can only contain one of each [`Component`], and will
@@ -71,7 +71,7 @@ use variadics_please::all_tuples;
 /// That is, if the entity does not have all the components of the bundle, those
 /// which are present will be removed.
 ///
-/// # Implementors
+/// # Implementers
 ///
 /// Every type which implements [`Component`] also implements `Bundle`, since
 /// [`Component`] types can be added to or removed from an entity.
@@ -508,9 +508,15 @@ impl BundleInfo {
         let mut required_components = RequiredComponents::default();
         for component_id in component_ids.iter().copied() {
             // SAFETY: caller has verified that all ids are valid
-            let info = unsafe { components.get_info_unchecked(component_id) };
-            required_components.merge(info.required_components());
+            let info = unsafe { &components.get_info_unchecked(component_id) };
             storages.prepare_component(info);
+            // SAFETY: caller has verified that all ids are valid
+            let required = unsafe {
+                &components
+                    .get_required_components(component_id)
+                    .debug_checked_unwrap()
+            };
+            required.merge_into(&mut required_components);
         }
         required_components.remove_explicit_components(&component_ids);
 
@@ -520,7 +526,7 @@ impl BundleInfo {
             .into_iter()
             .map(|(component_id, v)| {
                 // Safety: These ids came out of the passed `components`, so they must be valid.
-                let info = unsafe { components.get_info_unchecked(component_id) };
+                let info = unsafe { &components.get_info_unchecked(component_id) };
                 storages.prepare_component(info);
                 // This adds required components to the component_ids list _after_ using that list to remove explicitly provided
                 // components. This ordering is important!