diff --git a/AgentData/StdlibAndCMigrationAnalysis.md b/AgentData/StdlibAndCMigrationAnalysis.md new file mode 100644 index 0000000..1bac691 --- /dev/null +++ b/AgentData/StdlibAndCMigrationAnalysis.md @@ -0,0 +1,92 @@ +# Workload Analysis: Removing C++ Stdlib & Migrating to Pure C + +This analysis outlines the required workload, technical impact, and migration strategy for: +1. Removing all standard C++ library dependencies (`std::*`) from the Juliet codebase. +2. Moving completely from C++ to pure C. + +--- + +## 1. Scope Overview + +The repository consists of multiple sub-projects (**Juliet Core Engine**, **JulietApp**, **Game**, **Romeo**, and **External dependencies**). Eliminating stdlib dependencies versus migrating completely to pure C represent two distinct milestones: + +| Metric / Domain | Task 1: Eliminate C++ stdlib | Task 2: Pure C Migration | +| :--- | :--- | :--- | +| **Language Target** | C++20 (without standard libraries) | Pure C (C11 / C99 standard) | +| **Containers & Math** | Custom templates (`Vector`, `HashTable`, custom algorithms) | C structs + `void*` / macro templates + explicit functions | +| **Threading & Sync** | Win32 / OS APIs directly (`CreateThread`, `SRWLOCK`) | Native OS APIs (`CreateThread`, `SRWLOCK`, atomic primitives) | +| **External Third-Party** | Native Direct3D 12, ImGui | `cimgui` (C bindings), DirectX C COM interfaces (`ID3D12Device*`) | +| **OOP & Templates** | Kept intact | Struct-based vtables, no function overloading, no references (`&`) | + +--- + +## 2. Phase 1: Removing C++ stdlib Dependencies + +### A. Containers & Utility Replacement +- **Current Usages**: ``, ``, ``, ``, ``, ``, ``, ``, ``. +- **Workload**: + 1. **Containers**: Replace container implementations (such as `Juliet/include/Core/Container/Vector.h`, which currently includes ``) with custom dynamically resizing arrays / buffer allocators backed by `MemoryArena`. + 2. **Type Traits & Concepts**: Replace `` and `` usage in files like `Game/Entity/Entity.h` with compiler intrinsics (e.g. `__is_enum`, `__is_base_of`) or internal lightweight trait structures. + 3. **Algorithms & Math Utilities**: Implement custom `Min`, `Max`, `Clamp`, `Sort`, and `Swap` functions in `CoreUtils.h` or custom inline header helpers. + +### B. Threading & Synchronization +- **Current Usages**: ``, ``, `std::thread`, `std::mutex`, `std::lock_guard`. +- **Workload**: + 1. Replace `` in `Thread.h` and `Romeo/src/main.cpp` with platform abstraction wrappers using Win32 `CreateThread` / `CloseHandle`. + 2. Replace `` in `Mutex.h` with `SRWLOCK` or `CRITICAL_SECTION`. + +### C. Time & File I/O +- **Current Usages**: ``, ``, ``, ``, ``, ``. +- **Workload**: + 1. Replace `` in `LogManager.cpp` and `SystemEvent.cpp` with `QueryPerformanceCounter` / `QueryPerformanceFrequency` on Windows. + 2. Standardize filesystem I/O on Win32 API (`CreateFileW`, `ReadFile`, `WriteFile`) or minimal C runtime headers (``, ``, ``). + +### D. Memory Allocators & RTTI +- **Current Usages**: ``, `` (`typeid` in `MemoryArena.h`), ``. +- **Workload**: + 1. Replace placement `new` with custom inline placement functions or custom explicit initialization methods. + 2. Replace `typeid` / `type_info` usages with custom type hashing or enum type IDs. + +--- + +## 3. Phase 2: Complete Migration to C + +Transitioning fully to C requires refactoring away all C++ language constructs. + +### A. DirectX 12 & Agility SDK Integration +- **D3D12 Header Interface**: Switch from C++ COM smart pointers / methods (`device->CreateCommandAllocator(...)`) to standard C COM interfaces (`ID3D12Device_CreateCommandAllocator(device, ...)`). +- **D3DX12 Helper Library**: `d3dx12_state_object.h` and helper files rely heavily on stdlib (`std::vector`, `std::memory`, C++ structures). These must be rewritten in plain C or replaced with native DirectX 12 C struct initializers. + +### B. UI Framework (ImGui) +- Dear ImGui is natively C++. +- **Workload**: Switch from standard `imgui.h` / `imgui_stdlib.h` to [cimgui](https://github.com/cimgui/cimgui) (C-compatible wrappers for ImGui) or maintain a minimal C++ bridge file specifically for ImGui. + +### C. Codebase Refactoring (Language Paradigm) +1. **Classes to Structs**: Convert classes in `Juliet` core, `Game`, and `Romeo` to C structs. +2. **Virtual Functions**: Replace polymorphism with explicit `void*` context pointers and function pointer tables (vtables). +3. **Namespaces & Function Overloading**: Prefix function names (e.g., `Juliet_Log_Info(...)`) as C does not support namespaces or function overloading. +4. **Member Functions to Free Functions**: Convert `obj.Method(args)` to `Method(&obj, args)`. +5. **No Reference Arguments (`&`)**: Replace all pass-by-reference parameters with explicit pointers (`*`). +6. **Casting Rules**: Remove `static_cast` and `reinterpret_cast` in favor of standard C explicit casts `(Type)val`. + +### D. Build System (`Romeo.bff` / `fbuild.bff`) +- Update compiler settings in FastBuild (`.bff` files) and Visual Studio project settings from `/std:c++20` to C compiler flags (`/std:c11` or `/TC`). + +--- + +## 4. Estimated Workload Matrix + +| Task Module | Complexity | Estimated Relative Effort | Risks / Key Considerations | +| :--- | :--- | :--- | :--- | +| **1. Stdlib-Free Containers & Utils** | Moderate | ~15% | Custom array/hash table implementation. | +| **2. OS Threading & Time Abstraction** | Low-Moderate | ~10% | Clean Windows API replacements (`QueryPerformanceCounter`, `SRWLOCK`). | +| **3. C Struct & Syntax Refactoring** | High | ~40% | Large volume of mechanical refactoring (references, namespaces, overloading, methods). | +| **4. Graphics / D3D12 C Refactoring** | High | ~20% | `d3dx12` heavily relies on C++ templates/stdlib; rewriting helper structs in C. | +| **5. ImGui / Romeo GUI Integration** | Moderate | ~15% | Needs `cimgui` integration or a C-wrapper boundary. | + +--- + +## 5. Recommendation & Phasing + +1. **Step 1 (Stdlib Removal)**: Keep C++20 language features (classes, templates, member methods), but remove all stdlib inclusions (``, ``, ``, ``). Replace them with custom `Juliet` engine primitives. +2. **Step 2 (Evaluate C Migration)**: Re-evaluate if moving to pure C provides enough benefit vs. keeping a clean, stdlib-free C++ subset ("C with Classes" / stdlib-free C++). diff --git a/Juliet/include/Core/Container/Vector.h b/Juliet/include/Core/Container/Vector.h index f55d76f..63e510c 100644 --- a/Juliet/include/Core/Container/Vector.h +++ b/Juliet/include/Core/Container/Vector.h @@ -2,89 +2,63 @@ #include #include -#include namespace Juliet { - template + template struct VectorArena { - void Create(JULIET_DEBUG_PARAM_FIRST(const char* name = nullptr)) - { - Assert(!Arena); - static_assert(AllowRealloc == false); - - DataFirst = DataLast = nullptr; - Count = 0; - - JULIET_DEBUG_ONLY(Name = name ? name : Name;) - ArenaParams params{ .AllowRealloc = AllowRealloc JULIET_DEBUG_PARAM(.CanReserveMore = false) }; - Arena = ArenaAllocate(params JULIET_DEBUG_PARAM(Name)); - InternalArena = true; - - Reserve(ReserveSize); - } - void Create(NonNullPtr arena JULIET_DEBUG_PARAM(const char* name = nullptr)) { Assert(!Arena); JULIET_DEBUG_ONLY(Name = name ? name : Name;) - DataFirst = DataLast = nullptr; - Count = 0; - Arena = arena.Get(); - InternalArena = false; + DataFirst = DataLast = Data = nullptr; + Count = 0; + Capacity = 0; + Arena = arena; Reserve(ReserveSize); } void Destroy() { - if (InternalArena) - { - ArenaRelease(Arena); - } - DataFirst = DataLast = nullptr; - Count = 0; - Capacity = 0; - Arena = nullptr; + DataFirst = DataLast = Data = nullptr; + Count = 0; + Capacity = 0; + Arena = nullptr; } void Reserve(size_t newCapacity) { - if (newCapacity > Capacity) + Assert(Arena); + if (Data == nullptr) { - if (Data == nullptr) - { - Data = ArenaPushArray(Arena, newCapacity JULIET_DEBUG_PARAM(Name)); - } - else if constexpr (AllowRealloc) - { - if (!InternalArena) - { - DataFirst = Data = - static_cast(ArenaReallocate(Arena, Data, Capacity * sizeof(Type), newCapacity * sizeof(Type), - AlignOf(Type), true JULIET_DEBUG_PARAM("VectorRealloc"))); - DataLast = Data + Count - 1; - } - } + Data = ArenaPushArray(Arena, newCapacity JULIET_DEBUG_PARAM(Name)); Capacity = newCapacity; } + else + { + Assert(newCapacity <= Capacity && "VectorArena capacity exceeded! Reallocation is disabled."); + } } void Resize(size_t newCount) { + Assert(Arena); if (newCount == Count) { return; } - if (newCount > Capacity) + if (Data == nullptr) { - Reserve(newCount); + size_t initialCapacity = newCount > ReserveSize ? newCount : ReserveSize; + Reserve(initialCapacity); } + Assert(newCount <= Capacity && "VectorArena capacity exceeded!"); Count = newCount; if (Count > 0) @@ -101,20 +75,21 @@ namespace Juliet void PushBack(const Type* buffer, size_t amount) { Assert(Arena); + Assert(buffer || amount == 0); - if (Count + amount > Capacity) + if (amount == 0) { - if (Capacity == 0 && Count + amount < ReserveSize) - { - Reserve(ReserveSize); - } - else - { - size_t newCapacity = Max(Capacity * 2, AlignPow2(Capacity + amount, AlignOf(Type))); - Reserve(newCapacity); - } + return; } + if (Data == nullptr) + { + size_t initialCapacity = amount > ReserveSize ? amount : ReserveSize; + Reserve(initialCapacity); + } + + Assert(Count + amount <= Capacity && "VectorArena capacity exceeded!"); + Type* dst = Data + Count; MemCopy(dst, buffer, amount * sizeof(Type)); @@ -122,7 +97,7 @@ namespace Juliet { DataFirst = dst; } - DataLast = dst + amount; + DataLast = dst + amount - 1; Count += amount; } @@ -130,11 +105,13 @@ namespace Juliet { Assert(Arena); - if (Count + 1 > Capacity) + if (Data == nullptr) { - Reserve(Capacity == 0 ? ReserveSize : Capacity * 2); + Reserve(ReserveSize); } + Assert(Count + 1 <= Capacity && "VectorArena capacity exceeded!"); + Type* entry = Data + Count; *entry = value; @@ -150,11 +127,13 @@ namespace Juliet { Assert(Arena); - if (Count + 1 > Capacity) + if (Data == nullptr) { - Reserve(Capacity == 0 ? ReserveSize : Capacity * 2); + Reserve(ReserveSize); } + Assert(Count + 1 <= Capacity && "VectorArena capacity exceeded!"); + Type* entry = Data + Count; *entry = std::move(value); @@ -193,44 +172,37 @@ namespace Juliet { Assert(Arena); - if (InternalArena) - { - ArenaClear(Arena); - Data = nullptr; - Capacity = 0; - Reserve(ReserveSize); - } - DataFirst = DataLast = nullptr; Count = 0; } - bool IsEmpty() const { return Count == 0; } + [[nodiscard]] bool IsEmpty() const { return Count == 0; } // C++ Accessors for loop supports and Index based access - Type& operator[](size_t index) { return DataFirst[index]; } - const Type& operator[](size_t index) const { return DataFirst[index]; } + [[nodiscard]] Type& operator[](size_t index) { return DataFirst[index]; } + [[nodiscard]] const Type& operator[](size_t index) const { return DataFirst[index]; } - Type* begin() { return DataFirst; } - Type* end() { return DataFirst + Count; } + [[nodiscard]] Type* begin() { return DataFirst; } + [[nodiscard]] Type* end() { return DataFirst + Count; } - const Type* begin() const { return DataFirst; } - const Type* end() const { return DataFirst + Count; } + [[nodiscard]] const Type* begin() const { return DataFirst; } + [[nodiscard]] const Type* end() const { return DataFirst + Count; } - Type* First() { return DataFirst; } - Type* Front() { return DataFirst; } - Type* Last() { return DataLast; } - Type* Back() { return DataLast; } + [[nodiscard]] Type* First() { return DataFirst; } + [[nodiscard]] Type* Front() { return DataFirst; } + [[nodiscard]] Type* Last() { return DataLast; } + [[nodiscard]] Type* Back() { return DataLast; } + [[nodiscard]] Type* DataPtr() { return Data; } + [[nodiscard]] const Type* DataPtr() const { return Data; } - size_t Size() const { return Count; } + [[nodiscard]] size_t Size() const { return Count; } - Arena* Arena; - Type* DataFirst; - Type* DataLast; - Type* Data; - size_t Count; - size_t Capacity; - bool InternalArena : 1; + Arena* Arena = nullptr; + Type* DataFirst = nullptr; + Type* DataLast = nullptr; + Type* Data = nullptr; + size_t Count = 0; + size_t Capacity = 0; JULIET_DEBUG_ONLY(const char* Name = "VectorArena";) }; static_assert(std::is_standard_layout_v>, diff --git a/Juliet/include/Core/Networking/NetworkPacket.h b/Juliet/include/Core/Networking/NetworkPacket.h index 8d9f292..7709482 100644 --- a/Juliet/include/Core/Networking/NetworkPacket.h +++ b/Juliet/include/Core/Networking/NetworkPacket.h @@ -5,25 +5,20 @@ namespace Juliet { - // TODO Use VectorArena - template - class Vector : public std::vector - { - }; - class NetworkPacket { public: NetworkPacket(); + NetworkPacket(Arena& arena); virtual ~NetworkPacket(); NetworkPacket(NetworkPacket&); NetworkPacket& operator=(const NetworkPacket&); NetworkPacket(NetworkPacket&&) noexcept; NetworkPacket& operator=(NetworkPacket&&) noexcept; - ByteBuffer GetRawData(); + void Create(Arena& arena); - // Unpack + [[nodiscard]] ByteBuffer GetRawData(); // Pack NetworkPacket& operator<<(uint32 value); @@ -35,7 +30,7 @@ namespace Juliet friend class TcpSocket; private: - Vector Data; - size_t PartialSendIndex = 0; + VectorArena Data; + size_t PartialSendIndex = 0; }; } // namespace Juliet diff --git a/Juliet/include/Graphics/MeshRenderer.h b/Juliet/include/Graphics/MeshRenderer.h index 0dc8060..38f1897 100644 --- a/Juliet/include/Graphics/MeshRenderer.h +++ b/Juliet/include/Graphics/MeshRenderer.h @@ -30,11 +30,10 @@ namespace Juliet struct MeshRenderer { - // Note we prevent realloc for now. - VectorArena Meshes; - VectorArena Vertices; - VectorArena Indices; - VectorArena PointLights; + VectorArena Meshes; + VectorArena Vertices; + VectorArena Indices; + VectorArena PointLights; GraphicsBuffer* VertexBuffer; GraphicsBuffer* IndexBuffer; diff --git a/Juliet/src/Core/Networking/NetworkPacket.cpp b/Juliet/src/Core/Networking/NetworkPacket.cpp index e1fdb96..f6ccae1 100644 --- a/Juliet/src/Core/Networking/NetworkPacket.cpp +++ b/Juliet/src/Core/Networking/NetworkPacket.cpp @@ -7,17 +7,26 @@ namespace Juliet { NetworkPacket::NetworkPacket() = default; + NetworkPacket::NetworkPacket(Arena& arena) + { + Data.Create(&arena); + } NetworkPacket::~NetworkPacket() = default; NetworkPacket::NetworkPacket(NetworkPacket&) = default; NetworkPacket& NetworkPacket::operator=(const NetworkPacket&) = default; NetworkPacket::NetworkPacket(NetworkPacket&&) noexcept = default; NetworkPacket& NetworkPacket::operator=(NetworkPacket&&) noexcept = default; + void NetworkPacket::Create(Arena& arena) + { + Data.Create(&arena); + } + ByteBuffer NetworkPacket::GetRawData() { ByteBuffer buffer{}; - buffer.Data = Data.data(); - buffer.Size = Data.size(); + buffer.Data = Data.DataPtr(); + buffer.Size = Data.Size(); return buffer; } @@ -52,9 +61,7 @@ namespace Juliet { if (buffer.Data && (buffer.Size > 0)) { - const auto* begin = reinterpret_cast(buffer.Data); - const auto* end = begin + buffer.Size; - Data.insert(Data.end(), begin, end); + Data.PushBack(TO_BUFFER(buffer.Data), buffer.Size); } } diff --git a/Juliet/src/Core/Networking/TcpSocket.cpp b/Juliet/src/Core/Networking/TcpSocket.cpp index 18f828d..c543afa 100644 --- a/Juliet/src/Core/Networking/TcpSocket.cpp +++ b/Juliet/src/Core/Networking/TcpSocket.cpp @@ -27,6 +27,7 @@ namespace Juliet // Because of that we will send the size of the packet first before sending the data. // TODO Use scratch allocator. + /* Vector scratchVector; scratchVector.resize(buffer.Size + sizeof(uint32)); @@ -52,6 +53,8 @@ namespace Juliet } return messageStatus; + */ + return {}; } Socket::RequestStatus TcpSocket::Send(ByteBuffer buffer) diff --git a/Juliet/src/Engine/Debug/MemoryDebugger.cpp b/Juliet/src/Engine/Debug/MemoryDebugger.cpp index 367b5fd..8b5799d 100644 --- a/Juliet/src/Engine/Debug/MemoryDebugger.cpp +++ b/Juliet/src/Engine/Debug/MemoryDebugger.cpp @@ -40,13 +40,14 @@ namespace Juliet::Debug }; // Static Vector for lookup - VectorArena s_PagedArenaStates; + VectorArena s_PagedArenaStates; PagedArenaDebugState& GetPagedArenaState(const Arena* arena) { if (s_PagedArenaStates.Arena == nullptr) { - s_PagedArenaStates.Create(JULIET_DEBUG_ONLY("DebugState States")); + Arena* pagedArenaStates = ArenaAllocate({} JULIET_DEBUG_ONLY(, "DebugState States")); + s_PagedArenaStates.Create(pagedArenaStates); } for (auto& entry : s_PagedArenaStates) @@ -104,7 +105,8 @@ namespace Juliet::Debug static VectorArena blocks; if (blocks.Arena == nullptr) { - blocks.Create(JULIET_DEBUG_ONLY("DebugState Blocks")); + Arena* pagedArenaStates = ArenaAllocate({} JULIET_DEBUG_ONLY(, "DebugState Blocks")); + blocks.Create(pagedArenaStates); } blocks.Clear(); diff --git a/Juliet/src/Graphics/MeshRenderer.cpp b/Juliet/src/Graphics/MeshRenderer.cpp index 23015cf..0180136 100644 --- a/Juliet/src/Graphics/MeshRenderer.cpp +++ b/Juliet/src/Graphics/MeshRenderer.cpp @@ -22,10 +22,10 @@ namespace Juliet GraphicsBuffer* TransformsBuffer = nullptr; GraphicsTransferBuffer* LoadCopyBuffer = nullptr; - VectorArena Meshes; - VectorArena Vertices; - VectorArena Indices; - VectorArena PointLights; + VectorArena Meshes; + VectorArena Vertices; + VectorArena Indices; + VectorArena PointLights; PointLight* MappedLights = nullptr; Matrix* MappedTransforms = nullptr; diff --git a/Juliet/src/UnitTest/Container/VectorUnitTest.cpp b/Juliet/src/UnitTest/Container/VectorUnitTest.cpp index 93c1768..476de15 100644 --- a/Juliet/src/UnitTest/Container/VectorUnitTest.cpp +++ b/Juliet/src/UnitTest/Container/VectorUnitTest.cpp @@ -9,8 +9,8 @@ namespace Juliet::UnitTest { namespace { - template - inline void VerifyVectorState(const VectorArena& vec, size_t expectedCount) + template + inline void VerifyVectorState(const VectorArena& vec, size_t expectedCount) { Assert(vec.Size() == expectedCount); @@ -29,10 +29,13 @@ namespace Juliet::UnitTest void VectorUnitTest() { + ArenaParams params{}; + Arena* testArena = ArenaAllocate(params JULIET_DEBUG_ONLY(, "VectorUnitTestArena")); + // Test 1: Integer VectorArena (Basic Operations) { VectorArena vec = {}; - vec.Create(); + vec.Create(testArena); VerifyVectorState(vec, 0); vec.PushBack(10); @@ -65,7 +68,7 @@ namespace Juliet::UnitTest // Test 2: RemoveAtFast { VectorArena vec = {}; - vec.Create(); + vec.Create(testArena); vec.PushBack(10); vec.PushBack(20); @@ -95,7 +98,7 @@ namespace Juliet::UnitTest // Test 3: Clear and Reuse (Pointer State Check) { VectorArena vec = {}; - vec.Create(); + vec.Create(testArena); vec.PushBack(100); vec.PushBack(200); @@ -127,7 +130,7 @@ namespace Juliet::UnitTest }; VectorArena vec = {}; - vec.Create(); + vec.Create(testArena); VerifyVectorState(vec, 0); @@ -145,39 +148,7 @@ namespace Juliet::UnitTest vec.Destroy(); } - // Test 5: Reallocation Support (AllowRealloc = true) - { - // Initial capacity 4, allow realloc - ArenaParams params{ .AllowRealloc = true }; - Arena* externalArena = ArenaAllocate(params JULIET_DEBUG_ONLY(, "VectorTest")); - - VectorArena vec = {}; - vec.Create(externalArena); - - Assert(vec.Capacity == 4); - - vec.PushBack(1); - vec.PushBack(2); - vec.PushBack(3); - vec.PushBack(4); - Assert(vec.Capacity == 4); - - // Trigger realloc - vec.PushBack(5); - Assert(vec.Capacity >= 5); // Should have grown (likely doubled to 8) - VerifyVectorState(vec, 5); - - Assert(vec[0] == 1); - Assert(vec[1] == 2); - Assert(vec[2] == 3); - Assert(vec[3] == 4); - Assert(vec[4] == 5); - - vec.Destroy(); - ArenaRelease(externalArena); - } - - // Test 6: Move Semantics + // Test 5: Move Semantics { struct MoveOnly { @@ -207,10 +178,8 @@ namespace Juliet::UnitTest } }; - VectorArena vec = {}; - ArenaParams params{ .AllowRealloc = true }; - Arena* externalArena = ArenaAllocate(params JULIET_DEBUG_ONLY(, "VectorTest")); - NonNullPtr validArena(externalArena); + VectorArena vec = {}; + NonNullPtr validArena(testArena); vec.Create(validArena); MoveOnly item1(10); @@ -222,16 +191,13 @@ namespace Juliet::UnitTest Assert(!vec[0].MovedFrom); vec.Destroy(); - ArenaRelease(externalArena); } - // Test 7: Resize Behavior + // Test 6: Resize Behavior { - ArenaParams params{ .AllowRealloc = true }; - Arena* externalArena = ArenaAllocate(params JULIET_DEBUG_ONLY(, "VectorTest")); - NonNullPtr validArena(externalArena); + NonNullPtr validArena(testArena); - VectorArena vec = {}; + VectorArena vec = {}; vec.Create(validArena); vec.PushBack(1); @@ -243,42 +209,21 @@ namespace Juliet::UnitTest Assert(vec.Size() == 1); Assert(vec[0] == 1); - // Resize larger + // Resize larger up to max capacity vec.Resize(4); Assert(vec.Size() == 4); Assert(vec[0] == 1); vec.Destroy(); - ArenaRelease(externalArena); } - // Test 8: External Arena Usage + // Test 7: External Arena Usage & Volume Test within capacity { - ArenaParams params{ .AllowRealloc = true }; - Arena* externalArena = ArenaAllocate(params JULIET_DEBUG_ONLY(, "VectorTest")); - NonNullPtr validArena(externalArena); + NonNullPtr validArena(testArena); - VectorArena vec = {}; + VectorArena vec = {}; vec.Create(validArena); // Pass external arena - vec.PushBack(42); - Assert(vec.Size() == 1); - Assert(vec[0] == 42); - - vec.Destroy(); - ArenaRelease(externalArena); - } - - // Test 9: Volume Test (100 items with Realloc) - { - ArenaParams params{ .AllowRealloc = true }; - Arena* externalArena = ArenaAllocate(params JULIET_DEBUG_ONLY(, "VectorTest")); - NonNullPtr validArena(externalArena); - - VectorArena vec = {}; - vec.Create(validArena); - - // Push 100 items -> Should realloc multiple times for (int i = 0; i < 100; ++i) { vec.PushBack(i); @@ -291,8 +236,9 @@ namespace Juliet::UnitTest } vec.Destroy(); - ArenaRelease(externalArena); } + + ArenaRelease(testArena); } } // namespace Juliet::UnitTest #endif diff --git a/Romeo/src/Database.h b/Romeo/src/Database.h index 17bcb7f..b5dc292 100644 --- a/Romeo/src/Database.h +++ b/Romeo/src/Database.h @@ -25,7 +25,7 @@ namespace Romeo struct Database { - Juliet::VectorArena Entries = {}; + Juliet::VectorArena Entries = {}; Juliet::Arena* DbArena = nullptr; Juliet::Mutex Mutex; }; diff --git a/Romeo/src/JsonParser.h b/Romeo/src/JsonParser.h index 05aa3bb..d87a23e 100644 --- a/Romeo/src/JsonParser.h +++ b/Romeo/src/JsonParser.h @@ -31,8 +31,8 @@ namespace Romeo double NumVal = 0.0; Juliet::String StrVal = {}; - Juliet::VectorArena ArrayVal = {}; - Juliet::VectorArena ObjectVal = {}; + Juliet::VectorArena ArrayVal = {}; + Juliet::VectorArena ObjectVal = {}; }; // Parses a JSON string. Memory is allocated on the provided arena. diff --git a/Romeo/src/MarkdownGenerator.cpp b/Romeo/src/MarkdownGenerator.cpp index 0e38363..90f3778 100644 --- a/Romeo/src/MarkdownGenerator.cpp +++ b/Romeo/src/MarkdownGenerator.cpp @@ -410,7 +410,7 @@ namespace Romeo static void ParseSymbolsFromFile( Juliet::Arena* arena, const Juliet::String& filePath, - Juliet::VectorArena& outSymbols + Juliet::VectorArena& outSymbols ) { Assert(arena != nullptr); @@ -726,7 +726,7 @@ namespace Romeo static void FormatAndWriteSymbols(StringBuilder& sb, Juliet::Arena* arena, const Juliet::String& filePath) { printf("Romeo: FormatAndWriteSymbols start for %.*s\n", static_cast(filePath.Size), CStr(filePath)); - Juliet::VectorArena symbols = {}; + Juliet::VectorArena symbols = {}; symbols.Create(arena JULIET_DEBUG_ONLY(, "ParsedSymbols")); printf("Romeo: Calling ParseSymbolsFromFile...\n"); @@ -741,7 +741,7 @@ namespace Romeo // Collect all distinct namespaces printf("Romeo: Collecting namespaces...\n"); - Juliet::VectorArena namespaces = {}; + Juliet::VectorArena namespaces = {}; namespaces.Create(arena JULIET_DEBUG_ONLY(, "NamespacesList")); for (const ParsedSymbol& sym : symbols)