Modern C++ 内存篇1 - std::allocator VS pmr

2024-02-09 09:52
文章标签 c++ 内存 vs std modern allocator pmr

本文主要是介绍Modern C++ 内存篇1 - std::allocator VS pmr，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

大年三十所写，看到就点个赞吧！祝读者们龙年大吉！当然有问题欢迎评论指正。
在这里插入图片描述

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

1. 前言

从今天起我们开始内存相关的话题，内存是个很大的话题，一时不知从何说起。内存离不开allocator，我们就从allocator开始吧。allocator目前有两种：std::allocator, std::pmr::polymorphic_allocator，各有优缺点。
上来就长篇大论容易显得枯燥，我们还是抛出一个例子然后提出问题，通过问题慢慢深入吧。

2. 分配器例子

下面这个例子是我很久以前从一个网站上copy下来的。是个不错的用来快速学习的例子。作者当时留了个疑问没解决：为什么预分配内存的pmr反而效率更低哪？
这也是本节我们要解决的问题，从中也可以学到allocator和polymorphic_allocator的优缺点对比。

#include<iostream>
#include<memory_resource>
#include<vector>
#include "../PerfSum.hpp"
using namespace std;void TestPmrVec(){char buffer[1000000*4] = {0};std::pmr::monotonic_buffer_resource mbr{ std::data(buffer), std::size(buffer) };std::pmr::polymorphic_allocator<int> pa{&mbr};std::pmr::vector<int> vec{pa};//vec.push_back(0);//vec.push_back(1);PerfSum t;for(int i=0;i<1000000;i++){vec.push_back(i);}std::cout<<"End"<<std::endl;}void TestStdVec(){std::vector<int> vec ;PerfSum t;//vec.push_back(0);//vec.push_back(1);for(int i=0;i<1000000;i++){vec.push_back(i);}std::cout<<"End"<<std::endl;}int main() {std::cout<<"std vector cost:"<<std::endl;TestStdVec();std::cout<<"pmr vector cost:"<<std::endl;TestPmrVec();
}

其中PerfSum.hpp在《Modern C++ idiom3：RAII》中有提到。编译运行结果：

[mzhai@std_polymorphic_pmr]$ g++ compare_speed.cpp -std=c++17 -g
[mzhai@std_polymorphic_pmr]$ ./a.out
std vector cost:
Endtook 19171 microseconds.
pmr vector cost:
Endtook 56134 microseconds.

可见pmr反而比普通的vector慢了大约3倍。
这里我还是坚持我一贯的写作风格：先preview结果给大家，尽量一句话说明白，没时间的读者可以节约时间去干点别的，有时间且有兴趣了解细节的读者可以慢慢往下看。
preview：虽然pmr预分配的内存空间，但是后面vector既有capacity不够时需要copy/move旧的数据到新分配的空间去，pmr::vector是一个个元素move过去的；而普通vector是调用memmove把所有数据一股脑move过去的。

注意：pmr是c++17开始才有的standard library features, gcc从9.1开始支持。

3. pmr慢的原因

启动perf, 查热点：

[mzhai@std_polymorphic_pmr]$ sudo sysctl -w kernel.kptr_restrict=0
sudo sysctl -w kernel.perf_event_paranoid=0
[sudo] password for mzhai:
kernel.kptr_restrict = 0
kernel.perf_event_paranoid = 0
[mzhai@std_polymorphic_pmr]$ perf record -a -g ./a.out
std vector cost:
Endtook 17302 microseconds.
pmr vector cost:
Endtook 58350 microseconds.
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.100 MB perf.data (369 samples) ]
[mzhai@std_polymorphic_pmr]$ perf report

在这里插入图片描述
找到__uninitialized_copy_a的实现，我的机器在目录/usr/include/c++/11/bits/stl_uninitialized.h中：

请添加图片描述
从perf report能隐约看出调用栈，__uninitialized_copy_a是从push_back -> _M_realloc_insert 调过来的，从名字猜也能猜到是vector旧的分配的空间不够了需要reallocate, 分配完新的空间后需要调用__uninitialized_copy_a把旧的数据copy或move过来，但是重点是：这里竟然是for循环，是一个个copy或move过来的！

4. std::allocator快的原因

作为对比，我们查下std::vector 空间不够是怎么做的？
读者可自行调试TestStdVec，我这里直接上代码：

#0  std::__relocate_a_1<int, int> (__first=0x41b2e8, __last=0x41b2e8, __result=0x41b2cc) at /usr/include/c++/11/bits/stl_uninitialized.h:1012
#1  0x000000000040451f in std::__relocate_a<int*, int*, std::allocator<int> > (__first=0x41b2e8, __last=0x41b2e8, __result=0x41b2cc, __alloc=...)at /usr/include/c++/11/bits/stl_uninitialized.h:1046
#2  0x000000000040423f in std::vector<int, std::allocator<int> >::_S_do_relocate (__first=0x41b2e8, __last=0x41b2e8, __result=0x41b2cc, __alloc=...)at /usr/include/c++/11/bits/stl_vector.h:456
#3  0x0000000000403e5d in std::vector<int, std::allocator<int> >::_S_relocate (__first=0x41b2e8, __last=0x41b2e8, __result=0x41b2cc, __alloc=...)at /usr/include/c++/11/bits/stl_vector.h:469
#4  0x000000000040376a in std::vector<int, std::allocator<int> >::_M_realloc_insert<int const&> (this=0x7fffffffdb70, __position=0)at /usr/include/c++/11/bits/vector.tcc:468
#5  0x0000000000402f24 in std::vector<int, std::allocator<int> >::push_back (this=0x7fffffffdb70, __x=@0x7fffffffdb3c: 2)

请添加图片描述
直接调用__builtin_memmove把旧数据一股脑memmove过去，能不快吗？！
可能有读者有一点点疑问：想__builtin_memmove真的调用memmove吗？简单看下汇编就知道啦。请添加图片描述

5. 何时调用memmove何时调用for循环

通过上面的分析，我们现在知道了pmr慢而普通allocator快的原因了，接着新的问题来了：为什么pmr不走memmove? 什么条件下走memmove哪?
在这里插入图片描述

/usr/include/c++/11/bits/vector.tcc
423   template<typename _Tp, typename _Alloc>424     template<typename... _Args>425       void426       vector<_Tp, _Alloc>::427       _M_realloc_insert(iterator __position, _Args&&... __args)434     {458 #if __cplusplus >= 201103L459       if _GLIBCXX17_CONSTEXPR (_S_use_relocate())460         {461           __new_finish = _S_relocate(__old_start, __position.base(),462                      __new_start, _M_get_Tp_allocator());463464           ++__new_finish;465466           __new_finish = _S_relocate(__position.base(), __old_finish,467                      __new_finish, _M_get_Tp_allocator());468         }469       else470 #endif471         {472           __new_finish473         = std::__uninitialized_move_if_noexcept_a474         (__old_start, __position.base(),475          __new_start, _M_get_Tp_allocator());476477           ++__new_finish;478479           __new_finish480         = std::__uninitialized_move_if_noexcept_a481         (__position.base(), __old_finish,482          __new_finish, _M_get_Tp_allocator());483         }

关键点在_S_use_relocate()的值，此函数的定义如下：

/usr/include/c++/11/bits/stl_vector.h430       static constexpr bool431       _S_nothrow_relocate(true_type)432       {433     return noexcept(std::__relocate_a(std::declval<pointer>(),434                       std::declval<pointer>(),435                       std::declval<pointer>(),436                       std::declval<_Tp_alloc_type&>()));437       }438439       static constexpr bool440       _S_nothrow_relocate(false_type)441       { return false; }442443       static constexpr bool444       _S_use_relocate()445       {446     // Instantiating std::__relocate_a might cause an error outside the447     // immediate context (in __relocate_object_a's noexcept-specifier),448     // so only do it if we know the type can be move-inserted into *this.449     return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{});450       }
  1. 首先看__is_move_insertable<_Tp_alloc_type>{}，无论_Tp_alloc_type是std::allocator 还是std::pmr::polymorphic_allocator，结果是true.
785   template<typename _Alloc>
786     struct __is_move_insertable
787     : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type
788     { };
789
790   // std::allocator<_Tp> just requires MoveConstructible
791   template<typename _Tp>
792     struct __is_move_insertable<allocator<_Tp>>
793     : is_move_constructible<_Tp>
794     { };

std::allocator匹配后者（791行），is_move_constructible为true;
pmr匹配前者（785行）, 匹配下面的两者之一。
此处用了SFINAE思想，如果_Alloc能用_Tp做参数类型构造一个_ValueT*对象，则匹配true的这个模板，否则false, 分别对应__is_move_insertable的结果此处用了SFINAE思想，如果_Alloc能用_Tp做参数类型构造一个_ValueT*对象，则匹配true的这个模板，否则false, 分别对应__is_move_insertable的结果。std::allocator及polymorphic_allocator都有construct函数，构造int对象没问题。
2. 看std::__relocate_a是否抛出异常，__relocate_a会看__relocate_a_1是否抛出异常，而__relocate_a_1会看__relocate_object_a是否抛出异常，__relocate_object_a是否抛出异常取决于：

984   template<typename _Tp, typename _Up, typename _Allocator>985     inline void986     __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,987             _Allocator& __alloc)988     noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,989              __dest, std::move(*__orig)))990          && noexcept(std::allocator_traits<_Allocator>::destroy(991                 __alloc, std::__addressof(*__orig))))

std::allocator_traits<_Allocator>::construct 取决于 std::is_nothrow_constructible<_Up, _Args…>::value
std::allocator_traits<_Allocator>::destroy 取决于 is_nothrow_destructible<_Up>::value

以上仅当所有情况都是noexcept为true才会走_S_relocate的分支（不走__uninitialized_move_if_noexcept_a）。

不过除此之外__relocate_a_1还有一个特例：

1000   template<typename _Tp, typename = void>
1001     struct __is_bitwise_relocatable
1002     : is_trivial<_Tp> { };
1003
1004   template <typename _Tp, typename _Up>
1005     inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
1006     __relocate_a_1(_Tp* __first, _Tp* __last,
1007            _Tp* __result, allocator<_Up>&) noexcept
1008     {
1009       ptrdiff_t __count = __last - __first;
1010       if (__count > 0)
1011     __builtin_memmove(__result, __first, __count * sizeof(_Tp));
1012       return __result + __count;
1013     }

如果_Tp（我的例子里是int）是trivial的 且 分配器是std::allocator，则__relocate_a_1是noexcept的，则走_S_relocate的分支（不走__uninitialized_move_if_noexcept_a）

草草的画了一个流程图（大家凑合看）：
在这里插入图片描述

上面两条捋了一遍_S_use_relocate()的结果， 但并不是它是true就一定用memmove，

/usr/include/c++/11/bits/stl_vector.h452       static pointer453       _S_do_relocate(pointer __first, pointer __last, pointer __result,454              _Tp_alloc_type& __alloc, true_type) noexcept455       {456     return std::__relocate_a(__first, __last, __result, __alloc);457       }458459       static pointer460       _S_do_relocate(pointer, pointer, pointer __result,461              _Tp_alloc_type&, false_type) noexcept462       { return __result; }463464       static pointer465       _S_relocate(pointer __first, pointer __last, pointer __result,466           _Tp_alloc_type& __alloc) noexcept467       {468     using __do_it = __bool_constant<_S_use_relocate()>;469     return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});470       }

459行永远也走不到，因为_S_use_relocate()位true才会调用到这，而其值为true则一定匹配452行的函数特化版本。
__relocate_a最终调用到__relocate_a_1，上面提到过它有两个版本：
只有_Tp是trivial 且 用std::allocator 才会调用memmove。

1004   template <typename _Tp, typename _Up>
1005     inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
1006     __relocate_a_1(_Tp* __first, _Tp* __last,
1007            _Tp* __result, allocator<_Up>&) noexcept
1008     {
1009       ptrdiff_t __count = __last - __first;
1010       if (__count > 0)
1011     __builtin_memmove(__result, __first, __count * sizeof(_Tp));
1012       return __result + __count;
1013     }
1014
1015   template <typename _InputIterator, typename _ForwardIterator,
1016         typename _Allocator>
1017     inline _ForwardIterator
1018     __relocate_a_1(_InputIterator __first, _InputIterator __last,
1019            _ForwardIterator __result, _Allocator& __alloc)
1020     noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
1021                            std::addressof(*__first),
1022                            __alloc)))
1023     {
1024       typedef typename iterator_traits<_InputIterator>::value_type
1025     _ValueType;
1026       typedef typename iterator_traits<_ForwardIterator>::value_type
1027     _ValueType2;
1028       static_assert(std::is_same<_ValueType, _ValueType2>::value,
1029       "relocation is only possible for values of the same type");
1030       _ForwardIterator __cur = __result;
1031       for (; __first != __last; ++__first, (void)++__cur)

6. 看一个简单的class的例子

上面我用的是int，下面用一个简单的类看看，验证下上面的流程图。
我就不分析了，大家执行代码看结果来理解吧。

#include<iostream>
#include<memory_resource>
#include<vector>
#include "../PerfSum.hpp"
using namespace std;struct MyClass{MyClass(int _i):i(_i) {}int i;
};void TestPmrVec(){char buffer[1000000*4] = {0};std::pmr::monotonic_buffer_resource pool{std::data(buffer), std::size(buffer)};std::pmr::vector<MyClass> vec{&pool};PerfSum t;for(int i=0;i<1000000;i++){vec.push_back(MyClass{i});}std::cout<<"End"<<std::endl;}void TestStdVec(){std::vector<MyClass> vec ;PerfSum t;for(int i=0;i<1000000;i++){vec.push_back(MyClass{i});}std::cout<<"End"<<std::endl;}int main() {std::cout<<"is_move_constructible<MyClass>: "<<std::is_move_constructible_v<MyClass><<std::endl;std::cout<<"is_nothrow_constructible<MyClass>: "<<std::is_nothrow_constructible_v<MyClass,MyClass&&><<std::endl;std::cout<<"is_nothrow_destructible<MyClass>: "<<std::is_nothrow_destructible_v<MyClass><<std::endl;std::cout<<"trivail<MyClass>: "<<std::is_trivial_v<MyClass><<std::endl;std::cout<<"std vector cost:"<<std::endl;TestStdVec();std::cout<<"pmr vector cost:"<<std::endl;TestPmrVec();
}

7. release版本的差距没那么大

我们废了很大的经历才捋明白何时用memmove何时不用，而且debug版本之间的性能差距达3倍之多，确实值得我们调查一番。但令人失望又惊喜的是：release版本的性能差距竟然只有1.1倍左右：

[mzhai@std_polymorphic_pmr]$ g++ compare_speed.cpp -std=c++17 -O
std vector cost:
Endtook 5349 microseconds.
pmr vector cost:
Endtook 6207 microseconds.
[mzhai@std_polymorphic_pmr]$ ./a.out
std vector cost:
Endtook 4822 microseconds.
pmr vector cost:
Endtook 5160 microseconds.

不由得感叹：现在的编译器真厉害！

这篇关于Modern C++ 内存篇1 - std::allocator VS pmr的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/693887。

相关文章

Windows下C++使用SQLitede的操作过程

Windows下C++使用SQLitede的操作过程

《Windows下C++使用SQLitede的操作过程》本文介绍了Windows下C++使用SQLite的安装配置、CppSQLite库封装优势、核心功能（如数据库连接、事务管理）、跨平台支持及性能优... 目录Windows下C++使用SQLite1、安装2、代码示例CppSQLite：C++轻松操作SQ
阅读更多...
C++中RAII资源获取即初始化

C++中RAII资源获取即初始化

《C++中RAII资源获取即初始化》RAII通过构造/析构自动管理资源生命周期,确保安全释放,本文就来介绍一下C++中的RAII技术及其应用,具有一定的参考价值,感兴趣的可以了解一下... 目录一、核心原理与机制二、标准库中的RAII实现三、自定义RAII类设计原则四、常见应用场景1. 内存管理2. 文件操
阅读更多...
C++中零拷贝的多种实现方式

C++中零拷贝的多种实现方式

《C++中零拷贝的多种实现方式》本文主要介绍了C++中零拷贝的实现示例,旨在在减少数据在内存中的不必要复制,从而提高程序性能、降低内存使用并减少CPU消耗,零拷贝技术通过多种方式实现,下面就来了解一下... 目录一、C++中零拷贝技术的核心概念二、std::string_view 简介三、std::stri
阅读更多...
C++高效内存池实现减少动态分配开销的解决方案

C++高效内存池实现减少动态分配开销的解决方案

《C++高效内存池实现减少动态分配开销的解决方案》C++动态内存分配存在系统调用开销、碎片化和锁竞争等性能问题,内存池通过预分配、分块管理和缓存复用解决这些问题,下面就来了解一下... 目录一、C++内存分配的性能挑战二、内存池技术的核心原理三、主流内存池实现：TCMalloc与Jemalloc1. TCM
阅读更多...
C++ 函数 strftime 和时间格式示例详解

C++ 函数 strftime 和时间格式示例详解

《C++函数strftime和时间格式示例详解》strftime是C/C++标准库中用于格式化日期和时间的函数,定义在ctime头文件中,它将tm结构体中的时间信息转换为指定格式的字符串,是处理... 目录C++ 函数 strftipythonme 详解一、函数原型二、功能描述三、格式字符串说明四、返回值五
阅读更多...
C++作用域和标识符查找规则详解

C++作用域和标识符查找规则详解

《C++作用域和标识符查找规则详解》在C++中,作用域（Scope）和标识符查找（IdentifierLookup）是理解代码行为的重要概念,本文将详细介绍这些规则,并通过实例来说明它们的工作原理,需... 目录作用域标识符查找规则1. 普通查找（Ordinary Lookup）2. 限定查找（Qualif
阅读更多...
Redis过期删除机制与内存淘汰策略的解析指南

Redis过期删除机制与内存淘汰策略的解析指南

《Redis过期删除机制与内存淘汰策略的解析指南》在使用Redis构建缓存系统时,很多开发者只设置了EXPIRE但却忽略了背后Redis的过期删除机制与内存淘汰策略,下面小编就来和大家详细介绍一下... 目录1、简述2、Redis http://www.chinasem.cn的过期删除策略（Key Expir
阅读更多...
C/C++ chrono简单使用场景示例详解

C/C++ chrono简单使用场景示例详解

《C/C++chrono简单使用场景示例详解》：本文主要介绍C/C++chrono简单使用场景示例详解,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友... 目录chrono使用场景举例1 输出格式化字符串chrono使用场景China编程举例1 输出格式化字符串示
阅读更多...
C++/类与对象/默认成员函数@构造函数的用法

C++/类与对象/默认成员函数@构造函数的用法

《C++/类与对象/默认成员函数@构造函数的用法》：本文主要介绍C++/类与对象/默认成员函数@构造函数的用法,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录名词概念默认成员函数构造函数概念函数特征显示构造函数隐式构造函数总结名词概念默认构造函数：不用传参就可以
阅读更多...
C++类和对象之默认成员函数的使用解读

C++类和对象之默认成员函数的使用解读

《C++类和对象之默认成员函数的使用解读》：本文主要介绍C++类和对象之默认成员函数的使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、默认成员函数有哪些二、各默认成员函数详解默认构造函数析构函数拷贝构造函数拷贝赋值运算符三、默认成员函数的注意事项总结一
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2