Linux C++ 中的页面对齐内存分配

Question

假设，我需要在 Linux64 C++ 应用程序中分配一个大向量。 我执行以下操作：

int main()
{
  std::vector<int> v;
  v.resize(2000);

  std::cout << &v[0] << std::endl;

  return 0;
}

这会在我的笔记本电脑上打印 0x7ffc2a177450，这是字对齐的。 但是，Vector 大小为 2000*4B = 8kB，在我的 4kB 页 Ubuntu 系统上正好是 2 页。

问题：如何将我的 Vector 放在页面的开头，以便分配在物理内存中准确地产生 2 个页面？ 理想情况下，物理内存中的两个页面也应该是连续的。 谢谢！

Answer 1

您可以定义一个页面分配器：

#include <sys/user.h>
#include <sys/mman.h>
#include <cstddef>
#include <new>
template<class T>
struct page_allocator{
    using value_type = T;
    static auto mem_size_for(std::size_t n){
      n = n * sizeof(T);
      return (n & (PAGE_MASK)) + (n & ~(PAGE_MASK) ? PAGE_SIZE:0);
      }
    T* allocate(std::size_t n){
      auto p = mmap(0, mem_size_for(n)
                   ,PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
      if (p==MAP_FAILED) throw std::bad_alloc{};
      return static_cast<T*>(p);
      }
    void deallocate(T* p,std::size_t n){
      munmap(p,mem_size_for(n));
      }
    constexpr bool operator==(page_allocator)noexcept{return true;}
    constexpr bool operator!=(page_allocator)noexcept{return false;}
  };

并以这种方式使用它：

int main()
{
  std::vector<int,page_allocator<int>> v;
  v.resize(PAGE_SIZE/sizeof(int));

  std::cout << &v[0] << std::endl;

  return 0;
}

其他选项，使用 posix_memalign：

#include <cstddef>
#include <new>
#include <stdlib.h>
template<class T>
struct memalign_allocator{
    using value_type = T;
    T* allocate(std::size_t n){
      void* p;
      if (posix_memalign(&p,PAGE_SIZE,n*sizeof(T))) throw std::bad_alloc{};
      return static_cast<T*>(p);
      }
    void deallocate(T* p,std::size_t n){
      free(p);
      }
    constexpr bool operator==(memalign_allocator)noexcept{return true;}
    constexpr bool operator!=(memalign_allocator)noexcept{return false;}
  };

使用aligned_alloc 会执行得更好。

Answer 2

这是用于 Posix 和 Linux 的成熟的 C++23 兼容的页面对齐分配器：

#pragma once
#if defined(_WIN32)
    #include <Windows.h>
#elif defined(__unix__)
    #include <unistd.h>
    #include <sys/mman.h>
#else
    #error platform not supported
#endif
#include <cstddef>
#include <type_traits>
#include <memory>
#include <utility>
#include <atomic>
#include <cassert>
#include <new>
#if !defined(NDEBUG)
    #include <bit>
#endif
#include <utility>

template <typename T>
struct virtual_allocator
{
    using allocator_type = virtual_allocator;
    using value_type = T;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using propagate_on_container_move_assignment = std::false_type;
    constexpr virtual_allocator() noexcept {}
    constexpr virtual_allocator( virtual_allocator const & ) noexcept {}
    template<typename T2>
    constexpr virtual_allocator( virtual_allocator<T2> const & ) noexcept {}
    static value_type *allocate( std::size_t n );
    static void deallocate( value_type *p, std::size_t n ) noexcept;
    static void reset( void *p, std::size_t n )
        requires (sizeof(T) == std::bit_floor( sizeof(T) )) && std::is_trivial_v<T>;
    static std::size_t get_page_size();
#if defined(__cpp_lib_allocate_at_least)
    static std::allocation_result<value_type *> allocate_at_least( std::size_t n );
#endif
private:
    using alloc_ret_t = std::pair<value_type *, std::size_t>;
    static alloc_ret_t allocateAtLeast( std::size_t n );
    static std::size_t getPageSize();
};

template <typename T>
typename virtual_allocator<T>::value_type *virtual_allocator<T>::allocate( std::size_t n )
{
    return allocateAtLeast( n ).first;
}

template <typename T>
void virtual_allocator<T>::deallocate( value_type *p, std::size_t n ) noexcept
{
    std::size_t pageSize = getPageSize();
    assert(n * pageSize / pageSize == n);
    n = n * pageSize + pageSize - 1 & -(ptrdiff_t)pageSize;
#if defined(_WIN32)
    bool succ = (bool)VirtualFree( p, 0, MEM_RELEASE );
#elif defined(__unix__)
    bool succ = !munmap( p, n );
#endif
    assert(succ);
}

#if defined(__cpp_lib_allocate_at_least)
template <typename T>
std::allocation_result<typename virtual_allocator<T>::value_type *> virtual_allocator<T>::allocate_at_least( std::size_t n )
{
    auto ret = allocateAtLeast( n );
    return std::allocation_result<value_type *>( ret.first, ret.second );
}
#endif

template <typename T>
typename virtual_allocator<T>::alloc_ret_t virtual_allocator<T>::allocateAtLeast( std::size_t n )
{
    using namespace std;
    if( n * sizeof(value_type) / sizeof(value_type) != n )
        throw bad_alloc();
    size_t pageSize = getPageSize();
    n = n * sizeof(value_type) + pageSize - 1 & -(ptrdiff_t)pageSize;
#if defined(_WIN32)
    value_type *p = (value_type *)VirtualAlloc( nullptr, n, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE );
#elif defined(__unix__)
    value_type *p = (value_type *)mmap( nullptr, n, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0 );
#endif
    if( !p )
        throw bad_alloc();
    return alloc_ret_t( p, n / sizeof(value_type) );
}

template <typename T>
void virtual_allocator<T>::reset( void *p, std::size_t n )
    requires (sizeof(T) == std::bit_floor( sizeof(T) )) && std::is_trivial_v<T>
{
    using namespace std;
    size_t pageSize = getPageSize();
    if( ((size_t)p | n) & pageSize - 1 || n * sizeof(value_type) / sizeof(value_type) != n )
        throw bad_alloc();
#if defined(_WIN32)
    bool succ = (bool)VirtualAlloc( p, n, MEM_RESET, PAGE_READWRITE );
#elif defined(__unix__)
    bool succ = !madvise( p, n, MADV_DONTNEED );
#endif
    assert(succ);
}

template <typename T>
inline
std::size_t virtual_allocator<T>::get_page_size()
{
    return getPageSize();
}

template <typename T>
inline
std::size_t virtual_allocator<T>::getPageSize()
{
    using namespace std;
    static atomic<size_t> aPageSize( 0 );
    size_t pageSize = aPageSize.load( memory_order_relaxed );
    if( !pageSize ) [[unlikely]]
    {
#if defined(_WIN32)
        SYSTEM_INFO si;
        GetSystemInfo( &si );
        pageSize = si.dwPageSize;
#elif defined(__unix__)
        pageSize = sysconf( _SC_PAGESIZE );
#endif
        assert(pageSize && pageSize == bit_floor( pageSize ));
        aPageSize.store( pageSize, memory_order_relaxed );
    }
    return pageSize;
}

我有重置某些页面的个人要求，即将它们标记为可被内核丢弃。 因此，我有一个额外的 reset() 方法，它不需要 value_type 指针，而是一个裸指针，因为我需要计算调用者的页面对齐。 因此，我有一个额外的 get_page_size() 方法，如果 value_type 具有两倍大小的幂并且它是一个微不足道的数据类型，则可以调用该方法。
我的分配器的一个很好的特性是它支持 C++23 的 allocate_at_least()。 此方法分配 n 个项目，类似于 allocate()，但不仅返回一个裸指针，而且还返回一个参数，该参数报告实际分配的整个块中实际适合多少项目。 这是为了防止页面四舍五入。