In-Place Component Initialization

[james7132]

What problem does this solve or what need does it fill?

Right now, components are inserted into the ECS by first initializing them on the stack (usually in a Bundle) and then moving the value into the space allocated within ECS storage. This extra copy isn't entirely necessary, causing entity spawning/component insertion to not be a truly zero-cost abstraction.

What solution would you like?

Ideally, space would be allocated before any initialization occurs, and a pointer to the uninitialized memory is then used to directly initialize the value. If there is support for this at the type system or language level, we may be able to get away with avoiding a major change to the user facing API. However, assuming no further support from Rust itself on this, a rough sketch of the user-facing API might look like this:

// May require generalizing over Bundles and surfacing on other similar API surfaces
impl EntityMut {
  pub fn insert_in_place<C: Component>(&mut self, init: FnOnce(&mut MaybeUninit<C>));
}

impl ThinColumn {
  pub unsafe fn initialize_in_place_unchecked(&mut self, index: usize, init: impl FnOnce(OwningPtr<'_>), ...);
}

impl BlobVec {
  pub unsafe fn initialize_in_place_unchecked<T>(&mut self, index: usize, init: impl FnOnce(OwningPtr<'_>));
}

That said I'm not all that keen on exposing the deep internals of the ECS storage by running externally provided code, as there aren't many ways to keep those spaces panic safe, as seen with #20368, but this may need to be something we live with.

What alternative(s) have you considered?

Leave it as is and pay the extra memcpy costs.

Additional context

This may require more extensive language support to make this ergonomic. See rust-lang/lang-team#336 for further discussions on this topic.

[SkiFire13]

impl EntityMut {
 pub fn insert_in_place<C: Component>(&mut self, init: FnOnce(&mut MaybeUninit<C>));
}

Note that this would be unsound, since there's no guarantee that the closure will initialize the MaybeUninit.

I believe simply taking a FnOnce() -> C should be good enough for a safe implementation. It won't guarantee an inplace initialization but it will make it much easier for the compiler to optimize into one.

However I wonder if this will have real benefits, as it's limited to inserting only one component. Generally the cost really comes from inserting lot of components together, or from moving the existing ones between tables.