From 6a3de7eeacc21e2a6ccec853a24c9d0917d274e4 Mon Sep 17 00:00:00 2001 From: Jonathan Bradley Date: Tue, 29 Aug 2023 14:15:10 -0400 Subject: move boilerplate bucket code to memory file --- src/asset-manager.cpp | 60 +++++++++++++++++---------------------------------- src/asset-manager.hpp | 2 +- src/memory.cpp | 20 +++++++++++++++++ src/memory.hpp | 18 ++++++++++++++++ 4 files changed, 59 insertions(+), 41 deletions(-) diff --git a/src/asset-manager.cpp b/src/asset-manager.cpp index 37a2a17..dcfde4d 100644 --- a/src/asset-manager.cpp +++ b/src/asset-manager.cpp @@ -2,30 +2,14 @@ #include "asset-manager.hpp" TypeSafeInt_B(AssetHandle); -constexpr AssetHandle_T AssetIndexer_T{1ULL << 32}; -constexpr AssetHandle AssetIndexer{AssetIndexer_T}; -constexpr AssetHandle_T AssetIndexMax_T{63ULL << 32}; -constexpr AssetHandle AssetIndexMax{AssetIndexMax_T}; -constexpr AssetHandle_T AssetBucketMask_T{0x00000000FFFFFFFF}; -constexpr AssetHandle AssetBucketMask{AssetBucketMask_T}; -constexpr AssetHandle_T AssetIndexMask_T{0xFFFFFFFF00000000}; -constexpr AssetHandle AssetIndexMask{AssetIndexMask_T}; - -static inline constexpr AssetHandle_T GetBucketIndex(AssetHandle assetHandle) { - return static_cast(assetHandle & AssetBucketMask); -} -static inline constexpr AssetHandle_T GetAssetIndex(AssetHandle assetHandle) { - AssetHandle_T index = static_cast(assetHandle & AssetIndexMask); - return index >> 32; -} struct AssetBucket { - Asset assets[64]; + Asset assets[256]; }; uint64_t bucketIncrementer = 2; -AssetHandle bucketCounter{0}; -AssetHandle assetCounter{0}; +AssetHandle_T bucketCounter{0}; +AssetHandle_T assetCounter{0}; AssetBucket *assetBuckets = nullptr; void AssetManagerInit() { @@ -33,29 +17,14 @@ void AssetManagerInit() { } AssetHandle RegisterAsset_Inner(const void *src, void *dst, int64_t size, const char *key) { - AssetHandle assetHandle{assetCounter | bucketCounter}; - // update our counters and buckets - { - assetCounter = assetCounter + AssetIndexer; - if (assetCounter > AssetIndexMax) { - assetCounter = AssetHandle{0}; - ++bucketCounter; - } - if (bucketCounter > AssetHandle{bucketIncrementer}) { - int64_t newIncrement = bucketIncrementer * 1.5; - AssetBucket *newBuckets = pke::PkeNew(newIncrement); - memcpy(newBuckets, assetBuckets, sizeof(AssetBucket) * bucketIncrementer); - pke::PkeDelete(assetBuckets, bucketIncrementer); - assetBuckets = newBuckets; - bucketIncrementer = newIncrement; - } - } + AssetHandle_T assetHandle_T{Buckets_NewHandle(256ULL, bucketIncrementer, bucketCounter, assetCounter, assetBuckets)}; + AssetHandle assetHandle{assetHandle_T}; if (src != nullptr) { std::memcpy(dst, src, size); } - Asset *asset = &assetBuckets[GetBucketIndex(assetHandle)].assets[GetAssetIndex(assetHandle)]; + Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)]; asset->ptr = dst; asset->size = size; int64_t keyLen = std::strlen(key); @@ -81,7 +50,8 @@ AssetHandle RegisterAsset(const char *path) { int64_t pathLen = strlen(path); auto assetHandle = RegisterAsset_Inner(nullptr, target, 0, path + (pathLen > 16 ? pathLen - 16 : 0)); - Asset *asset = &assetBuckets[GetBucketIndex(assetHandle)].assets[GetAssetIndex(assetHandle)]; + AssetHandle_T assetHandle_T = static_cast(assetHandle); + Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)]; file.seekg(0); file.read(static_cast(asset->ptr), fileSize); file.close(); @@ -90,12 +60,22 @@ AssetHandle RegisterAsset(const char *path) { } void DestroyAsset(AssetHandle assetHandle) { - Asset *asset = &assetBuckets[GetBucketIndex(assetHandle)].assets[GetAssetIndex(assetHandle)]; + AssetHandle_T assetHandle_T = static_cast(assetHandle); + auto itemIndex = Buckets_GetItemIndex(assetHandle_T); + Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[itemIndex]; pke::PkeDelete(asset->ptr, asset->size); + for (long i = 0; i < 16; ++i) { + asset->key[i] = 0; + } + asset->size = 0; asset->ptr = CAFE_BABE(void); + if (itemIndex == assetCounter - (1ULL << 32)) { + assetCounter -= (1ULL << 32); + } } const Asset *GetAsset(AssetHandle assetHandle) { - return &assetBuckets[GetBucketIndex(assetHandle)].assets[GetAssetIndex(assetHandle)]; + AssetHandle_T assetHandle_T = static_cast(assetHandle); + return &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)]; } diff --git a/src/asset-manager.hpp b/src/asset-manager.hpp index 8a45d48..8064697 100644 --- a/src/asset-manager.hpp +++ b/src/asset-manager.hpp @@ -12,7 +12,7 @@ TypeSafeInt_H(AssetHandle, uint64_t, UINT64_MAX); struct Asset{ - char key[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + char key[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; int64_t size = 0; void *ptr = nullptr; }; diff --git a/src/memory.cpp b/src/memory.cpp index f919770..7670b2f 100644 --- a/src/memory.cpp +++ b/src/memory.cpp @@ -105,3 +105,23 @@ void pke::Flush() { DestroyBucket(&buckets[i + 1]); } } + +uint64_t Buckets_NewHandle(std::size_t bucketBytes, uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, void*& buckets) { + uint64_t newHandle{itemCounter | bucketCounter}; + + itemCounter += uint64_t{1ULL << 32}; + if (itemCounter > uint64_t{(bucketItemCount - 1) << 32}) { + itemCounter = 0ULL; + bucketCounter += 1; + } + if (bucketCounter > bucketIncrementer) { + int64_t newIncrement = bucketIncrementer * 1.5; + char * newBuckets = reinterpret_cast(pke::PkeNew(bucketBytes * newIncrement)); + std::memcpy(newBuckets, buckets, bucketBytes * bucketIncrementer); + pke::PkeDelete(buckets, bucketBytes * bucketIncrementer); + buckets = newBuckets; + bucketIncrementer = newIncrement; + } + + return newHandle; +} diff --git a/src/memory.hpp b/src/memory.hpp index 83ffd8f..74e72a3 100644 --- a/src/memory.hpp +++ b/src/memory.hpp @@ -3,6 +3,7 @@ #include "macros.hpp" +#include #include #include #include @@ -43,4 +44,21 @@ inline void PkeDelete(const void *ptr, long count) { } /* pke */ +uint64_t Buckets_NewHandle(std::size_t bucketBytes, uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, void*& buckets); + +template inline uint64_t Buckets_NewHandle(uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, T*& buckets) { + void *ptr = reinterpret_cast(buckets); + uint64_t handle = Buckets_NewHandle(sizeof(T), bucketItemCount, bucketIncrementer, bucketCounter, itemCounter, ptr); + buckets = reinterpret_cast(ptr); + return handle; +} + +static inline constexpr uint64_t Buckets_GetBucketIndex(uint64_t handle) { + return handle & 0x00000000FFFFFFFF; +} + +static inline constexpr uint64_t Buckets_GetItemIndex(uint64_t handle) { + return handle >> 32; +} + #endif /* PKE_MEMORY_HPP */ -- cgit v1.2.3