Linux C+中的页对齐内存分配+； 假设，我需要在LIUX64 C++应用程序中分配一个大的向量。 我做了以下工作： int main() { std::vector<int> v; v.resize(2000); std::cout << &v[0] << std::endl; return 0; } intmain（） { std：：向量v； v、 （2000年）； std:：cout

您可以定义页面分配器：

#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;}
  };

#包括
#包括
#包括
#包括
模板
结构页分配器{
使用值_type=T；
静态自动内存大小（标准：：大小）{
n=n*sizeof（T）；
返回（n&（页面掩码）+（n&~（页面掩码）？页面大小：0）；
}
T*分配（标准：：大小\u T n）{
自动p=mmap（0，内存大小）（n）
，PROT|u READ | PROT|u WRITE，MAP|u PRIVATE | MAP|u ANONYMOUS，-1,0）；
如果（p==MAP_失败）抛出std:：bad_alloc{}；
返回静态_-cast（p）；
}
无效解除分配（T*p，std:：size\u T n）{
munmap（p，mem_size_表示（n））；
}
constexpr bool运算符==（页面分配器）noexcept{return true；}
constexpr bool运算符！=（页面分配器）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;
}

intmain（）
{
std：：向量v；
v、 调整大小（页面大小/sizeof（int））；
std:：cout打印的不是为向量数据本身分配的内存地址，而是为向量对象分配的变量
v
。数据的位置是
&v[0]
（或
v.data（）
）标准库没有支持用户定义的对齐的分配器。但是，Boost确实如此：像C++这样的高级语言不关心OS提供的底层内存管理系统。为什么你会关心这个问题？最后，这个问题似乎是：你请求帮助解决一个未知的（对我们来说）。问题。请试着询问您的实际问题，我们可能会为您提供其他（也许更好）的解决方案。@Tampler“因此我认为我需要在操作系统内核级别控制这一点”确实如此。这个
posix_memalign
是否比
aligned_alloc
性能更好？@sandthorn，我已经查看了glibc的malloc.c源文件。
aligned_alloc
必须性能更好。
posix_memalign
是一个
aligned_alloc
检查对齐有效性并设置错误号。
#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;}
  };