Initial arena benchmarks

src/arena_allocator.hpp

@@ -7,8 +7,9 @@
 class ArenaAllocator {
 public:
   explicit ArenaAllocator(size_t initial_size = 1024)
-      : block_size_(initial_size), current_block_(0), current_offset_(0) {
-    add_block();
+      : initial_block_size_(initial_size), current_block_(0),
+        current_offset_(0) {
+    add_block(initial_size);
   }
 
   ~ArenaAllocator() = default;
@@ -29,11 +30,9 @@ public:
     size_t aligned_offset =
         align_up(block_addr + current_offset_, alignment) - block_addr;
 
-    if (aligned_offset + size > block_size_) {
-      if (size > block_size_) {
-        throw std::bad_alloc();
-      }
-      add_block();
+    if (aligned_offset + size > block_sizes_[current_block_]) {
+      size_t next_block_size = calculate_next_block_size(size);
+      add_block(next_block_size);
       block_start = blocks_[current_block_].get();
       block_addr = reinterpret_cast<uintptr_t>(block_start);
       aligned_offset = align_up(block_addr, alignment) - block_addr;
@@ -55,25 +54,44 @@ public:
     current_offset_ = 0;
   }
 
-  size_t total_allocated() const { return blocks_.size() * block_size_; }
+  size_t total_allocated() const {
+    size_t total = 0;
+    for (size_t size : block_sizes_) {
+      total += size;
+    }
+    return total;
+  }
 
   size_t used_bytes() const {
-    return current_block_ * block_size_ + current_offset_;
+    size_t total = current_offset_;
+    for (size_t i = 0; i < current_block_; ++i) {
+      total += block_sizes_[i];
+    }
+    return total;
   }
 
   size_t available_in_current_block() const {
-    return block_size_ - current_offset_;
+    return block_sizes_[current_block_] - current_offset_;
   }
 
   size_t num_blocks() const { return blocks_.size(); }
 
 private:
-  void add_block() {
-    blocks_.emplace_back(std::make_unique<char[]>(block_size_));
+  void add_block(size_t size) {
+    blocks_.emplace_back(std::make_unique<char[]>(size));
+    block_sizes_.push_back(size);
     current_block_ = blocks_.size() - 1;
     current_offset_ = 0;
   }
 
+  size_t calculate_next_block_size(size_t required_size) const {
+    size_t current_size =
+        blocks_.empty() ? initial_block_size_ : block_sizes_[current_block_];
+    size_t doubled_size = current_size * 2;
+
+    return std::max(required_size, doubled_size);
+  }
+
   static size_t align_up(size_t value, size_t alignment) {
     if (alignment == 0 || (alignment & (alignment - 1)) != 0) {
       return value;
@@ -81,8 +99,9 @@ private:
     return (value + alignment - 1) & ~(alignment - 1);
   }
 
-  size_t block_size_;
+  size_t initial_block_size_;
   size_t current_block_;
   size_t current_offset_;
   std::vector<std::unique_ptr<char[]>> blocks_;
+  std::vector<size_t> block_sizes_;
 };