Synchronized component registration

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,
 );
 
 fn add_remove(c: &mut Criterion) {

benches/benches/bevy_ecs/components/registration.rs

@@ -0,0 +1,224 @@
+use core::hint::black_box;
+
+use bevy_ecs::component::{require, Component, Components, ComponentsData, ComponentsView};
+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 ComponentsView) {
+    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(components: &Components) {
+    components.register_component_synced::<ComponentA0>();
+    components.register_component_synced::<ComponentA1>();
+    components.register_component_synced::<ComponentA2>();
+    components.register_component_synced::<ComponentA3>();
+    components.register_component_synced::<ComponentA4>();
+    components.register_component_synced::<ComponentA5>();
+    components.register_component_synced::<ComponentA6>();
+    components.register_component_synced::<ComponentA7>();
+    components.register_component_synced::<ComponentA8>();
+    components.register_component_synced::<ComponentA9>();
+    components.register_component_synced::<ComponentB0>();
+    components.register_component_synced::<ComponentB1>();
+    components.register_component_synced::<ComponentB2>();
+    components.register_component_synced::<ComponentB3>();
+    components.register_component_synced::<ComponentB4>();
+    components.register_component_synced::<ComponentB5>();
+    components.register_component_synced::<ComponentB6>();
+    components.register_component_synced::<ComponentB7>();
+    components.register_component_synced::<ComponentB8>();
+    components.register_component_synced::<ComponentB9>();
+    components.register_component_synced::<ComponentC0>();
+    components.register_component_synced::<ComponentC1>();
+    components.register_component_synced::<ComponentC2>();
+    components.register_component_synced::<ComponentC3>();
+    components.register_component_synced::<ComponentC4>();
+    components.register_component_synced::<ComponentC5>();
+    components.register_component_synced::<ComponentC6>();
+    components.register_component_synced::<ComponentC7>();
+    components.register_component_synced::<ComponentC8>();
+    components.register_component_synced::<ComponentC9>();
+}
+
+pub fn bench(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("raw", |b| {
+        b.iter(move || {
+            let mut components = black_box(ComponentsData::default());
+            register_direct(&mut components);
+        });
+    });
+    group.bench_function("mut", |b| {
+        b.iter(move || {
+            let mut components = black_box(Components::default());
+            register_direct(&mut components.as_mut());
+            components.clean();
+        });
+    });
+    group.bench_function("locked", |b| {
+        b.iter(move || {
+            let mut components = black_box(Components::default());
+            register_direct(&mut components.lock());
+            components.clean();
+        });
+    });
+    group.bench_function("full", |b| {
+        b.iter(move || {
+            let mut components = black_box(Components::default());
+            register_direct(&mut components);
+            components.clean();
+        });
+    });
+    group.bench_function("full_staged", |b| {
+        b.iter(move || {
+            let mut components = black_box(Components::default());
+            components.register_component_synced::<ComponentA0>(); // to trigger a staged change
+            register_direct(&mut components);
+            components.clean();
+        });
+    });
+    group.bench_function("synced", |b| {
+        b.iter(move || {
+            let mut components = black_box(Components::default());
+            register_synced(&components);
+            components.clean();
+        });
+    });
+    group.finish();
+}

crates/bevy_app/src/sub_app.rs

@@ -141,6 +141,7 @@ impl SubApp {
 
     /// Runs the default schedule and updates internal component trackers.
     pub fn update(&mut self) {
+        self.world.clean();
         self.run_default_schedule();
         self.world.clear_trackers();
     }

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, ComponentsViewReadonly};
 use bevy_ecs::{
     archetype::Archetype,
     component::{ComponentId, Tick},

crates/bevy_ecs/macros/src/component.rs

@@ -151,7 +151,6 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
                 <#ident as #bevy_ecs_path::component::Component>::register_required_components(
                     requiree,
                     components,
-                    storages,
                     required_components,
                     inheritance_depth + 1,
                     recursion_check_stack
@@ -161,7 +160,6 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
                 Some(RequireFunc::Path(func)) => {
                     register_required.push(quote! {
                         components.register_required_components_manual::<Self, #ident>(
-                            storages,
                             required_components,
                             || { let x: #ident = #func().into(); x },
                             inheritance_depth,
@@ -172,7 +170,6 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
                 Some(RequireFunc::Closure(func)) => {
                     register_required.push(quote! {
                         components.register_required_components_manual::<Self, #ident>(
-                            storages,
                             required_components,
                             || { let x: #ident = (#func)().into(); x },
                             inheritance_depth,
@@ -183,7 +180,6 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
                 None => {
                     register_required.push(quote! {
                         components.register_required_components_manual::<Self, #ident>(
-                            storages,
                             required_components,
                             <#ident as Default>::default,
                             inheritance_depth,
@@ -218,14 +214,13 @@ 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,
-                storages: &mut #bevy_ecs_path::storage::Storages,
+                components: &mut impl #bevy_ecs_path::component::ComponentsViewExclusive,
                 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>
             ) {
                 #bevy_ecs_path::component::enforce_no_required_components_recursion(components, recursion_check_stack);
-                let self_id = components.register_component::<Self>(storages);
+                let self_id = components.register_component::<Self>();
                 recursion_check_stack.push(self_id);
                 #(#register_required)*
                 #(#register_recursive_requires)*

crates/bevy_ecs/macros/src/lib.rs

@@ -86,10 +86,10 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
         match field_kind {
             BundleFieldKind::Component => {
                 field_component_ids.push(quote! {
-                <#field_type as #ecs_path::bundle::Bundle>::component_ids(components, storages, &mut *ids);
+                <#field_type as #ecs_path::bundle::Bundle>::component_ids(components, &mut *ids);
                 });
                 field_required_components.push(quote! {
-                    <#field_type as #ecs_path::bundle::Bundle>::register_required_components(components, storages, required_components);
+                    <#field_type as #ecs_path::bundle::Bundle>::register_required_components(components, required_components);
                 });
                 field_get_component_ids.push(quote! {
                     <#field_type as #ecs_path::bundle::Bundle>::get_component_ids(components, &mut *ids);
@@ -134,7 +134,6 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
         unsafe impl #impl_generics #ecs_path::bundle::Bundle for #struct_name #ty_generics #where_clause {
             fn component_ids(
                 components: &mut #ecs_path::component::Components,
-                storages: &mut #ecs_path::storage::Storages,
                 ids: &mut impl FnMut(#ecs_path::component::ComponentId)
             ){
                 #(#field_component_ids)*
@@ -158,8 +157,7 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             }
 
             fn register_required_components(
-                components: &mut #ecs_path::component::Components,
-                storages: &mut #ecs_path::storage::Storages,
+                components: &mut impl #ecs_path::component::ComponentsViewExclusive,
                 required_components: &mut #ecs_path::component::RequiredComponents
             ){
                 #(#field_required_components)*