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。

相关文章

C++右移运算符的一个小坑及解决

C++右移运算符的一个小坑及解决

《C++右移运算符的一个小坑及解决》文章指出右移运算符处理负数时左侧补1导致死循环,与除法行为不同,强调需注意补码机制以正确统计二进制1的个数... 目录我遇到了这么一个www.chinasem.cn函数由此可以看到也很好理解总结我遇到了这么一个函数template<typename T>unsigned
阅读更多...
C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...
Redis实现高效内存管理的示例代码

Redis实现高效内存管理的示例代码

《Redis实现高效内存管理的示例代码》Redis内存管理是其核心功能之一,为了高效地利用内存,Redis采用了多种技术和策略,如优化的数据结构、内存分配策略、内存回收、数据压缩等,下面就来详细的介绍... 目录1. 内存分配策略jemalloc 的使用2. 数据压缩和编码ziplist示例代码3. 优化的
阅读更多...
深入解析C++ 中std::map内存管理

深入解析C++ 中std::map内存管理

《深入解析C++中std::map内存管理》文章详解C++std::map内存管理,指出clear()仅删除元素可能不释放底层内存,建议用swap()与空map交换以彻底释放,针对指针类型需手动de... 目录1️、基本清空std::map2️、使用 swap 彻底释放内存3️、map 中存储指针类型的对象
阅读更多...
Python内存优化的实战技巧分享

Python内存优化的实战技巧分享

《Python内存优化的实战技巧分享》Python作为一门解释型语言,虽然在开发效率上有着显著优势,但在执行效率方面往往被诟病,然而,通过合理的内存优化策略,我们可以让Python程序的运行速度提升3... 目录前言python内存管理机制引用计数机制垃圾回收机制内存泄漏的常见原因1. 循环引用2. 全局变
阅读更多...
C++ STL-string类底层实现过程

C++ STL-string类底层实现过程

《C++STL-string类底层实现过程》本文实现了一个简易的string类,涵盖动态数组存储、深拷贝机制、迭代器支持、容量调整、字符串修改、运算符重载等功能,模拟标准string核心特性,重点强... 目录实现框架一、默认成员函数1.默认构造函数2.构造函数3.拷贝构造函数(重点)4.赋值运算符重载函数
阅读更多...
C++ vector越界问题的完整解决方案

C++ vector越界问题的完整解决方案

《C++vector越界问题的完整解决方案》在C++开发中,std::vector作为最常用的动态数组容器,其便捷性与性能优势使其成为处理可变长度数据的首选,然而,数组越界访问始终是威胁程序稳定性的... 目录引言一、vector越界的底层原理与危害1.1 越界访问的本质原因1.2 越界访问的实际危害二、基
阅读更多...
c++日志库log4cplus快速入门小结

c++日志库log4cplus快速入门小结

《c++日志库log4cplus快速入门小结》文章浏览阅读1.1w次，点赞9次，收藏44次。本文介绍Log4cplus，一种适用于C++的线程安全日志记录API，提供灵活的日志管理和配置控制。文章涵盖... 目录简介日志等级配置文件使用关于初始化使用示例总结参考资料简介log4j 用于Java，log4c
阅读更多...
C++归并排序代码实现示例代码

C++归并排序代码实现示例代码

《C++归并排序代码实现示例代码》归并排序将待排序数组分成两个子数组,分别对这两个子数组进行排序,然后将排序好的子数组合并,得到排序后的数组,：本文主要介绍C++归并排序代码实现的相关资料,需要的... 目录1 算法核心思想2 代码实现3 算法时间复杂度1 算法核心思想归并排序是一种高效的排序方式，需要用
阅读更多...
MySQL 内存使用率常用分析语句

MySQL 内存使用率常用分析语句

《MySQL内存使用率常用分析语句》用户整理了MySQL内存占用过高的分析方法,涵盖操作系统层确认及数据库层bufferpool、内存模块差值、线程状态、performance_schema性能数据... 目录一、 OS层二、 DB层1. 全局情况2. 内存占js用详情最近连续遇到mysql内存占用过高导致
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2