slab_allocator.hpp

#pragma once
#include "./assert.hpp"
#include "./log.hpp"
#include <list>
#include <map>
#include <memory>
#include <unordered_map>
#ifndef NO_MULTITHREADING
#include <mutex>
#endif
 
namespace barretenberg {
 
void init_slab_allocator(size_t circuit_subgroup_size);
 
std::shared_ptr<void> get_mem_slab(size_t size);
 
void* get_mem_slab_raw(size_t size);
 
void free_mem_slab_raw(void*);
 
template <typename T> class ContainerSlabAllocator {
  public:
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using size_type = std::size_t;
 
    template <typename U> struct rebind {
        using other = ContainerSlabAllocator<U>;
    };
 
    pointer allocate(size_type n)
    {
        // info("ContainerSlabAllocator allocating: ", n * sizeof(T));
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
        return reinterpret_cast<pointer>(get_mem_slab_raw(n * sizeof(T)));
    }
 
    void deallocate(pointer p, size_type /*unused*/) { free_mem_slab_raw(p); }
 
    friend bool operator==(const ContainerSlabAllocator<T>& /*unused*/, const ContainerSlabAllocator<T>& /*unused*/)
    {
        return true;
    }
 
    friend bool operator!=(const ContainerSlabAllocator<T>& /*unused*/, const ContainerSlabAllocator<T>& /*unused*/)
    {
        return false;
    }
};
 
} // namespace barretenberg