Enable proper entity location for EntityManager::create

[Gronis]

Right now, entities created with EntityManager::create() without components are added without knowledge of its components. A way to improve this would be to create a temporary entity, and add it to the EntityManager once the Entity goes out of scope (because then we know what components it has). The problem with this is that it would be "id less" until it goes out of scope.

[Gronis]

An idea is to create a new class: UnallocatedEntity which is returned by the EntityManager when creating a new entity. It has the same interface (methods) as an entity an can be implicitly casted into an entity (So that the current behaviour is kept). However, each component that's added to the UnallocatedEntity is placed an a temporary location at first. When the destructor or the assignment operator is called, all temporary components and the entity are moved into the entityManager.

This way, the EntityManager can assign a "smart" location in memory based on the added components since it's added to the EntityManager when all components have been added.

Good or bad idea?

[waldnercharles]

I feel like this is on the right track. If you decide to implement this, it might be nice to have an explicit assignment method as well.

UnallocatedEntity::allocate(); or EntityManager::create_temporary()

Also, I don't know if there would actually be any gains in speed. I would benchmark it.

[Gronis]

I was thinking that instead of implementing a new method: EntityManager::create_temp();, modify EntityManager::create() so that it returns an UnallocatedEntity which can be implicitly casted to Entity. So when writing like this: Entity e = entities.create(); The standard behaviour is kept.
But when writing like this:

UnallocatedEntity e = entities.create(); 
//or
auto e = entities.create();

We get the new behavior.

I like the ability to allocate manually as well as automatically.

[waldnercharles]

Either way you decide to go, I would write a test to benchmark the difference in speed.

[Gronis]

I've benchmarked for some time now and don't really find a huge performance swing. Unless there are very few entities with a quite large component.

In my test, if i let each 16th entity have ComponentType1, which has the size 32B, and the other entities have some other component. Then iterating over all 10M entities and check for ComponentType1 (which is 1/16 of 10M entities, spread uniformly across memory) and unpacking this component, this takes about 0.0138-0.0151s. Doing the same, but with the entities which has ComponentType1 being clumped together in memory takes about 0.0085-0.0104s

However for small components like a few bytes, this does not make a particular impact. Changing the size of ComponentType1 to 4B, the performance is very similar (less than 0.001s difference). Since all the ComponentMasks needs to be loaded into memory anyway, and the ComponentMask is 8 bytes as standard, which means that scatter small components over the memory does not impact the overall performance that much.

So, as long one type of component is quite big (>16B) and there are quite few of entities with this component type, then the "smart" allocation is quite a nice feature.

I will benchmark if returning an UnallocatedEntity from EntityManager::create() and do an implicit cast does impact performance over the current implementation of EntityManager::create(). If there is no or minimal impact, then I think this is the way to go.

[Gronis]

I added the UnallocatedEntity and as performance was better when iterating, since entities are clumped closer together. However, allocating is pretty slow right now (5x times slower compared to when not using UnallocatedEntity) and needs to be improved to somewhere around 2x the normal speed (since we have to copy the data). But since this only matters when using UnallocatedEntity, I pushed it anyway. There were no difference in performance when creating UnallocatedEntities and then implicitly cast them to Entities, since the allocate step only assigns an id, so using Entity e = entities.create(); should have the same performance.