rework linear allocators option in entities manager

Author: malytomas

sources/include/cage-core/entities.h

@@ -54,7 +54,12 @@ namespace cage
 		EntityComponent *defineComponent_(uint32 typeIndex, const void *prototype);
 	};
 
-	CAGE_CORE_API Holder<EntityManager> newEntityManager();
+	struct CAGE_CORE_API EntityManagerCreateConfig
+	{
+		bool linearAllocators = false; // much faster purge, but destroying entities or components will keep the memory allocated until purged
+	};
+
+	CAGE_CORE_API Holder<EntityManager> newEntityManager(const EntityManagerCreateConfig &config = {});
 
 	class CAGE_CORE_API EntityComponent : private Immovable
 	{
@@ -141,7 +146,7 @@ namespace cage
 		const EntityManager *source = nullptr;
 		EntityManager *destination = nullptr;
 		bool purge = true; // faster destroy previous entities, but does not call any callbacks
-		bool linearAllocator = false; // replace allocators in destination, which allows faster copy, but forbids removing entities or components
+		bool rebuildIndices = false; // allows correctly removing entities/components
 	};
 
 	CAGE_CORE_API void entitiesCopy(const EntitiesCopyConfig &config);

sources/libcore/entities.cpp

@@ -31,18 +31,20 @@ namespace cage
 		class EntityManagerImpl : public EntityManager
 		{
 		public:
+			const EntityManagerCreateConfig config;
 			Holder<MemoryArena> arena;
 			std::vector<Holder<ComponentImpl>> components;
 			std::vector<EntityComponent *> componentsByTypes;
 			ankerl::unordered_dense::map<uint32, Entity *> namedEntities;
 			FlatBag<Entity *> allEntities;
 			uint32 generateId = 0;
 			uint32 entSize = 0;
-			bool linearArena = false;
+
+			EntityManagerImpl(const EntityManagerCreateConfig &config) : config(config) {}
 
 			~EntityManagerImpl()
 			{
-				destroy();
+				purge();
 				components.clear();
 			}
 
@@ -66,12 +68,19 @@ namespace cage
 				}
 				catch (...)
 				{
-					arena->deallocate(ptr);
+					if (!config.linearAllocators)
+						arena->deallocate(ptr);
 					throw;
 				}
 			}
 
-			void desEnt(EntityImpl *e) { arena->destroy<EntityImpl>(e); }
+			void desEnt(EntityImpl *e)
+			{
+				if (config.linearAllocators)
+					e->~EntityImpl();
+				else
+					arena->destroy<EntityImpl>(e);
+			}
 		};
 
 		class ComponentImpl : public EntityComponent
@@ -91,12 +100,19 @@ namespace cage
 				CAGE_ASSERT(typeSize > 0);
 				prototype = systemMemory().createBuffer(typeSize, typeAlignment).cast<void>();
 				detail::memcpy(+prototype, prototype_, typeSize);
-				arena = newMemoryAllocatorPool({ std::max(typeSize, uint32(sizeof(uintPtr))), typeAlignment });
+				if (manager->config.linearAllocators)
+					arena = newMemoryAllocatorLinear({});
+				else
+					arena = newMemoryAllocatorPool({ std::max(typeSize, uint32(sizeof(uintPtr))), typeAlignment });
 			}
 
 			void *newVal() { return arena->allocate(typeSize, typeAlignment); }
 
-			void desVal(void *v) { arena->deallocate(v); }
+			void desVal(void *v)
+			{
+				if (!manager->config.linearAllocators)
+					arena->deallocate(v);
+			}
 		};
 
 		EntityImpl::EntityImpl(EntityManagerImpl *manager, uint32 id) : manager(manager), id(id)
@@ -244,13 +260,11 @@ namespace cage
 	void EntityManager::destroy()
 	{
 		EntityManagerImpl *impl = (EntityManagerImpl *)this;
-		if (impl->linearArena)
-			impl->purge();
-		else
-		{
-			while (!impl->allEntities.empty())
-				impl->allEntities.unsafeData().back()->destroy();
-		}
+		// first call all callbacks
+		while (!impl->allEntities.empty())
+			impl->allEntities.unsafeData().back()->destroy();
+		// second free the memory
+		impl->purge();
 	}
 
 	void EntityManager::purge()
@@ -285,7 +299,10 @@ namespace cage
 		ComponentImpl *c = +h;
 		impl->components.push_back(std::move(h));
 		impl->entSize = sizeof(EntityImpl) + impl->components.size() * sizeof(void *);
-		impl->arena = newMemoryAllocatorPool({ impl->entSize, alignof(EntityImpl) });
+		if (impl->config.linearAllocators)
+			impl->arena = newMemoryAllocatorLinear({});
+		else
+			impl->arena = newMemoryAllocatorPool({ impl->entSize, alignof(EntityImpl) });
 		return c;
 	}
 
@@ -294,9 +311,9 @@ namespace cage
 		return defineComponent_(source->typeIndex(), +((ComponentImpl *)source)->prototype);
 	}
 
-	Holder<EntityManager> newEntityManager()
+	Holder<EntityManager> newEntityManager(const EntityManagerCreateConfig &config)
 	{
-		return systemMemory().createImpl<EntityManager, EntityManagerImpl>();
+		return systemMemory().createImpl<EntityManager, EntityManagerImpl>(config);
 	}
 
 	EntityManager *EntityComponent::manager() const
@@ -437,7 +454,6 @@ namespace cage
 		const EntityManagerImpl *src = (const EntityManagerImpl *)config.source;
 		EntityManagerImpl *dst = (EntityManagerImpl *)config.destination;
 
-		CAGE_ASSERT(!config.linearAllocator || config.purge); // linear arena must purge
 		if (config.purge)
 			dst->purge();
 		else
@@ -446,19 +462,6 @@ namespace cage
 		// must define components before changing the allocators
 		const auto mp = componnentMapping(config);
 
-		CAGE_ASSERT(!dst->linearArena || config.linearAllocator); // cannot take back
-		if (config.linearAllocator && !dst->linearArena)
-		{
-			dst->linearArena = true;
-			for (const auto &it : dst->components)
-			{
-				it->arena.clear();
-				it->arena = newMemoryAllocatorLinear({});
-			}
-			dst->arena.clear();
-			dst->arena = newMemoryAllocatorLinear({});
-		}
-
 		ankerl::unordered_dense::map<Entity *, EntityImpl *> ents; // old -> new
 		ents.reserve(src->count());
 		dst->allEntities.unsafeData().reserve(src->allEntities.size());
@@ -471,7 +474,7 @@ namespace cage
 			dst->allEntities.unsafeData().push_back(n);
 			ents[se] = n;
 		}
-		if (!config.linearAllocator)
+		if (config.rebuildIndices)
 			dst->allEntities.unsafeRebuildIndex();
 		for (Entity *e : dst->allEntities)
 		{
@@ -491,7 +494,7 @@ namespace cage
 				detail::memcpy(de->comp(di) = dc->newVal(), se->comp(si), sz);
 				dc->componentEntities.unsafeData().push_back(de);
 			}
-			if (!config.linearAllocator)
+			if (config.rebuildIndices)
 				dc->componentEntities.unsafeRebuildIndex();
 		}
 	}

sources/libcore/memory/allocators.cpp

@@ -151,14 +151,15 @@ namespace cage
 
 			void addBlock(MemoryBuffer &b)
 			{
-				char *begin = b.data();
-				char *end = b.data() + b.size();
-				char *p = (char *)detail::roundDownTo((uintPtr)end, config.itemAlignment) - config.itemSize;
-				while (p >= begin)
+				char *p = (char *)detail::roundUpTo((uintPtr)b.data(), config.itemAlignment);
+				freeList = p;
+				char *e = b.data() + b.size() - config.itemSize * 2;
+				while (p < e)
 				{
-					deallocate(p);
-					p -= config.itemSize; // form the free list in reverse so that consecutive allocations have increasing addresses
+					*(void **)p = p + config.itemSize;
+					p += config.itemSize;
 				}
+				*(void **)p = nullptr;
 			}
 
 			void newBlock()

sources/libsimple/graphics.cpp

@@ -62,7 +62,7 @@ namespace cage
 
 		struct EmitBuffer : private Immovable
 		{
-			Holder<EntityManager> scene = newEntityManager();
+			Holder<EntityManager> scene = newEntityManager({ .linearAllocators = true });
 			uint64 emitTime = 0;
 		};
 
@@ -192,7 +192,6 @@ namespace cage
 					EntitiesCopyConfig cfg;
 					cfg.source = engineEntities();
 					cfg.destination = +emitBuffers[lock.index()].scene;
-					cfg.linearAllocator = true;
 					entitiesCopy(cfg);
 					emitBuffers[lock.index()].emitTime = emitTime;
 				}