Pool.hpp

Go to the documentation of this file.

// Copyright (c) Sleipnir contributors
 
#pragma once
 
#include <cstddef>
#include <memory>
 
#include "sleipnir/util/SymbolExports.hpp"
#include "sleipnir/util/small_vector.hpp"
 
namespace sleipnir {
 
class SLEIPNIR_DLLEXPORT PoolResource {
 public:
  explicit PoolResource(size_t blocksPerChunk)
      : blocksPerChunk{blocksPerChunk} {}
 
  PoolResource(const PoolResource&) = delete;
  PoolResource& operator=(const PoolResource&) = delete;
  PoolResource(PoolResource&&) = default;
  PoolResource& operator=(PoolResource&&) = default;
 
  [[nodiscard]]
  void* allocate(size_t bytes, [[maybe_unused]] size_t alignment =
                                   alignof(std::max_align_t)) {
    if (m_freeList.empty()) {
      AddChunk(bytes);
    }
 
    auto ptr = m_freeList.back();
    m_freeList.pop_back();
    return ptr;
  }
 
  void deallocate(
      void* p, [[maybe_unused]] size_t bytes,
      [[maybe_unused]] size_t alignment = alignof(std::max_align_t)) {
    m_freeList.emplace_back(p);
  }
 
  bool is_equal(const PoolResource& other) const noexcept {
    return this == &other;
  }
 
  size_t blocks_in_use() const noexcept {
    return m_buffer.size() * blocksPerChunk - m_freeList.size();
  }
 
 private:
  small_vector<std::unique_ptr<std::byte[]>> m_buffer;
  small_vector<void*> m_freeList;
  size_t blocksPerChunk;
 
  void AddChunk(size_t bytesPerBlock) {
    m_buffer.emplace_back(new std::byte[bytesPerBlock * blocksPerChunk]);
    for (int i = blocksPerChunk - 1; i >= 0; --i) {
      m_freeList.emplace_back(m_buffer.back().get() + bytesPerBlock * i);
    }
  }
};
 
template <typename T>
class PoolAllocator {
 public:
  using value_type = T;
 
  explicit constexpr PoolAllocator(PoolResource* r) : m_memoryResource{r} {}
 
  constexpr PoolAllocator(const PoolAllocator<T>& other) = default;
  constexpr PoolAllocator<T>& operator=(const PoolAllocator<T>&) = default;
 
  [[nodiscard]]
  constexpr T* allocate(size_t n) {
    return static_cast<T*>(m_memoryResource->allocate(n));
  }
 
  constexpr void deallocate(T* p, size_t n) {
    m_memoryResource->deallocate(p, n);
  }
 
 private:
  PoolResource* m_memoryResource;
};
 
SLEIPNIR_DLLEXPORT PoolResource& GlobalPoolResource();
 
template <typename T>
PoolAllocator<T> GlobalPoolAllocator() {
  return PoolAllocator<T>{&GlobalPoolResource()};
}
 
}  // namespace sleipnir