default_allocator.h

//   Copyright Giuseppe Campana (giu.campana@gmail.com) 2016-2018.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#pragma once
#include <density/density_common.h>
#include <density/detail/page_allocator.h>
#include <density/detail/system_page_manager.h>

namespace density
{
    template <size_t PAGE_CAPACITY_AND_ALIGNMENT> class basic_default_allocator;

    using default_allocator = basic_default_allocator<default_page_capacity>;

    template <size_t PAGE_CAPACITY_AND_ALIGNMENT = default_page_capacity>
    class basic_default_allocator
    {
      private:
        using PageAllocator =
          detail::PageAllocator<typename detail::SystemPageManager<PAGE_CAPACITY_AND_ALIGNMENT>>;

      public:
        static constexpr size_t page_size = PageAllocator::page_size;

        static constexpr size_t page_alignment = PageAllocator::page_alignment;

        void * allocate(size_t i_size, size_t i_alignment, size_t i_alignment_offset = 0)
        {
            return density::aligned_allocate(i_size, i_alignment, i_alignment_offset);
        }

        void *
          try_allocate(size_t i_size, size_t i_alignment, size_t i_alignment_offset = 0) noexcept
        {
            return density::try_aligned_allocate(i_size, i_alignment, i_alignment_offset);
        }

        void deallocate(
          void * i_block, size_t i_size, size_t i_alignment, size_t i_alignment_offset = 0) noexcept
        {
            density::aligned_deallocate(i_block, i_size, i_alignment, i_alignment_offset);
        }

        void * allocate_page()
        {
            auto const new_page =
              PageAllocator::thread_local_instance()
                .template try_allocate_page<detail::page_allocation_type::uninitialized>(
                  progress_blocking);
            if (new_page == nullptr)
                throw std::bad_alloc();
            return new_page;
        }

        void * try_allocate_page(progress_guarantee i_progress_guarantee) noexcept
        {
            return PageAllocator::thread_local_instance()
              .template try_allocate_page<detail::page_allocation_type::uninitialized>(
                i_progress_guarantee);
        }

        void * allocate_page_zeroed()
        {
            auto const new_page =
              PageAllocator::thread_local_instance()
                .template try_allocate_page<detail::page_allocation_type::zeroed>(
                  progress_blocking);
            if (new_page == nullptr)
                throw std::bad_alloc();
            return new_page;
        }

        void * try_allocate_page_zeroed(progress_guarantee i_progress_guarantee) noexcept
        {
            return PageAllocator::thread_local_instance()
              .template try_allocate_page<detail::page_allocation_type::zeroed>(
                i_progress_guarantee);
        }

        void deallocate_page(void * i_page) noexcept
        {
            DENSITY_ASSUME(i_page != nullptr);
            PageAllocator::thread_local_instance()
              .template deallocate_page<detail::page_allocation_type::uninitialized>(i_page);
        }

        void deallocate_page_zeroed(void * i_page) noexcept
        {
            PageAllocator::thread_local_instance()
              .template deallocate_page<detail::page_allocation_type::zeroed>(i_page);
        }

        static void reserve_lockfree_page_memory(size_t i_size, size_t * o_reserved_size = nullptr)
        {
            if (!try_reserve_lockfree_page_memory(progress_blocking, i_size, o_reserved_size))
            {
                throw std::bad_alloc();
            }
        }

        static bool try_reserve_lockfree_page_memory(
          progress_guarantee i_progress_guarantee,
          size_t             i_size,
          size_t *           o_reserved_size = nullptr) noexcept
        {
            auto const reserved_size =
              PageAllocator::thread_local_instance().try_reserve_lockfree_memory(
                i_progress_guarantee, i_size);
            if (o_reserved_size != nullptr)
                *o_reserved_size = reserved_size;
            return reserved_size >= i_size;
        }

        void pin_page(void * i_page) noexcept { PageAllocator::pin_page(i_page); }

        void unpin_page(void * i_address) noexcept { PageAllocator::unpin_page(i_address); }

        bool try_pin_page(progress_guarantee i_progress_guarantee, void * i_address) noexcept
        {
            return PageAllocator::try_pin_page(i_progress_guarantee, i_address);
        }

        void unpin_page(progress_guarantee i_progress_guarantee, void * i_address) noexcept
        {
            return PageAllocator::unpin_page(i_progress_guarantee, i_address);
        }

        uintptr_t get_pin_count(const void * i_address) noexcept
        {
            return PageAllocator::get_pin_count(i_address);
        }

        bool operator==(const basic_default_allocator &) const noexcept { return true; }

        bool operator!=(const basic_default_allocator &) const noexcept { return false; }
    };

} // namespace density