feat: add arena allocator with block chaining and max size

Author: renecannao

include/sql_parser/arena.h

@@ -0,0 +1,56 @@
+#ifndef SQL_PARSER_ARENA_H
+#define SQL_PARSER_ARENA_H
+
+#include "sql_parser/common.h"
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <new>
+
+namespace sql_parser {
+
+class Arena {
+public:
+    explicit Arena(size_t block_size = 65536, size_t max_size = 1048576);
+    ~Arena();
+
+    Arena(const Arena&) = delete;
+    Arena& operator=(const Arena&) = delete;
+    Arena(Arena&&) = delete;
+    Arena& operator=(Arena&&) = delete;
+
+    void* allocate(size_t bytes);
+
+    template <typename T>
+    T* allocate_typed() {
+        void* mem = allocate(sizeof(T));
+        if (!mem) return nullptr;
+        return new (mem) T{};
+    }
+
+    StringRef allocate_string(const char* src, uint32_t len);
+
+    void reset();
+
+    size_t bytes_used() const;
+
+private:
+    struct Block {
+        Block* next;
+        size_t capacity;
+        size_t used;
+        char* data() { return reinterpret_cast<char*>(this) + sizeof(Block); }
+    };
+
+    Block* allocate_block(size_t capacity);
+
+    Block* primary_;
+    Block* current_;
+    size_t block_size_;
+    size_t max_size_;
+    size_t total_allocated_;
+};
+
+} // namespace sql_parser
+
+#endif // SQL_PARSER_ARENA_H

src/sql_parser/arena.cpp

@@ -0,0 +1,88 @@
+#include "sql_parser/arena.h"
+#include <cstdlib>
+
+namespace sql_parser {
+
+Arena::Block* Arena::allocate_block(size_t capacity) {
+    void* mem = std::malloc(sizeof(Block) + capacity);
+    if (!mem) return nullptr;
+    Block* block = static_cast<Block*>(mem);
+    block->next = nullptr;
+    block->capacity = capacity;
+    block->used = 0;
+    return block;
+}
+
+Arena::Arena(size_t block_size, size_t max_size)
+    : block_size_(block_size), max_size_(max_size), total_allocated_(0) {
+    primary_ = allocate_block(block_size_);
+    current_ = primary_;
+    total_allocated_ = block_size_;
+}
+
+Arena::~Arena() {
+    Block* b = primary_;
+    while (b) {
+        Block* next = b->next;
+        std::free(b);
+        b = next;
+    }
+}
+
+void* Arena::allocate(size_t bytes) {
+    bytes = (bytes + 7) & ~size_t(7);
+
+    if (current_->used + bytes <= current_->capacity) {
+        void* ptr = current_->data() + current_->used;
+        current_->used += bytes;
+        return ptr;
+    }
+
+    size_t new_cap = (bytes > block_size_) ? bytes : block_size_;
+    if (total_allocated_ + new_cap > max_size_) {
+        return nullptr;
+    }
+
+    Block* new_block = allocate_block(new_cap);
+    if (!new_block) return nullptr;
+
+    current_->next = new_block;
+    current_ = new_block;
+    total_allocated_ += new_cap;
+
+    void* ptr = current_->data() + current_->used;
+    current_->used += bytes;
+    return ptr;
+}
+
+StringRef Arena::allocate_string(const char* src, uint32_t len) {
+    void* mem = allocate(len);
+    if (!mem) return StringRef{nullptr, 0};
+    std::memcpy(mem, src, len);
+    return StringRef{static_cast<const char*>(mem), len};
+}
+
+void Arena::reset() {
+    Block* b = primary_->next;
+    while (b) {
+        Block* next = b->next;
+        std::free(b);
+        b = next;
+    }
+    primary_->next = nullptr;
+    primary_->used = 0;
+    current_ = primary_;
+    total_allocated_ = block_size_;
+}
+
+size_t Arena::bytes_used() const {
+    size_t used = 0;
+    const Block* b = primary_;
+    while (b) {
+        used += b->used;
+        b = b->next;
+    }
+    return used;
+}
+
+} // namespace sql_parser

tests/test_arena.cpp

@@ -0,0 +1,78 @@
+#include <gtest/gtest.h>
+#include "sql_parser/arena.h"
+
+using namespace sql_parser;
+
+TEST(ArenaTest, AllocateAndReset) {
+    Arena arena(4096);
+    void* p1 = arena.allocate(64);
+    ASSERT_NE(p1, nullptr);
+    void* p2 = arena.allocate(64);
+    ASSERT_NE(p2, nullptr);
+    EXPECT_NE(p1, p2);
+
+    arena.reset();
+    void* p3 = arena.allocate(64);
+    ASSERT_NE(p3, nullptr);
+    EXPECT_EQ(p1, p3);
+}
+
+TEST(ArenaTest, AllocateAligned) {
+    Arena arena(4096);
+    void* p1 = arena.allocate(1);
+    void* p2 = arena.allocate(8);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(p2) % 8, 0u);
+}
+
+TEST(ArenaTest, OverflowToNewBlock) {
+    Arena arena(128);
+    void* p1 = arena.allocate(100);
+    ASSERT_NE(p1, nullptr);
+    void* p2 = arena.allocate(100);
+    ASSERT_NE(p2, nullptr);
+    EXPECT_NE(p1, p2);
+}
+
+TEST(ArenaTest, ResetFreesOverflowBlocks) {
+    Arena arena(128);
+    arena.allocate(100);
+    arena.allocate(100);
+    arena.reset();
+    void* p = arena.allocate(64);
+    ASSERT_NE(p, nullptr);
+}
+
+TEST(ArenaTest, MaxSizeEnforced) {
+    Arena arena(128, 256);
+    void* p1 = arena.allocate(100);
+    ASSERT_NE(p1, nullptr);
+    void* p2 = arena.allocate(100);
+    ASSERT_NE(p2, nullptr);
+    void* p3 = arena.allocate(100);
+    EXPECT_EQ(p3, nullptr);
+}
+
+TEST(ArenaTest, AllocateTyped) {
+    Arena arena(4096);
+
+    struct TestStruct {
+        int a;
+        double b;
+    };
+
+    TestStruct* ts = arena.allocate_typed<TestStruct>();
+    ASSERT_NE(ts, nullptr);
+    ts->a = 42;
+    ts->b = 3.14;
+    EXPECT_EQ(ts->a, 42);
+    EXPECT_DOUBLE_EQ(ts->b, 3.14);
+}
+
+TEST(ArenaTest, AllocateString) {
+    Arena arena(4096);
+    const char* src = "hello world";
+    StringRef ref = arena.allocate_string(src, 11);
+    EXPECT_EQ(ref.len, 11u);
+    EXPECT_EQ(std::memcmp(ref.ptr, "hello world", 11), 0);
+    EXPECT_NE(ref.ptr, src);
+}