arena_allocator.h

/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
miniob is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
         http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details. */
 
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.
 
#pragma once
 
#include <atomic>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <vector>
 
class Arena
{
public:
  Arena();
 
  Arena(const Arena &)            = delete;
  Arena &operator=(const Arena &) = delete;
 
  ~Arena();
 
  // Return a pointer to a newly allocated memory block of "bytes" bytes.
  char *Allocate(size_t bytes);
 
  // Allocate memory with the normal alignment guarantees provided by malloc.
  char *AllocateAligned(size_t bytes);
 
  // Returns an estimate of the total memory usage of data allocated
  // by the arena.
  size_t MemoryUsage() const { return memory_usage_.load(std::memory_order_relaxed); }
 
private:
  char *AllocateFallback(size_t bytes);
  char *AllocateNewBlock(size_t block_bytes);
 
  // Allocation state
  char  *alloc_ptr_;
  size_t alloc_bytes_remaining_;
 
  // Array of new[] allocated memory blocks
  std::vector<char *> blocks_;
 
  // Total memory usage of the arena.
  //
  // TODO(costan): This member is accessed via atomics, but the others are
  //               accessed without any locking. Is this OK?
  std::atomic<size_t> memory_usage_;
};
 
inline char *Arena::Allocate(size_t bytes)
{
  // The semantics of what to return are a bit messy if we allow
  // 0-byte allocations, so we disallow them here (we don't need
  // them for our internal use).
  assert(bytes > 0);
  if (bytes <= alloc_bytes_remaining_) {
    char *result = alloc_ptr_;
    alloc_ptr_ += bytes;
    alloc_bytes_remaining_ -= bytes;
    return result;
  }
  return AllocateFallback(bytes);
}