std::pmr 多态内存分配器#

先回顾一下标准分配器#

这一节最好搭配侯捷的标准STL内存分配器来看，这样可以很好帮助理解一些动作的行为。

分配器的核心就是四个步骤： 分配空间（allocate），构造对象（construct），析构对象（destruct），解分配空间（deallocate）。

标准内存分配器就提供了这四个函数。多态内存分配器也提供了这四个函数。

• 在标准分配器当中，allocate和deallocate对应的全局的::operator new和::operator delete。construct和destruct对应的就是元素的构造和析构

为什么要有多态内存分配器#

在没有多态内存分配器的时候，我们面临两个问题。

第一种情况是内存分配器的传播问题。

我们有一个独特的例子：

• 我们有一个CustomString类，每一个对象接受一个allocator。我们现在有三个不同allocator的同类对象。注意此时对象类型均为CustomString。
• 然后我们放入vector。在push_back x1和x2的时候没什么问题，使用了对应的分配器。但是如果我们在头部插入了x3，情况就不对了。
• vector的头插逻辑是先在下一个可用位置分配一块内存，然后使用移动（拷贝）构造在新的位置构造出最后一个元素。然后再按照顺序把前面的元素搬移（拷贝）。在搬移（拷贝中），分配器是不会被拷贝（赋值）的。因为永远不该这么做，因为内存是已经被分配好了的，无法更改。
• 所以这个时候有问题了。x1用了alloc2，x3用了alloc1。瞬间混乱了起来。

我们真正想要的是这样的东西：

• 所以在C++17之前，我们有一个std::scoped_allocator_adaptor。我们可以把自己的分配器使用它包装，它可以保证分配器的正确传播：

std::scoped_allocator_adaptor 类模板是可用于多层容器（ map 的 list 的 set 的 vector 等等）的分配器。它以外层分配器类型 OuterAlloc 与零或更多个内层分配器类型 InnerAlloc... 实例化。直接以 scoped_allocator_adaptor 构造的容器用 OuterAlloc 分配其元素，但若元素自身是容器，则它使用首个内存分配器。该容器的元素，若其自身是容器，则使用第二个内存分配器，以此类推。若容器的层级多于内层分配器的数量，则最内层分配器为所有进一步内嵌的容器再度使用。

第二个问题是内存分配器固有的问题：

• 针对默认内存分配器本身的性能有如下问题：

  • 内存分配、回收慢。

  • 内存分配可能有锁。

  • 内存对齐无法控制。

  • 分配位置无法控制。比如连续多次分配时，内存的定域性/局部性(locality)无法保证。

• 针对使用的参数方面有如下问题（尤其针对std::allocator)

  • allocator是模板签名的一部分。不同allocator的容器，无法混用。

    • 1
      void func(const std::vector<int>&); // Default allocator
      2
      //上面的vector签名是：std::vector<int, std::allocator<int>>
      3
      std::vector<int, MyAlloc<int>> v(someAlloc); // 自定义分配器
      4
      func(v); // ERROR: v is a different type than std::vector<int>
      

    • 二者签名不匹配。我们尽管可以使用模板，但是这会让后面所有的函数都是模板。

  • c++11以前，allocator无状态；c++11以后，可以有状态，然而allocator类型复杂难用。

  • allocator内存对齐无法控制，需要传入自定义allocator。

  • 以上三点、特别是第一点，造成STL无法成为软件接口(interface)的一部分。

  • 难以将局部特种内存（比如共享内存），内存池用于STL容器。

多态内存分配器，内存资源和容器的关系#

memory_resource是获得的原始内存，我们拿到了原始内存后，通过polymorphic_allocator分配器来进行分配。最后容器需要使用分配器来给元素分配内存。说白了，分配器从内存资源中获得资源，然后进行内存的再分配。polymorphic_allocator分配器是一层memory_resource的包装。

• 多态内存分配器作用域下的容器是pmr::。其实就是别名模板。所以我们以vector为例：

1
namespace pmr {
2
    template< class T >
3
    using vector = std::vector<T, std::pmr::polymorphic_allocator<T>>;
4
}

由于多态内存分配器把内存资源的获取和分配分离开来，所以可以保证同一个元素哪怕底层内层资源不同，但是分配器的类型可以相同。

这部分的细节我们后面再细说。

1
std::vector<MyClass, std::pmr::polymorphic_allocator<MyClass> > vec = std::vector<MyClass, std::pmr::polymorphic_allocator<MyClass> >(allocator2);

内存资源 memory_resources#

• 上图是一个抽象简化版的内存资源类。我们看到里面有allocate和deallocate。这两个是非虚函数。他们的分配动作是委托给私有虚成员函数do_allocate和do_deallocate进行的。

  • 这里是模板方法模式的NVI（non-virtual-interface）技术。

• memory_resource是一个抽象基类。STL给我们提供了内置的5种内存资源和一些工具函数。

  • 我们如果要自己实现自己的内存资源，也需要继承自此类。

  • 类 std::pmr::memory_resource 是抽象接口，针对封装内存资源类的无界集。

• 继承自memory_resource的类需要实现的函数主要是四个

  • do_allocate

    • 从自身内存中分配特定大小的内存。
      • 具体定义会随之变化。比如从何处分配。

  • do_deallocate

    • 从自身内存中解分配某一特定位置，特定大小的区块。
      • 具体定义会随之变化。比如解分配到何处，是否真的解分配。

  • is_equal

    • 比较两个内存资源是否相等。也就是从当前这个内存资源分配的内存是否可以通过另一个内存资源解分配。

  • release

    • 调用上游的deallocate来释放内存。将全部内存交还给上游内存分配器。

• 内存资源是可以成为链条的。这一点我们下面讲。

• 注意内存资源类不是类模板！！！

1
monotonic_buffer_resource();                       //(1)
2
explicit monotonic_buffer_resource(std::pmr::memory_resource* upstream);  //(2)
3
explicit monotonic_buffer_resource(std::size_t initial_size);        //(3)
4
monotonic_buffer_resource(std::size_t initial_size, std::pmr::memory_resource* upstream);      //(4)
5
monotonic_buffer_resource(void* buffer, std::size_t buffer_size);      //(5)
6
monotonic_buffer_resource(void* buffer, std::size_t buffer_size, std::pmr::memory_resource* upstream);//(6)
7
monotonic_buffer_resource(const monotonic_buffer_resource&) = delete;    //(7)

1
class MyClass {
2
public:
3
    MyClass(int val = 0) : m_val(new int(val)) {
4
        std::cout << "MyClass constructed with value: " << val << std::endl;
5
    }
6
    ~MyClass() {
7
        std::cout << "MyClass destroyed with value: " << *m_val << std::endl;
8
        delete m_val;
9
    }
10
private:
11
    int* m_val;
12
};
13
int main() {
14
    char buffer[1024]; //从栈获取原始内存
15
    std::size_t buffer_size = sizeof(buffer);
16
    cout << "original "<<&buffer << endl; //原始内存地址
17
    {
18
        std::pmr::monotonic_buffer_resource buffer_resource{buffer, buffer_size, std::pmr::null_memory_resource()};
19
        //monotonic memory resource使用栈获取的资源做为初始资源，使用null_memory_resource当做上游分配器强调内存用尽后抛出bad_alloc而不是从默认分配器分配
20
        std::pmr::polymorphic_allocator<MyClass> allocator{ &buffer_resource }; //初始化分配器
21
        {
22
            MyClass* t = allocator.allocate(1); //分配1个Myclass对象 8字节
23
            cout << &t << endl; //获取指针地址
24
            cout << "1st alloc place "<<&*t << endl; //获取当前分配地址
25
            allocator.construct(t, 20); //在该地址构造元素
26

27
            MyClass* tt = allocator.allocate(1); //再分配1个Myclass对象 8字节
28
            cout << &tt << endl; //获取指针地址
29
            cout << "2nd alloc place  "<<&*tt << endl; //获取当前分配地址
30
            allocator.construct(tt, 30); //在该地址构造元素
31
//------------如果不destroy会泄露。因为deallocate解分配并不会调用元素的析构函数---------
32
            allocator.destroy(t); //析构元素
33
            allocator.destroy(tt); //析构元素
34
//----------使用release重置内存，把首地址推回分配起始地址（原始内存首地址）
35
            buffer_resource.release();
36

37
            MyClass* ttt = allocator.allocate(1); //再次分配1个Myclass对象
38
            cout << &ttt << endl;//获取指针地址
39
            cout << "3rd alloc place  "<<&*ttt << endl; //获取当前分配地址
40
            allocator.construct(ttt, 40);  //在该地址构造元素
41
            allocator.destroy(ttt);
42
        }
43
    }
44
    return 0;
45
}

1
original 0x7ffe4ff6eb90 起始地址
2
0x7ffe4ff6eb30
3
1st alloc place 0x7ffe4ff6eb90 起始地址和第一次分配地址一致
4
MyClass constructed with value: 20
5
0x7ffe4ff6eb38
6
2nd alloc place  0x7ffe4ff6eb98 第二次分配在第一次分配上+8
7
MyClass constructed with value: 30
8
MyClass destroyed with value: 20
9
MyClass destroyed with value: 30
10
0x7ffe4ff6eb40
11
3rd alloc place  0x7ffe4ff6eb90 release后指针推回至原生内存起始位置。
12
MyClass constructed with value: 40
13
MyClass destroyed with value: 40

1
char* buffer = new char[1024]; //堆内存。
2
std::size_t buffer_size = 1024;
3
{
4
    std::pmr::monotonic_buffer_resource buffer_resource{buffer, buffer_size, std::pmr::null_memory_resource()};
5
    std::pmr::polymorphic_allocator<MyClass> allocator{ &buffer_resource };
6
    {
7
        //...
8
    }
9
}
10
delete[] buffer; //回收内存

1
unsynchronized_pool_resource(); //(1)
2
explicit unsynchronized_pool_resource(std::pmr::memory_resource* upstream); //(2)
3
explicit unsynchronized_pool_resource(const std::pmr::pool_options& opts); //(3)
4
unsynchronized_pool_resource(const std::pmr::pool_options& opts,std::pmr::memory_resource* upstream); //(4)
5
unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete; //(5)

1
std::pmr::monotonic_buffer_resource buffer_resource{std::pmr::new_delete_resource()}; //最外层monotonic通过new_delete获取原始内存。
2
std::pmr::unsynchronized_pool_resource midlevel{&buffer_resource}; //第一层unsync池化
3
std::pmr::unsynchronized_pool_resource un_sync{&midlevel}; //第二层unsync 池化
4
std::pmr::polymorphic_allocator<MyClass> allocator{&un_sync};
5
{
6
    MyClass* t = allocator.allocate(1);
7
    cout << &t << endl;
8
    cout << "1st alloc place "<<&*t << endl;
9
    allocator.construct(t, 20);
10

11
    MyClass* tt = allocator.allocate(1);
12
    cout << &tt << endl;
13
    cout << "2nd alloc place  "<<&*tt << endl;
14
    allocator.construct(tt, 30);
15

16
    allocator.destroy(t);
17
    allocator.destroy(tt);
18

19
    un_sync.release(); //release内存资源。此行为会导致第一层unsync调用deallocate。回收已分配的内存到第一层unsync的内存池
20

21
    MyClass* ttt = allocator.allocate(1); //第二层unsync再次allocate
22
    cout << &ttt << endl;
23
    cout << "3rd alloc place  "<<&*ttt << endl;
24
    allocator.construct(ttt, 40);
25
    allocator.destroy(ttt);
26
}

1
0x7ffe69b80ed8
2
1st alloc place 0x559e13abbc00 //第一次分配
3
MyClass constructed with value: 20
4
0x7ffe69b80ee0
5
2nd alloc place  0x559e13abbc08 //第二次分配
6
MyClass constructed with value: 30
7
MyClass destroyed with value: 20
8
MyClass destroyed with value: 30
9
释放
10
0x7ffe69b80ee8
11
3rd alloc place  0x559e13abbc00 //第三次分配。地址同第一次。
12
MyClass constructed with value: 40
13
MyClass destroyed with value: 40

分配器 allocator#

我们提到过。分配器是一种对内存资源的包装

• 第二个转换构造函数非常有用。它的作用是我们可以直接把memory_resource传入任何需要polymorphic_allocator的地方。比如直接传入pmr::容器。

• 构造函数

1
polymorphic_allocator() noexcept; //(1)
2
polymorphic_allocator( const polymorphic_allocator& other ) = default; //(2)
3
template< class U >
4
polymorphic_allocator( const polymorphic_allocator<U>& other ) noexcept; //(3) 关键的构造函数模板。
5
polymorphic_allocator( memory_resource* r); //(4) 转换构造

第一个：默认构造函数会默认构造一个以默认值（通常为new_delete_resource）为内存资源的分配器

第二个：拷贝构造

第三个：构造函数模板。下面的模板参数以及正确转换全都靠它

第四个：是上文提到的转换构造。

• allocate

  • 用底层的 memory_resource 分配 n 个 T 类型对象的存储。

    等价于 return static_cast<T*>(resource()->allocate(n * sizeof(T), alignof(T))); 。

  • 由于我们提过，分配器是一种内存资源的wrapper。所以分配器调用的allocate就相当于对内存资源调用allocate。

  • 格外要注意的是，内存资源返回的内存是void*。而分配器返回的内存是对应类型的。

• deallocate

  • 解分配 p 所指向的存储，它必须通过与 *resource() 比较等于的（相等的）std::pmr::memory_resource x 使用 x.allocate(n * sizeof(T), alignof(T)) 分配。

    等价于 this->resource()->deallocate(p, n * sizeof(T), alignof(T));

  • 还是调用了底层内存资源的deallocate

• construct

  • 这玩意有一堆重载。主要是看第一个：

    • 1
      template < class U, class... Args >
      2
      void construct( U* p, Args&&... args ); //(1)
      

    • 在 p 所指的，分配但未初始化的存储上，以提供的构造函数参数构造一个对象。若对象自身拥有使用分配器的类型，或它是 std::pair ，则传递 this->resource() 给被构造的对象。

    • 以使用分配器构造的手段在 p 所指示的未初始化内存位置，以 *this 为分配器创建给定类型 U 的对象。

  • 说白了就如果提供了分配器，就使用提供的分配器构造。

• destroy

  • 销毁 p 所指向的对象，如同以调用 p->~U()

  • 所以我们强调了，dellocate解分配不调用内存位置上元素的析构函数。摧毁元素和回收内存是两个独立动作。

polymorphic_allocator 的模板参数#

有一些讲座说我们应该始终以std::byte为polymorphic_allocator 的模板参数。但是直觉来说，应该以元素类型为模板参数。

1
class MyClass {
2
public:
3
    MyClass(int val = 0) : m_val(new int(val)) {
4
        std::cout << "MyClass constructed with value: " << val << std::endl;
5
    }
6
    ~MyClass() {
7
        std::cout << "MyClass destroyed with value: " << *m_val << std::endl;
8
        delete m_val;
9
    }
10
private:
11
    int* m_val;
12
};
13
int main() {
14
    char buffer[1024];
15
    std::size_t buffer_size = 1024;
16
    {
17
        std::pmr::monotonic_buffer_resource buffer_resource{buffer, buffer_size, std::pmr::null_memory_resource()};
18
        //monotonic内存资源从已分配栈内存做为初始资源。并使用null做为上游资源
19
        std::pmr::polymorphic_allocator<MyClass> allocator{ &buffer_resource }; //版本1，分配器参数为元素类型：MyClass
20
        std::pmr::polymorphic_allocator<byte> allocator{ &buffer_resource }; //版本2，分配器参数为byte。
21
        {
22
            std::pmr::vector<MyClass> vec(allocator); //使用分配器初始化pmr vector
23
            vec.reserve(1);//预留一个空间
24
            vec.emplace_back(1);//原地构造一个对象
25
        }
26
    }
27
    return 0;
28
}

1
MyClass constructed with value: 1
2
MyClass destroyed with value: 1

• 注意关于monotonic内存资源和winkout的联系会在下一节讲。但是这里必须要提到一点，winkout和使用何种内存资源之间无任何联系。

两种分配器参数都可以正常工作。那么是什么原因呢？我们看一下这一行代码：

1
std::pmr::polymorphic_allocator<MyClass> allocator{ &buffer_resource };
2
std::pmr::vector<MyClass> vec(allocator); //此行展开

这一行代码展开后的样子是这样的：

1
std::vector<MyClass, std::pmr::polymorphic_allocator<MyClass>> vec = std::vector<MyClass, std::pmr::polymorphic_allocator<MyClass>>(allocator);

首先记住一点：allocator的模板参数一定会被推导为元素类型。因为别忘了上面提到的pmr是别名模板，元素类型是T，allocator的类型是根据T来的。

其次，我们发现如果分配器类型和元素类型一致，则顺利构造。左右两侧无区别。

但是如果我们换成byte呢？

1
std::pmr::polymorphic_allocator<byte> allocator{ &buffer_resource };
2
std::pmr::vector<MyClass> vec(allocator); //此行展开

这一行展开后是这样的：

1
std::vector<MyClass, std::pmr::polymorphic_allocator<MyClass>> vec = std::vector<MyClass, std::pmr::polymorphic_allocator<MyClass>>(std::pmr::polymorphic_allocator<MyClass>(allocator));

再次重申，allocator的模板参数一定会被推导为元素类型。同时，右侧括号内传入的分配器发生了隐式类型转换。调用的正是我们在分配器中提到的第三个构造函数。

所以理论上讲，此时行为都是一致的。而分配器本身的构造并不会造成性能的过多损失。但是有一点要注意，隐式类型转换后，传入的分配器是那个转换后的临时对象。所以现在vector内部的分配器和外面传入的allocator其实是两个独立对象了。一定要注意。最好还是使用和元素一样类型的分配器。

我的提问

分配器种类，分配器绑定方式和析构的组合#

目前为止，分配器绑定方式可以分为两种

• 类型参数（模板参数）
• 继承自抽象基类，比如：

  • 

  • 注意这里不是继承自std::allocator。一般也不应该这样做。原因见这里

  • 

目前为止，分配器内存来源可以分为这么几种

• 默认全局分配器（std::allocator)

  • 绑定方式一定是类型参数

• New_Delete_Allocator

  • 和默认全局分配器原理一致，但是绑定方式一定是继承自抽象基类

• 多态内存资源

  • 如monotonic_buffer_resource，unsync/synchronized_pool_resource等

析构方式又可以分为两种：

• 常规析构
• wink-out

所以，一共我们可以得到这么多种搭配组合

wink-out 和 常规析构#

首先注意，wink-out适用于任何内存资源。我们还记得容器分配构造的四个步骤：分配空间，构造对象，析构对象，解分配空间。

wink-out就是不析构，直接解分配。所以使用wink-out的时候一定要注意，如果内存区域的元素是含有额外资源的，则不可以winkout。会导致内存泄漏。

• 我们看一下常规析构：

一切都很正常。标准的四个步骤。

• 我们再来看一下所谓的winked-out

核心意思就是我们不再需要析构和解分配两个步骤

不需要析构非常好理解，因为如果某些对象没有保有其他资源，也就是析构函数是trivial的时候，调用析构是没有意义的。所以可以不调用这些析构。

不需要deallocate如何理解呢？一般情况下，通常只针对monotonic_buffer_resource使用winkout。因为它的deallocate是无作用。只有在析构的时候才会把资源交还给上游分配器。当然了，标准库提供的所有内存资源都符合RAII特性，在析构的时候都会把内存交还给上游分配器。所以这里不使用deallocate也是可以的。一定要记住，所有解分配deallocate都不会调用元素的析构函数。所以要注意内存泄漏问题，使用这个技巧之前一定要清楚自己在做什么。

我们来看个特殊例子，因为有时候容易错误理解：

1
int main() {
2
    char buffer[1024];
3
    std::size_t buffer_size = 1024;
4
    {
5

6
        std::pmr::monotonic_buffer_resource buffer_resource{buffer, buffer_size, std::pmr::null_memory_resource()};
7
        //外层monotonic原始内存
8
        std::pmr::polymorphic_allocator<MyClass> allocator{ &buffer_resource }; //分配器
9
        {
10
            std::pmr::vector<MyClass> t(allocator); //分配器传入pmr vector
11
            t.reserve(1); //预留1个位置
12
            t.emplace_back(20); //原地构造元素
13
        }
14
    }
15
    return 0;
16
}

1
MyClass constructed with value: 20
2
MyClass destroyed with value: 20

奇怪？明明我们没有手动对内存资源进行操作，怎么会正确析构呢？因为这是pmr::vector帮助我们做的。因为它毕竟还是vector。还是会在vector被销毁的时候帮助我们对元素进行析构。

std::vector<T,Allocator>::~vector：调用元素的析构函数，然后解分配所用的存储。

自定义分配器的相等比较#

参考来自这里

[operator ==(a1, a2)] returns true only if the storage allocated by the allocator a1 can be deallocated through a2. Establishes reflexive, symmetric, and transitive relationship. Does not throw exceptions. operator ==(a1, a2)仅当分配器 a1 分配的存储可以通过分配器 a2 释放时才返回 true。建立了自反、对称和传递关系。不抛出异常。

一般来说，如果两个分配器相等，那么在移动一个容器至另一个容器的时候可以直接交换指针，在第二个容器重用第一个容器的内存。如果分配器不相等，则必须要在第二个容器中重新分配内存，然后复制每一个元素，然后释放第一个容器。

针对如何实现内存资源，和如何实现使用多态内存分配器的容器，可以看看下面参考资料的内容

参考资料#

CppCon 2017针对如何实现内存资源和自己的使用分配器的容器

CppCon 2019针对如何实现带有多态内存分配器的类和容器类

CppCon 2017理解并测试分配器

游戏引擎新感觉

CSDN的pmr

分配器，内存资源，容器的关联

polymorphic allocator的模板参数

如何测试wink-out

memory_source的LLVM源代码 和 LLVM最终源代码