summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CMakeLists.txt1
-rw-r--r--src/asset-manager.cpp38
-rw-r--r--src/bucketed-array.hpp52
-rw-r--r--src/camera.cpp23
-rw-r--r--src/ecs.cpp96
-rw-r--r--src/memory.cpp26
-rw-r--r--src/memory.hpp37
-rw-r--r--src/thread_pool.cpp30
8 files changed, 133 insertions, 170 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 454bceb..dbd9787 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -15,6 +15,7 @@ set(PKE_SOURCE_FILES
src/arg-handler.hpp
src/arg-handler.cpp
src/array.hpp
+ src/bucketed-array.hpp
src/camera.hpp
src/camera.cpp
src/components.hpp
diff --git a/src/asset-manager.cpp b/src/asset-manager.cpp
index f652b64..6ff4600 100644
--- a/src/asset-manager.cpp
+++ b/src/asset-manager.cpp
@@ -1,6 +1,7 @@
#include "asset-manager.hpp"
+#include "bucketed-array.hpp"
#include "thread_pool.hpp"
#include <chrono>
@@ -10,11 +11,7 @@
const PkeHandleItemIndex_T maxAssetItemsPerBucket = 64;
-struct AssetBucket {
- Asset assets[maxAssetItemsPerBucket];
-};
-
-BucketContainer<AssetBucket, AssetHandle> Asset_BucketContainer{};
+BucketContainer<Asset, AssetHandle> Asset_BucketContainer{};
ThreadPoolHandle assetThreadPool = ThreadPoolHandle_MAX;
@@ -26,7 +23,7 @@ AssetKey EngineDefinedAssets[EngineDefinedAssetCount] = {
};
void AM_Init() {
- Buckets_Init(Asset_BucketContainer);
+ Buckets_Init(Asset_BucketContainer, maxAssetItemsPerBucket);
assetThreadPool = PkeThreads_Init(2, 255);
AM_Register(EngineDefinedAssets[0], PKE_ASSET_TYPE_SHADER, "assets/shaders/present.vert.spv");
AM_Register(EngineDefinedAssets[1], PKE_ASSET_TYPE_SHADER, "assets/shaders/present.frag.spv");
@@ -57,8 +54,8 @@ inline Asset *AM_Get_Inner(AssetKey key) {
count = maxAssetItemsPerBucket;
}
for (long i = 0; i < count; ++i) {
- if (strncmp(key, Asset_BucketContainer.buckets[b].assets[i].key, 16) == 0) {
- return &Asset_BucketContainer.buckets[b].assets[i];
+ if (strncmp(key, Asset_BucketContainer.buckets[b][i].key, 16) == 0) {
+ return &Asset_BucketContainer.buckets[b][i];
}
}
}
@@ -73,9 +70,8 @@ AssetHandle AM_Register(AssetKey key, AssetType type, const void *data, int64_t
if (searchedAsset != nullptr) {
return searchedAsset->handle;
}
- bool moved;
- AssetHandle assetHandle{Buckets_NewHandle<AssetBucket>(maxAssetItemsPerBucket, Asset_BucketContainer, moved)};
- Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
+ AssetHandle assetHandle{Buckets_NewHandle(Asset_BucketContainer)};
+ Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex][assetHandle.itemIndex];
new (&asset) Asset{};
asset.handle = assetHandle;
strncpy(asset.key, key, AssetKeyLength);
@@ -93,9 +89,8 @@ AssetHandle AM_Register(AssetKey key, AssetType type, const char *path) {
if (searchedAsset != nullptr) {
return searchedAsset->handle;
}
- bool moved = false;
- AssetHandle assetHandle{Buckets_NewHandle<AssetBucket>(maxAssetItemsPerBucket, Asset_BucketContainer, moved)};
- Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
+ AssetHandle assetHandle{Buckets_NewHandle(Asset_BucketContainer)};
+ Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex][assetHandle.itemIndex];
new (&asset) Asset{};
asset.handle = assetHandle;
strncpy(asset.key, key, AssetKeyLength);
@@ -126,9 +121,8 @@ AssetHandle AM_Register(const char *path, AssetType type) {
return searchedAsset->handle;
}
- bool moved = false;
- AssetHandle assetHandle{Buckets_NewHandle<AssetBucket>(maxAssetItemsPerBucket, Asset_BucketContainer, moved)};
- Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
+ AssetHandle assetHandle{Buckets_NewHandle(Asset_BucketContainer)};
+ Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex][assetHandle.itemIndex];
new (&asset) Asset{};
asset.handle = assetHandle;
strncpy(asset.key, assetKey, AssetKeyLength);
@@ -149,7 +143,7 @@ AssetHandle AM_Register(const char *path, AssetType type) {
void AM_Release(AssetHandle assetHandle) {
assert(assetHandle != AssetHandle_MAX);
- Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
+ Asset &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex][assetHandle.itemIndex];
asset.referenceCount -= 1;
assert(asset.referenceCount >= 0 && "asset was unloaded more times than it was retrieved");
}
@@ -157,7 +151,7 @@ void AM_Release(AssetHandle assetHandle) {
const Asset *AM_Get(AssetHandle assetHandle) {
auto validationResult = ValidateHandle(assetHandle, Asset_BucketContainer.pkeHandle, maxAssetItemsPerBucket);
assert(validationResult == 0);
- auto &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex].assets[assetHandle.itemIndex];
+ auto &asset = Asset_BucketContainer.buckets[assetHandle.bucketIndex][assetHandle.itemIndex];
if (asset.state == PKE_ASSET_LOADING_STATE_LOADED) {
asset.referenceCount += 1;
return &asset;
@@ -207,7 +201,7 @@ Asset *AM_GetAssets(uint64_t bucketIndex, uint64_t &itemCount) {
} else {
itemCount = maxAssetItemsPerBucket;
}
- return Asset_BucketContainer.buckets[bucketIndex].assets;
+ return Asset_BucketContainer.buckets[bucketIndex];
}
void AM_DebugPrint() {
@@ -216,7 +210,7 @@ void AM_DebugPrint() {
auto &bkt = Asset_BucketContainer.buckets[b];
uint64_t counter = b == Asset_BucketContainer.pkeHandle.bucketIndex ? Asset_BucketContainer.pkeHandle.itemIndex : maxAssetItemsPerBucket;
for (uint64_t i = 0; i < counter; ++i) {
- auto &asset = bkt.assets[i];
+ auto &asset = bkt[i];
/*
if (asset.size == 0)
continue;
@@ -240,7 +234,7 @@ void AM_DebugPrint() {
void AM_GC() {
for (long b = 0; b <= Asset_BucketContainer.pkeHandle.bucketIndex; ++b) {
for (long i = 0; i < Asset_BucketContainer.pkeHandle.itemIndex; ++i) {
- Asset &asset = Asset_BucketContainer.buckets[b].assets[i];
+ Asset &asset = Asset_BucketContainer.buckets[b][i];
if (asset.referenceCount > 0)
continue;
if (asset.ptr != nullptr && asset.ptr != CAFE_BABE(void)) {
diff --git a/src/bucketed-array.hpp b/src/bucketed-array.hpp
new file mode 100644
index 0000000..5813ca6
--- /dev/null
+++ b/src/bucketed-array.hpp
@@ -0,0 +1,52 @@
+#ifndef PKE_BUCKETED_ARRAY_HPP
+#define PKE_BUCKETED_ARRAY_HPP
+
+#include <cstddef>
+
+#include "memory.hpp"
+
+constexpr PkeHandleBucketIndex_T BucketContainerDefaultBucketCount = 16;
+constexpr PkeHandleItemIndex_T BucketContainerDefaultItemCount = 256;
+
+template<typename T, typename CT = PkeHandle, PkeHandleBucketIndex_T BKT_CNT = BucketContainerDefaultBucketCount>
+struct BucketContainer {
+ CT limits;
+ CT pkeHandle;
+ T* buckets[BKT_CNT];
+};
+
+template<typename T, typename CT, PkeHandleBucketIndex_T BKT_CNT>
+void Buckets_Init(BucketContainer<T, CT, BKT_CNT> &bktContainer, size_t maxItemCount = BucketContainerDefaultItemCount) {
+ bktContainer.limits.bucketIndex = BKT_CNT;
+ bktContainer.limits.itemIndex = maxItemCount;
+ bktContainer.pkeHandle.hash = 0;
+ for (PkeHandleBucketIndex_T i = 0; i < BKT_CNT; ++i) {
+ bktContainer.buckets[i] = nullptr;
+ }
+ bktContainer.buckets[0] = Pke_New<T>(maxItemCount);
+}
+
+template<typename T, typename CT, PkeHandleBucketIndex_T BKT_CNT>
+inline CT Buckets_NewHandle(BucketContainer<T, CT, BKT_CNT> &bktContainer) {
+ CT returnValue = bktContainer.pkeHandle;
+ bktContainer.pkeHandle.itemIndex += 1;
+ if (bktContainer.pkeHandle.itemIndex >= bktContainer.limits.itemIndex) {
+ bktContainer.pkeHandle.itemIndex = 0;
+ bktContainer.pkeHandle.bucketIndex += 1;
+ assert(bktContainer.pkeHandle.bucketIndex < bktContainer.limits.bucketIndex);
+ }
+ if (bktContainer.pkeHandle.itemIndex == 0) {
+ bktContainer.buckets[bktContainer.pkeHandle.bucketIndex] = Pke_New<T>(bktContainer.limits.itemIndex);
+ }
+ return returnValue;
+}
+
+template<typename T, typename CT, PkeHandleBucketIndex_T BKT_CNT>
+static inline constexpr void Buckets_Destroy(BucketContainer<T, CT, BKT_CNT> &bktContainer) {
+ for (PkeHandleBucketIndex_T i = 0; i < BKT_CNT; ++i) {
+ Pke_Delete<T>(bktContainer.buckets[i], bktContainer.limits.itemIndex);
+ bktContainer.buckets[i] = CAFE_BABE(T);
+ }
+}
+
+#endif /* PKE_BUCKETED_ARRAY_HPP */
diff --git a/src/camera.cpp b/src/camera.cpp
index 4e8af3d..c7a861c 100644
--- a/src/camera.cpp
+++ b/src/camera.cpp
@@ -1,4 +1,5 @@
+#include "bucketed-array.hpp"
#include "camera.hpp"
#include "memory.hpp"
@@ -14,31 +15,23 @@ PkeCamera NullCamera {
PkeCamera *ActiveCamera = &NullCamera;
const PkeHandleItemIndex_T MAX_CAMERAS_PER_BUCKET = 32;
-struct CameraBucket {
- PkeCamera cameras[MAX_CAMERAS_PER_BUCKET];
-};
-BucketContainer<CameraBucket, CameraHandle> Camera_BucketContainer{};
+BucketContainer<PkeCamera, CameraHandle> Camera_BucketContainer{};
PkeCamera &PkeCamera_Register() {
- bool moved = false;
- CameraHandle activeHandle = ActiveCamera->handle;
- CameraHandle cameraHandle{Buckets_NewHandle<CameraBucket>(MAX_CAMERAS_PER_BUCKET, Camera_BucketContainer, moved)};
- if (moved && activeHandle != CameraHandle_MAX) {
- ActiveCamera = PkeCamera_Get(activeHandle);
- }
- auto &cam = Camera_BucketContainer.buckets[cameraHandle.bucketIndex].cameras[cameraHandle.itemIndex];
+ CameraHandle cameraHandle{Buckets_NewHandle(Camera_BucketContainer)};
+ auto &cam = Camera_BucketContainer.buckets[cameraHandle.bucketIndex][cameraHandle.itemIndex];
cam.handle = cameraHandle;
return cam;
}
PkeCamera *PkeCamera_Get(CameraHandle cameraHandle) {
assert(cameraHandle != CameraHandle_MAX);
- return &Camera_BucketContainer.buckets[cameraHandle.bucketIndex].cameras[cameraHandle.itemIndex];
+ return &Camera_BucketContainer.buckets[cameraHandle.bucketIndex][cameraHandle.itemIndex];
}
void PkeCamera_Destroy(CameraHandle cameraHandle) {
assert(cameraHandle != CameraHandle_MAX);
- auto &cam = Camera_BucketContainer.buckets[cameraHandle.bucketIndex].cameras[cameraHandle.itemIndex];
+ auto &cam = Camera_BucketContainer.buckets[cameraHandle.bucketIndex][cameraHandle.itemIndex];
cam.handle = CameraHandle_MAX;
cam.pos = glm::vec3(0);
cam.rot = glm::quat{};
@@ -58,11 +51,11 @@ PkeCamera *PkeCamera_GetCameras(int64_t bucketIndex, int64_t &count) {
} else {
count = MAX_CAMERAS_PER_BUCKET;
}
- return Camera_BucketContainer.buckets[bucketIndex].cameras;
+ return Camera_BucketContainer.buckets[bucketIndex];
}
void PkeCamera_Init() {
- Buckets_Init(Camera_BucketContainer);
+ Buckets_Init(Camera_BucketContainer, MAX_CAMERAS_PER_BUCKET);
}
void PkeCamera_Teardown() {
diff --git a/src/ecs.cpp b/src/ecs.cpp
index 34eb701..1e62988 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -1,6 +1,7 @@
#include "ecs.hpp"
+#include "bucketed-array.hpp"
#include "game-settings.hpp"
#include "math-helpers.hpp"
#include "memory.hpp"
@@ -12,17 +13,7 @@
#include <BulletCollision/CollisionShapes/btConvexHullShape.h>
#include <glm/gtc/type_ptr.hpp>
-const PkeHandleItemIndex_T maxBucketItemCount = 256;
-
-struct EntityBucket {
- Entity entities[maxBucketItemCount];
-};
-struct GrBindsBucket {
- CompGrBinds compGrBinds[maxBucketItemCount];
-};
-struct InstanceBucket {
- CompInstance instances[maxBucketItemCount];
-};
+constexpr PkeHandleItemIndex_T maxBucketItemCount = 256;
/*
* Entities that have been marked for removal by calling ECS_MarkForRemoval
@@ -47,19 +38,19 @@ DynArray<Entity> entitiesYetToBeRemoved{0, nullptr};
DynArray<EntityHandle> EntitiesWithExcessInstances{16};
-BucketContainer<EntityBucket, EntityHandle> Entities_BucketContainer{};
-BucketContainer<GrBindsBucket, GrBindsHandle> Comp_GrBinds_BucketContainer{};
-BucketContainer<InstanceBucket, InstanceHandle> Comp_Instance_BucketContainer{};
+BucketContainer<Entity, EntityHandle> Entities_BucketContainer{};
+BucketContainer<CompGrBinds, GrBindsHandle> Comp_GrBinds_BucketContainer{};
+BucketContainer<CompInstance, InstanceHandle> Comp_Instance_BucketContainer{};
void ECS_GetEntity_Inner(EntityHandle entHandle, Entity*& ent) {
assert(entHandle != EntityHandle_MAX && "Unknown entity handle");
- ent = &Entities_BucketContainer.buckets[entHandle.bucketIndex].entities[entHandle.itemIndex];
+ ent = &Entities_BucketContainer.buckets[entHandle.bucketIndex][entHandle.itemIndex];
}
void ECS_Init() {
- Buckets_Init(Entities_BucketContainer);
- Buckets_Init(Comp_GrBinds_BucketContainer);
- Buckets_Init(Comp_Instance_BucketContainer);
+ Buckets_Init(Entities_BucketContainer, maxBucketItemCount);
+ Buckets_Init(Comp_GrBinds_BucketContainer, maxBucketItemCount);
+ Buckets_Init(Comp_Instance_BucketContainer, maxBucketItemCount);
}
uint64_t ECS_GetEntities_BucketCount() {
@@ -68,14 +59,13 @@ uint64_t ECS_GetEntities_BucketCount() {
Entity *ECS_GetEntities(uint64_t bucketIndex, uint64_t &itemCount) {
assert(bucketIndex <= Entities_BucketContainer.pkeHandle.bucketIndex);
itemCount = bucketIndex == Entities_BucketContainer.pkeHandle.bucketIndex ? Entities_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
- return Entities_BucketContainer.buckets[bucketIndex].entities;
+ return Entities_BucketContainer.buckets[bucketIndex];
}
EntityHandle ECS_CreateEntity_Inner(EntityHandle parentEntHandle) {
- bool moved;
- EntityHandle entityHandle{Buckets_NewHandle<EntityBucket>(maxBucketItemCount, Entities_BucketContainer, moved)};
+ EntityHandle entityHandle{Buckets_NewHandle<Entity>(Entities_BucketContainer)};
- Entity *entity = &Entities_BucketContainer.buckets[entityHandle.bucketIndex].entities[entityHandle.itemIndex];
+ Entity *entity = &Entities_BucketContainer.buckets[entityHandle.bucketIndex][entityHandle.itemIndex];
entity = new (entity) Entity{};
entity->handle = entityHandle;
entity->parentHandle = parentEntHandle;
@@ -88,7 +78,7 @@ EntityHandle ECS_CreateEntity(EntityHandle parentEntHandle) {
}
void ECS_MarkForRemoval(EntityHandle entityHandle) {
- const Entity *ent = &Entities_BucketContainer.buckets[entityHandle.bucketIndex].entities[entityHandle.itemIndex];
+ const Entity *ent = &Entities_BucketContainer.buckets[entityHandle.bucketIndex][entityHandle.itemIndex];
assert(ent->isMarkedForRemoval == false && "Entity already marked for removal");
entitiesMarkedForRemoval.Push(entityHandle);
}
@@ -102,7 +92,7 @@ void ECS_Tick_Early(double delta) {
for (long b = 0; b <= Entities_BucketContainer.pkeHandle.bucketIndex; ++b) {
uint64_t entCount = b == Entities_BucketContainer.pkeHandle.bucketIndex ? Entities_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
for (long e = 0; e < entCount; ++e) {
- Entity *ent = &Entities_BucketContainer.buckets[b].entities[e];
+ Entity *ent = &Entities_BucketContainer.buckets[b][e];
if (ent->handle == EntityHandle_MAX) continue;
if (ent->isMarkedForRemoval) {
entitiesYetToBeRemoved.Push(*ent);
@@ -120,19 +110,19 @@ void ECS_Tick_Early(double delta) {
for (long e = 0; e < entitiesYetToBeRemoved.Count(); ++e) {
Entity &clonedEnt = entitiesYetToBeRemoved[e];
CompGrBinds *grBinds = nullptr;
- InstanceBucket *instBucket = nullptr;
+ CompInstance *instBucket = nullptr;
CompInstance *inst = nullptr;
uint64_t instBucketIndex = 0;
if (clonedEnt.instanceHandle != InstanceHandle_MAX) {
instBucketIndex = clonedEnt.instanceHandle.bucketIndex;
- instBucket = &Comp_Instance_BucketContainer.buckets[instBucketIndex];
- inst = &instBucket->instances[clonedEnt.instanceHandle.itemIndex];
+ instBucket = Comp_Instance_BucketContainer.buckets[instBucketIndex];
+ inst = &instBucket[clonedEnt.instanceHandle.itemIndex];
if (inst->grBindsHandle != GrBindsHandle_MAX) {
- grBinds = &Comp_GrBinds_BucketContainer.buckets[inst->grBindsHandle.bucketIndex].compGrBinds[inst->grBindsHandle.itemIndex];
+ grBinds = &Comp_GrBinds_BucketContainer.buckets[inst->grBindsHandle.bucketIndex][inst->grBindsHandle.itemIndex];
}
}
if (grBinds == nullptr && clonedEnt.grBindsHandle != GrBindsHandle_MAX) {
- grBinds = &Comp_GrBinds_BucketContainer.buckets[clonedEnt.grBindsHandle.bucketIndex].compGrBinds[clonedEnt.grBindsHandle.itemIndex];
+ grBinds = &Comp_GrBinds_BucketContainer.buckets[clonedEnt.grBindsHandle.bucketIndex][clonedEnt.grBindsHandle.itemIndex];
}
if (inst != nullptr) {
assert(grBinds != nullptr);
@@ -145,17 +135,17 @@ void ECS_Tick_Early(double delta) {
}
auto &bucket = Comp_Instance_BucketContainer.buckets[bi];
for (long ii = 0; ii < instCounter; ++ii) {
- if (bucket.instances[ii].entHandle == EntityHandle_MAX) {
+ if (bucket[ii].entHandle == EntityHandle_MAX) {
continue;
}
- if (bucket.instances[ii].grBindsHandle != inst->grBindsHandle) {
+ if (bucket[ii].grBindsHandle != inst->grBindsHandle) {
continue;
}
- if (bucket.instances[ii].instanceHandle.itemIndex < clonedEnt.instanceHandle.itemIndex) {
+ if (bucket[ii].instanceHandle.itemIndex < clonedEnt.instanceHandle.itemIndex) {
continue;
}
- bucket.instances[ii].index -= 1;
- bucket.instances[ii].isNeedingUpdated = true;
+ bucket[ii].index -= 1;
+ bucket[ii].isNeedingUpdated = true;
}
}
grBinds->instanceCounter -= 1;
@@ -192,7 +182,7 @@ void ECS_Tick(double delta) {
auto &bkt = Comp_Instance_BucketContainer.buckets[b];
long count = Comp_Instance_BucketContainer.pkeHandle.bucketIndex == b ? Comp_Instance_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
for (uint32_t i = 0; i < count; ++i) {
- auto &inst = bkt.instances[i];
+ auto &inst = bkt[i];
if (inst.entHandle == EntityHandle_MAX)
continue;
auto activationState = inst.bt.rigidBody->getActivationState();
@@ -225,13 +215,13 @@ void ECS_Tick_Late(double delta) {
auto &bkt = Comp_Instance_BucketContainer.buckets[b];
long count = Comp_Instance_BucketContainer.pkeHandle.bucketIndex == b ? Comp_Instance_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
for (uint32_t i = 0; i < count; ++i) {
- auto &inst = bkt.instances[i];
+ auto &inst = bkt[i];
if (inst.isNeedingUpdated == false)
continue;
if (inst.entHandle == EntityHandle_MAX)
continue;
- auto &grBinds = Comp_GrBinds_BucketContainer.buckets[inst.grBindsHandle.bucketIndex].compGrBinds[inst.grBindsHandle.itemIndex];
+ auto &grBinds = Comp_GrBinds_BucketContainer.buckets[inst.grBindsHandle.bucketIndex][inst.grBindsHandle.itemIndex];
InstanceBufferCopy *bfrUpdate = nullptr;
for (long u = 0; u < bufferUpdates.Count(); ++u) {
@@ -340,12 +330,12 @@ void FindComponents(EntityHandle handle, Entity *&ent, CompInstance *&compInst,
return;
GrBindsHandle grBindsHandle = ent->grBindsHandle;
if (ent->instanceHandle != InstanceHandle_MAX) {
- compInst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];
+ compInst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex][ent->instanceHandle.itemIndex];
if (grBindsHandle == GrBindsHandle_MAX)
grBindsHandle = compInst->grBindsHandle;
}
if (grBindsHandle != GrBindsHandle_MAX) {
- grBinds = &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex].compGrBinds[grBindsHandle.itemIndex];
+ grBinds = &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex][grBindsHandle.itemIndex];
}
}
@@ -393,9 +383,8 @@ CompGrBinds &ECS_CreateGrBinds(EntityHandle entHandle) {
assert(ent->grBindsHandle == GrBindsHandle_MAX);
- bool moved;
- ent->grBindsHandle = Buckets_NewHandle(maxBucketItemCount, Comp_GrBinds_BucketContainer, moved);
- auto *comp = &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex].compGrBinds[ent->grBindsHandle.itemIndex];
+ ent->grBindsHandle = Buckets_NewHandle(Comp_GrBinds_BucketContainer);
+ auto *comp = &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex][ent->grBindsHandle.itemIndex];
comp = new (comp) CompGrBinds{};
comp->entHandle = entHandle;
comp->grBindsHandle = ent->grBindsHandle;
@@ -406,11 +395,11 @@ CompGrBinds *ECS_GetGrBinds(EntityHandle entHandle) {
Entity *ent = nullptr;
ECS_GetEntity_Inner(entHandle, ent);
if (ent->grBindsHandle == GrBindsHandle_MAX) return nullptr;
- return &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex].compGrBinds[ent->grBindsHandle.itemIndex];
+ return &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex][ent->grBindsHandle.itemIndex];
}
CompGrBinds *ECS_GetGrBinds(GrBindsHandle grBindsHandle) {
if (grBindsHandle == GrBindsHandle_MAX) return nullptr;
- return &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex].compGrBinds[grBindsHandle.itemIndex];
+ return &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex][grBindsHandle.itemIndex];
}
uint64_t ECS_GetGrBinds_BucketCount() {
@@ -423,7 +412,7 @@ CompGrBinds *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount) {
} else {
itemCount = maxBucketItemCount;
}
- return Comp_GrBinds_BucketContainer.buckets[bucketIndex].compGrBinds;
+ return Comp_GrBinds_BucketContainer.buckets[bucketIndex];
}
CompInstance &ECS_CreateInstance(EntityHandle entHandle, EntityHandle entityTypeEntityHandle) {
@@ -438,15 +427,14 @@ CompInstance &ECS_CreateInstance(EntityHandle entHandle, EntityHandle entityType
assert(ent->grBindsHandle == GrBindsHandle_MAX);
assert(entTypeEnt->grBindsHandle != GrBindsHandle_MAX);
- bool moved;
- ent->instanceHandle = Buckets_NewHandle(maxBucketItemCount, Comp_Instance_BucketContainer, moved);
+ ent->instanceHandle = Buckets_NewHandle(Comp_Instance_BucketContainer);
- auto *instBkt = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex];
- auto *comp = &instBkt->instances[ent->instanceHandle.itemIndex];
- comp = new (comp) CompInstance{};
+ auto *instBkt = Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex];
+ auto *comp = &instBkt[ent->instanceHandle.itemIndex];
+ new (comp) CompInstance{};
comp->entHandle = entHandle;
- auto *grBinds = &Comp_GrBinds_BucketContainer.buckets[entTypeEnt->grBindsHandle.bucketIndex].compGrBinds[entTypeEnt->grBindsHandle.itemIndex];
+ auto *grBinds = &Comp_GrBinds_BucketContainer.buckets[entTypeEnt->grBindsHandle.bucketIndex][entTypeEnt->grBindsHandle.itemIndex];
comp->grBindsHandle = grBinds->grBindsHandle;
comp->instanceHandle = ent->instanceHandle;
@@ -467,7 +455,7 @@ CompInstance *ECS_GetInstance(EntityHandle entHandle) {
if (ent->instanceHandle == InstanceHandle_MAX)
return nullptr;
- auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];
+ auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex][ent->instanceHandle.itemIndex];
return inst;
}
@@ -479,7 +467,7 @@ void ECS_UpdateInstance(EntityHandle entHandle, const InstPos &instPos, bool ove
if (ent->instanceHandle == InstanceHandle_MAX)
return;
- auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];
+ auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex][ent->instanceHandle.itemIndex];
if (BtDynamicsWorld && overridePhysics) {
btVector3 localInertia(0, 0, 0);
@@ -505,7 +493,7 @@ CompInstance *ECS_GetInstances(uint64_t bucketIndex, uint64_t &itemCount) {
} else {
itemCount = maxBucketItemCount;
}
- return Comp_Instance_BucketContainer.buckets[bucketIndex].instances;
+ return Comp_Instance_BucketContainer.buckets[bucketIndex];
}
void ECS_Teardown() {
diff --git a/src/memory.cpp b/src/memory.cpp
index ce2fe00..8fcc121 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -355,32 +355,6 @@ void Pke_MemoryFlush() {
}
}
-PkeHandle Buckets_NewHandle(std::size_t bucketBytes, std::size_t alignment, PkeHandleItemIndex_T bucketItemCount, PkeHandleBucketIndex_T &bucketIncrementer, PkeHandleBucketIndex_T &bucketCounter, PkeHandleItemIndex_T &itemCounter, void*& buckets, bool &moved) {
- moved = false;
- PkeHandle returnValue {
- .bucketIndex = bucketCounter,
- .itemIndex = itemCounter,
- };
-
- itemCounter += 1;
- if (itemCounter >= bucketItemCount) {
- itemCounter = 0ULL;
- bucketCounter += 1;
- }
- if (bucketCounter >= bucketIncrementer) {
- std::size_t calculatedAlignment = alignment < MINIMUM_ALIGNMENT ? MINIMUM_ALIGNMENT : alignment;
- moved = true;
- int64_t newIncrement = bucketIncrementer * 1.5;
- char * newBuckets = reinterpret_cast<char *>(Pke_New(bucketBytes * newIncrement, calculatedAlignment));
- std::memcpy(newBuckets, buckets, bucketBytes * bucketIncrementer);
- Pke_Delete(buckets, bucketBytes * bucketIncrementer);
- buckets = newBuckets;
- bucketIncrementer = newIncrement;
- }
-
- return returnValue;
-}
-
void Pke_DebugPrint() {
printf("Memory Manager printout:\nBucket count: %li\n", bucketHead);
for (long i = 0; i < bucketHead; ++i) {
diff --git a/src/memory.hpp b/src/memory.hpp
index c2fc3bb..fe63318 100644
--- a/src/memory.hpp
+++ b/src/memory.hpp
@@ -17,13 +17,6 @@
extern const std::size_t MINIMUM_ALIGNMENT;
extern const std::size_t MAXIMUM_ALIGNMENT;
-template<typename T, typename CT>
-struct BucketContainer {
- PkeHandleBucketIndex_T incrementer = 2;
- CT pkeHandle;
- T *buckets = nullptr;
-};
-
void *Pke_New(std::size_t sz, std::size_t alignment);
void *Pke_New(std::size_t sz, std::size_t alignment, MemBucket *bkt);
void Pke_Delete(const void *ptr, std::size_t sz);
@@ -89,34 +82,4 @@ inline void Pke_Delete(const void *ptr, long count, MemBucket *bucket = nullptr)
}
}
-
-template <typename T, typename CT>
-void Buckets_Init(BucketContainer<T, CT> &bktContainer) {
- assert(bktContainer.buckets == nullptr && "bucket container already initialized");
- bktContainer.pkeHandle.hash = 0;
- bktContainer.buckets = Pke_New<T>(bktContainer.incrementer);
-}
-
-PkeHandle Buckets_NewHandle(std::size_t bucketBytes, std::size_t alignment, PkeHandleItemIndex_T bucketItemCount, PkeHandleBucketIndex_T &bucketIncrementer, PkeHandleBucketIndex_T &bucketCounter, PkeHandleItemIndex_T &itemCounter, void*& buckets, bool &moved);
-template <typename T> inline PkeHandle Buckets_NewHandle(PkeHandleItemIndex_T bucketItemCount, PkeHandleBucketIndex_T &bucketIncrementer, PkeHandleBucketIndex_T &bucketCounter, PkeHandleItemIndex_T &itemCounter, T*& buckets, bool &moved) {
- void *ptr = reinterpret_cast<void *>(buckets);
- PkeHandle handle = Buckets_NewHandle(sizeof(T), alignof(T), bucketItemCount, bucketIncrementer, bucketCounter, itemCounter, ptr, moved);
- buckets = reinterpret_cast<T *>(ptr);
- return handle;
-}
-
-template <typename T, typename CT = PkeHandle>
-inline CT Buckets_NewHandle(PkeHandleItemIndex_T maxBucketItemCount, BucketContainer<T, CT> &bktContainer, bool &moved) {
- CT returnValue{};
- returnValue.hash = Buckets_NewHandle<T>(maxBucketItemCount, bktContainer.incrementer, bktContainer.pkeHandle.bucketIndex, bktContainer.pkeHandle.itemIndex, bktContainer.buckets, moved).hash;
- return returnValue;
-}
-
-template <typename T, typename CT>
-static inline constexpr void Buckets_Destroy(BucketContainer<T, CT> &bktContainer) {
- if (bktContainer.buckets == nullptr || bktContainer.buckets == CAFE_BABE(T)) return;
- Pke_Delete<T>(bktContainer.buckets, bktContainer.pkeHandle.bucketIndex + 1);
- bktContainer.buckets = CAFE_BABE(T);
-}
-
#endif /* PKE_MEMORY_HPP */
diff --git a/src/thread_pool.cpp b/src/thread_pool.cpp
index 050db20..4a67054 100644
--- a/src/thread_pool.cpp
+++ b/src/thread_pool.cpp
@@ -1,6 +1,8 @@
#include "thread_pool.hpp"
+#include "bucketed-array.hpp"
+
#include <functional>
#include <future>
@@ -17,11 +19,8 @@ struct ThreadPool {
};
const PkeHandleItemIndex_T MAX_THREADS_PER_BUCKET = 8;
-struct ThreadBucket {
- ThreadPool threadPools[MAX_THREADS_PER_BUCKET];
-};
-BucketContainer<ThreadBucket, ThreadPoolHandle> ThreadPool_BucketContainer{};
+BucketContainer<ThreadPool, ThreadPoolHandle> ThreadPool_BucketContainer{};
void ThreadRun(ThreadPool *tp) {
std::packaged_task<void()> *j = nullptr;
@@ -126,14 +125,13 @@ void inline PkeThreads_Shutdown_Inner(ThreadPool &tp) {
}
ThreadPoolHandle PkeThreads_Init(uint8_t threadCount, uint8_t maxQueueCount, MemBucket *bkt) {
- if (!ThreadPool_BucketContainer.buckets) {
- Buckets_Init(ThreadPool_BucketContainer);
+ if (ThreadPool_BucketContainer.pkeHandle.hash == 0) {
+ Buckets_Init(ThreadPool_BucketContainer, MAX_THREADS_PER_BUCKET);
}
assert(threadCount > 0);
- bool moved;
- ThreadPoolHandle newHandle{Buckets_NewHandle(255, ThreadPool_BucketContainer, moved)};
+ ThreadPoolHandle newHandle{Buckets_NewHandle(ThreadPool_BucketContainer)};
- auto *tp = &ThreadPool_BucketContainer.buckets[newHandle.bucketIndex].threadPools[newHandle.itemIndex];
+ auto *tp = &ThreadPool_BucketContainer.buckets[newHandle.bucketIndex][newHandle.itemIndex];
tp->bkt = bkt;
tp->isRunning = true;
@@ -153,13 +151,13 @@ ThreadPoolHandle PkeThreads_Init(uint8_t threadCount, uint8_t maxQueueCount, Mem
void PkeThreads_Reset(ThreadPoolHandle handle) {
assert(handle != ThreadPoolHandle_MAX);
- auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
+ auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex][handle.itemIndex];
PkeThreads_Reset_Inner(*tp);
}
bool PkeThreads_Enqueue(ThreadPoolHandle handle, std::packaged_task<void()> *job) {
assert(handle != ThreadPoolHandle_MAX);
- auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
+ auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex][handle.itemIndex];
if (tp->bkt != nullptr) {
/* 2023-12-22 JCB
* Note that if this becomes an issue we can change it.
@@ -173,27 +171,27 @@ bool PkeThreads_Enqueue(ThreadPoolHandle handle, std::packaged_task<void()> *job
}
int64_t PkeThreads_GetQueueCount (ThreadPoolHandle handle) {
- auto &threadPool = ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
+ auto &threadPool = ThreadPool_BucketContainer.buckets[handle.bucketIndex][handle.itemIndex];
return threadPool.jobQueue->Count();
}
void PkeThreads_Pause(ThreadPoolHandle handle) {
assert(handle != ThreadPoolHandle_MAX);
- auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
+ auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex][handle.itemIndex];
PkeThreads_Pause_Inner(*tp);
}
void PkeThreads_Resume(ThreadPoolHandle handle) {
assert(handle != ThreadPoolHandle_MAX);
- auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
+ auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex][handle.itemIndex];
PkeThreads_Resume_Inner(*tp);
}
void PkeThreads_Shutdown(ThreadPoolHandle handle) {
assert(handle != ThreadPoolHandle_MAX);
- auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
+ auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex][handle.itemIndex];
PkeThreads_Shutdown_Inner(*tp);
PkeThreads_JoinAll_Inner(*tp);
@@ -201,7 +199,7 @@ void PkeThreads_Shutdown(ThreadPoolHandle handle) {
void PkeThreads_Teardown(ThreadPoolHandle handle) {
assert(handle != ThreadPoolHandle_MAX);
- auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex].threadPools[handle.itemIndex];
+ auto *tp = &ThreadPool_BucketContainer.buckets[handle.bucketIndex][handle.itemIndex];
PkeThreads_Shutdown_Inner(*tp);
PkeThreads_JoinAll_Inner(*tp);
generated by cgit v1.2.3 (git 2.39.1) at 2026-01-08 02:05:45 +0000