iffl_allocator.h

Go to the documentation of this file.

#pragma once


#include <iffl_config.h>
#include <iffl_common.h>

namespace iffl {

class debug_memory_resource 
    : public FFL_PMR::memory_resource {

public:

    debug_memory_resource() = default;

    ~debug_memory_resource() noexcept {
        validate_no_busy_blocks();
    }

    size_t get_busy_blocks_count() const noexcept {
        return busy_blocks_count_.load(std::memory_order_relaxed);
    }

    void validate_no_busy_blocks() const noexcept {
        FFL_CODDING_ERROR_IF(0 < get_busy_blocks_count());
    }

private:

    using pattern_type = size_t;   
    struct prefix_t {
        size_t size;
        size_t alignment;
        debug_memory_resource *memory_resource;
        pattern_type pattern;
    };
    struct suffix_t {
        pattern_type pattern;
    };
    constexpr static size_t min_allocation_size{ sizeof(prefix_t) + sizeof(suffix_t) };

    constexpr static pattern_type busy_block_prefix_pattern{ 0xBEEFABCD };
    constexpr static pattern_type free_block_prefix_pattern{ 0xBEEFABCE };
    constexpr static pattern_type busy_block_suffix_pattern{ 0xDEADABCD };
    constexpr static pattern_type free_block_suffix_pattern{ 0xDEADABCE };

    constexpr static int fill_pattern{ 0xFE };
    void* do_allocate(size_t bytes, [[maybe_unused]] size_t alignment) override {

        size_t bytes_with_debug_info = bytes + min_allocation_size;
        void *ptr = FFL_ALLIGNED_ALLOC(bytes_with_debug_info, alignment);
        if (nullptr == ptr) {
            throw std::bad_alloc{};
        }

        prefix_t *prefix{ static_cast<prefix_t *>(ptr) };
        suffix_t *suffix{ reinterpret_cast<suffix_t *>( static_cast<char *>(ptr) + bytes_with_debug_info) - 1 };

        prefix->size = bytes_with_debug_info;
        prefix->alignment = alignment;
        prefix->memory_resource = this;
        prefix->pattern = busy_block_prefix_pattern;
        suffix->pattern = busy_block_suffix_pattern;

        increment_busy_block_count();

        char *user_buffer = reinterpret_cast<char *>(prefix + 1);
        fill_buffer(user_buffer, fill_pattern, bytes);

        return user_buffer;
    }
    void do_deallocate(void* p, size_t bytes, [[maybe_unused]] size_t alignment) noexcept override {

        decrement_busy_block_count();

        prefix_t *prefix{ static_cast<prefix_t *>(p) - 1 };
        FFL_CODDING_ERROR_IF_NOT(prefix->pattern == busy_block_prefix_pattern);
        FFL_CODDING_ERROR_IF_NOT(prefix->memory_resource == this);
        FFL_CODDING_ERROR_IF_NOT(prefix->size > min_allocation_size);
        size_t const user_allocation_size = prefix->size - min_allocation_size;
        FFL_CODDING_ERROR_IF_NOT(user_allocation_size == bytes);
        FFL_CODDING_ERROR_IF_NOT(prefix->alignment == alignment);
        suffix_t *suffix{ reinterpret_cast<suffix_t *>(reinterpret_cast<char *>(prefix) + prefix->size) - 1 };
        FFL_CODDING_ERROR_IF_NOT(suffix->pattern == busy_block_suffix_pattern);

        prefix->memory_resource = nullptr;
        prefix->pattern = free_block_prefix_pattern;
        suffix->pattern = free_block_suffix_pattern;

        FFL_ALLIGNED_FREE(prefix);
    }
    bool do_is_equal(memory_resource const & other) const noexcept override {
        return (&other == this);
    }
    void increment_busy_block_count() noexcept {
        size_t const prev_busy_blocks_count = busy_blocks_count_.fetch_add(1, std::memory_order_relaxed);
        FFL_CODDING_ERROR_IF_NOT(prev_busy_blocks_count >= 0);
    }
    void decrement_busy_block_count() noexcept {
        size_t const prev_busy_blocks_count = busy_blocks_count_.fetch_sub(1, std::memory_order_relaxed);
        FFL_CODDING_ERROR_IF_NOT(prev_busy_blocks_count > 0);
    }
    std::atomic<size_t> busy_blocks_count_{ 0 };
};


class input_buffer_memory_resource
    : public FFL_PMR::memory_resource {

public:
    explicit input_buffer_memory_resource(void *buffer, 
                                          size_t buffer_size) noexcept
        : used_(buffer ? false : true)
        , buffer_{buffer}
        , buffer_size_{ buffer_size } {
    }

    ~input_buffer_memory_resource() noexcept {
        validate_no_busy_blocks();
    }

    size_t get_busy_blocks_count() const noexcept {
        return (used_ ? 1 : 0);
    }

    void validate_no_busy_blocks() const noexcept {
        FFL_CODDING_ERROR_IF(0 < get_busy_blocks_count());
    }

protected:

    void* do_allocate(size_t bytes, [[maybe_unused]] size_t alignment) override {
        if (!used_ && buffer_ && bytes <= buffer_size_) {
            used_ = true;
            return buffer_;
        } else {
            throw std::bad_alloc{};
        }
    }
    void do_deallocate(void* p, size_t bytes, [[maybe_unused]] size_t alignment) noexcept override {
        FFL_CODDING_ERROR_IF_NOT(p == buffer_ && bytes <= buffer_size_);
        used_ = false;
    }

    bool do_is_equal(memory_resource const & other) const noexcept override {
        return (&other == this);
    }

private:
    bool used_{ false };
    void *buffer_{ nullptr };
    size_t buffer_size_{ 0 };
};

} // namespace iffl