pool_memory_resource.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Copyright (c) 2026 Daniel Polo
 
#ifndef IT_D4NP_MEMORYPOOL_POOL_MEMORY_RESOURCE_HPP_
#define IT_D4NP_MEMORYPOOL_POOL_MEMORY_RESOURCE_HPP_
 
#include <it/d4np/memorypool/memory_pool.hpp>
 
#if defined(__has_include)
#if __has_include(<memory_resource>)
#include <memory_resource>
#endif
#endif
 
// Availability gate (see the @file note). This drives `#if` here, in the
// dedicated test, and in consumer code, so it must be a preprocessor macro
// rather than a constexpr constant — hence the macro-usage suppression.
/* NOLINTBEGIN(cppcoreguidelines-macro-usage) */
#if defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 201603L
#define PBR_MEMORY_POOL_HAS_PMR 1
#else
#define PBR_MEMORY_POOL_HAS_PMR 0
#endif
/* NOLINTEND(cppcoreguidelines-macro-usage) */
 
#if PBR_MEMORY_POOL_HAS_PMR
 
#include <cstddef>
#include <new>
 
namespace it::d4np::memorypool {
 
class PoolMemoryResource : public std::pmr::memory_resource {
public:
    explicit PoolMemoryResource(Pool& pool,
                                std::pmr::memory_resource* upstream = std::pmr::get_default_resource()) noexcept
        : pool_(&pool), upstream_(upstream) {}
 
    [[nodiscard]] Pool& pool() const noexcept {
        return *pool_;
    }
 
    [[nodiscard]] std::pmr::memory_resource* upstream_resource() const noexcept {
        return upstream_;
    }
 
private:
    // The `(bytes, alignment)` pair is the std::pmr::memory_resource override
    // signature and cannot be restructured into a parameter struct.
    // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
    void* do_allocate(std::size_t bytes, std::size_t alignment) override {
        if (routes_to_pool(bytes, alignment)) {
            void* const block = pool_->try_allocate();
            if (block == nullptr) {
                throw std::bad_alloc{};
            }
            return block;
        }
        return upstream_->allocate(bytes, alignment);
    }
 
    // Fixed override signature — see ::do_allocate.
    // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
    void do_deallocate(void* ptr, std::size_t bytes, std::size_t alignment) override {
        if (routes_to_pool(bytes, alignment)) {
            pool_->deallocate(ptr);
            return;
        }
        upstream_->deallocate(ptr, bytes, alignment);
    }
 
    [[nodiscard]] bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override {
        const auto* const rhs = dynamic_cast<const PoolMemoryResource*>(&other);
        return rhs != nullptr && rhs->pool_ == pool_ && rhs->upstream_ == upstream_;
    }
 
    // Mirrors the std::pmr `(bytes, alignment)` shape — see ::do_allocate.
    // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
    [[nodiscard]] bool routes_to_pool(std::size_t bytes, std::size_t alignment) const noexcept {
        return bytes <= pool_->block_size() && alignment <= alignof(std::max_align_t);
    }
 
    Pool* pool_;
    std::pmr::memory_resource* upstream_;
};
 
}  // namespace it::d4np::memorypool
 
#endif  // PBR_MEMORY_POOL_HAS_PMR
 
#endif  // IT_D4NP_MEMORYPOOL_POOL_MEMORY_RESOURCE_HPP_