feat: high-performance engine optimizations and Prepared Statement API #19
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,119 @@ | ||
| /** | ||
| * @file arena_allocator.hpp | ||
| * @brief High-performance bump allocator for execution-scoped data | ||
| */ | ||
|
|
||
| #ifndef CLOUDSQL_COMMON_ARENA_ALLOCATOR_HPP | ||
| #define CLOUDSQL_COMMON_ARENA_ALLOCATOR_HPP | ||
|
|
||
| #include <algorithm> | ||
| #include <cstddef> | ||
| #include <cstdint> | ||
| #include <memory> | ||
| #include <memory_resource> | ||
| #include <vector> | ||
|
|
||
| namespace cloudsql::common { | ||
|
|
||
| /** | ||
| * @class ArenaAllocator | ||
| * @brief Manages memory chunks and provides fast, contiguous allocations. | ||
| * | ||
| * Implements std::pmr::memory_resource for compatibility with standard | ||
| * containers like std::pmr::vector. | ||
| */ | ||
| class ArenaAllocator : public std::pmr::memory_resource { | ||
| public: | ||
| static constexpr size_t DEFAULT_CHUNK_SIZE = 65536; // 64KB | ||
|
|
||
| explicit ArenaAllocator(size_t chunk_size = DEFAULT_CHUNK_SIZE) | ||
| : chunk_size_(chunk_size), current_chunk_idx_(0), current_offset_(0) {} | ||
|
|
||
| ~ArenaAllocator() override { | ||
| for (auto* chunk : chunks_) { | ||
| delete[] chunk; | ||
| } | ||
| } | ||
|
|
||
| // Disable copy | ||
| ArenaAllocator(const ArenaAllocator&) = delete; | ||
| ArenaAllocator& operator=(const ArenaAllocator&) = delete; | ||
|
|
||
| /** | ||
| * @brief Reset the arena, reclaiming all memory for reuse. | ||
| * | ||
| * Keeps all allocated chunks but resets pointers so they can be overwritten. | ||
| * This is an O(1) or O(N_chunks) operation with zero heap overhead. | ||
| */ | ||
| void reset() { | ||
| current_chunk_idx_ = 0; | ||
| current_offset_ = 0; | ||
| } | ||
|
|
||
| protected: | ||
| /** | ||
| * @brief Internal allocation logic for PMR | ||
| */ | ||
| void* do_allocate(size_t bytes, size_t alignment) override { | ||
| if (bytes == 0) return nullptr; | ||
|
|
||
| // Align the offset | ||
| size_t mask = alignment - 1; | ||
|
|
||
| // Try current chunk | ||
| if (current_chunk_idx_ < chunks_.size()) { | ||
| size_t aligned_offset = (current_offset_ + mask) & ~mask; | ||
| if (aligned_offset + bytes <= chunk_size_) { | ||
| void* result = chunks_[current_chunk_idx_] + aligned_offset; | ||
| current_offset_ = aligned_offset + bytes; | ||
| return result; | ||
| } | ||
|
|
||
| // Move to next existing chunk if possible | ||
| current_chunk_idx_++; | ||
| current_offset_ = 0; | ||
| return do_allocate(bytes, alignment); | ||
| } | ||
|
|
||
| // Need a new chunk | ||
| if (bytes > chunk_size_) { | ||
| auto* large_chunk = new uint8_t[bytes]; | ||
| chunks_.push_back(large_chunk); | ||
| // We don't make this the "current" chunk for small allocations | ||
| // to avoid wasting space. We just return it. | ||
| return large_chunk; | ||
| } | ||
|
|
||
| allocate_new_chunk(); | ||
| return do_allocate(bytes, alignment); | ||
| } | ||
|
|
||
| /** | ||
| * @brief PMR deallocate is a no-op for bump allocators (we reset the whole arena) | ||
| */ | ||
| void do_deallocate(void* p, size_t bytes, size_t alignment) override { | ||
| // No-op | ||
| (void)p; | ||
| (void)bytes; | ||
| (void)alignment; | ||
| } | ||
|
|
||
| bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override { | ||
| return this == &other; | ||
| } | ||
|
|
||
| private: | ||
| void allocate_new_chunk() { | ||
| chunks_.push_back(new uint8_t[chunk_size_]); | ||
| // Don't change current_chunk_idx_ here, let the recursive call handle it | ||
| } | ||
|
|
||
| size_t chunk_size_; | ||
| std::vector<uint8_t*> chunks_; | ||
| size_t current_chunk_idx_; | ||
| size_t current_offset_; | ||
| }; | ||
|
|
||
| } // namespace cloudsql::common | ||
|
|
||
| #endif // CLOUDSQL_COMMON_ARENA_ALLOCATOR_HPP | ||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Keep oversized allocations out of the reusable chunk list.
The
bytes > chunk_size_branch appends the dedicated buffer tochunks_but leavescurrent_chunk_idx_/current_offset_unchanged. The next small allocation can therefore be handed out from that same buffer at offset 0, aliasing the still-live large allocation.💡 One way to isolate large allocations
~ArenaAllocator() override { for (auto* chunk : chunks_) { delete[] chunk; } + for (auto* chunk : large_chunks_) { + delete[] chunk; + } } ... if (bytes > chunk_size_) { auto* large_chunk = new uint8_t[bytes]; - chunks_.push_back(large_chunk); + large_chunks_.push_back(large_chunk); // We don't make this the "current" chunk for small allocations // to avoid wasting space. We just return it. return large_chunk; } ... std::vector<uint8_t*> chunks_; + std::vector<uint8_t*> large_chunks_; size_t current_chunk_idx_; size_t current_offset_;Also applies to: 79-85, 111-114
🤖 Prompt for AI Agents