binary_page_memory_resource_impl.hpp

/*
 * VecMem project, part of the ACTS project (R&D line)
 *
 * (c) 2021-2025 CERN for the benefit of the ACTS project
 *
 * Mozilla Public License Version 2.0
 */
 
#pragma once
 
// Local include(s).
#include "vecmem/memory/memory_resource.hpp"
#include "vecmem/memory/unique_ptr.hpp"
 
// System include(s).
#include <cstddef>
#include <functional>
#include <memory>
#include <optional>
#include <vector>
 
namespace vecmem::details {

struct binary_page_memory_resource_impl {
    static constexpr std::size_t min_superpage_size = 20;

    static constexpr std::size_t delta_superpage_size = 8;

    static constexpr std::size_t min_page_size = 8;

    explicit binary_page_memory_resource_impl(memory_resource &upstream);

    enum class page_state { OCCUPIED, VACANT, SPLIT, NON_EXTANT };

    struct superpage {
        superpage(std::size_t, memory_resource &, std::size_t);

        std::size_t total_pages() const;

        std::size_t m_size;

        std::size_t m_min_page_size;

        std::size_t m_num_pages;

        std::unique_ptr<page_state[]> m_pages;

        unique_alloc_ptr<std::byte[]> m_memory;
    };

    struct page_ref {
    public:
        page_ref() = delete;

        page_ref(const page_ref &) = default;

        page_ref(page_ref &&) = default;

        page_ref(superpage &, std::size_t);

        page_ref &operator=(page_ref &&) = default;

        page_ref &operator=(const page_ref &) = default;

        bool operator==(const page_ref &) const;

        bool operator!=(const page_ref &) const;

        std::size_t get_size() const;

        page_state get_state() const;

        void *get_addr() const;

        page_ref left_child() const;

        page_ref right_child() const;

        std::optional<page_ref> parent() const;

        std::optional<page_ref> sibling() const;

        void unsplit();

        void split();

        void change_state_vacant_to_occupied();

        void change_state_occupied_to_vacant();

        void change_state_non_extant_to_vacant();

        void change_state_vacant_to_non_extant();

        void change_state_vacant_to_split();

        void change_state_split_to_vacant();

        std::size_t get_index();
 
    private:
        std::reference_wrapper<superpage> m_superpage;
        std::size_t m_page;
    };


    void *allocate(std::size_t size, std::size_t align);
    void deallocate(void *p, std::size_t size, std::size_t align);


    std::optional<page_ref> find_free_page(std::size_t, std::size_t);

    void allocate_upstream(std::size_t, std::size_t);
 
    memory_resource &m_upstream;
    std::vector<superpage> m_superpages;
 
};  // struct binary_page_memory_resource_impl
 
}  // namespace vecmem::details