c – 如果构造和销毁了许多向量,自定义分配器是否会提高性能？

分类：C&C++作者：佚名
在下面的代码中,每10个整数的许多向量构造有60％的几率,或者现有的向量被删除,有40％的几率.因此,会有很多调用new / malloc和delete.
由于所有这些向量都是vector< int>类型,自定义分配器可以帮助减少对new和delete的调用,从而提高性能吗？这个想法是删除的矢量的空间可以由新构造的空间重用.这样的分配器怎么样？

注意：这个问题是关于分配器,它减少了对new和delete的调用.

#include <iostream>
#include <vector>
#include <random>

using namespace std;

int main() 
{
    // Random generator and distribution
    mt19937 gen(123456);
    uniform_real_distribution<> dis01(0.,1.);

    // Make or delete 10E6 vectors.
    vector< vector<int> > v; //the inner vectors will make many calls to new and delete

    v.reserve(10E5); //assume some size.

    for(int i=0; i<10E6; ++i)
    {
        if(dis01(gen)<0.6) // if true: make new sub-vector
        {
            v.emplace_back(); //new sub-vector
            v.back().reserve(10);

            for(int k=0; k<10; ++k)
                v.back().emplace_back(k); //fill it with some numbers
        }
        else // else,delete the last entry if there is one.
            if(!v.empty())
                v.pop_back();
    }

    cout<<"v.size()= "<<v.size();       
    return 0;
}

解决方法

这适用于C 11.较旧的标准需要额外的东西
在分配器[1]中实现.

这是概念验证代码.它运行并解决了这个例子
问题但受到一些限制.它仍然
演示了如何使用自定义分配器来改进
在很多std :: vectors的场景中的性能
创造和破坏.

PoolAlloc.hh：

template<typename T>
struct MemChunk
{
    std::size_t buf_size=0;
    T* buf=nullptr;
    T* top=nullptr;
    std::size_t used=0;
};

template<typename T>
class PoolAllocator
{
    public:
    using value_type=T;

    PoolAllocator();
    explicit PoolAllocator(std::size_t);
    PoolAllocator(PoolAllocator const&) noexcept;
    template<typename U>
        PoolAllocator(PoolAllocator<U> const&) noexcept;
    PoolAllocator(PoolAllocator&&) noexcept;
    PoolAllocator& operator=(PoolAllocator const&)=delete;
    PoolAllocator& operator=(PoolAllocator&&)=delete;
    ~PoolAllocator();

    template <typename U> 
    struct rebind 
    {
        using other=PoolAllocator<U>;
    };

    T* allocate(std::size_t);
    void deallocate(T*,std::size_t) noexcept;

    template<typename U1,typename U2>
        friend bool operator==(PoolAllocator<U1> const&,PoolAllocator<U2> const&) noexcept;

    private:
    std::vector<MemChunk<T>>* memory_=nullptr;
    int* ref_count_=nullptr;
    std::size_t default_buf_size_=0;
};

template<typename T>
PoolAllocator<T>::PoolAllocator():
    PoolAllocator{100000} {}

template<typename T>
PoolAllocator<T>::PoolAllocator(std::size_t buf_size):
    memory_{new std::vector<MemChunk<T>>},ref_count_{new int(0)},default_buf_size_{buf_size}
{
    memory_->emplace_back();
    memory_->back().buf_size=buf_size;
    memory_->back().buf=new T[buf_size];
    memory_->back().top=memory_->back().buf;
    ++(*ref_count_);
}

template<typename T>
PoolAllocator<T>::PoolAllocator(PoolAllocator const& src) noexcept:
    memory_{src.memory_},ref_count_{src.ref_count_},default_buf_size_{src.default_buf_size_}
{
    ++(*ref_count_);
}

template<typename T>
PoolAllocator<T>::PoolAllocator(PoolAllocator&& src) noexcept:
    memory_{src.memory_},default_buf_size_{src.default_buf_size_}
{
    src.memory_=nullptr;
    src.ref_count_=nullptr;
}

template<typename T>
template<typename U>
PoolAllocator<T>::PoolAllocator(PoolAllocator<U> const& src) noexcept:
    memory_{src.memory_},default_buf_size_{src.default_buf_size_}
{
    ++(*ref_count_);
}

template<typename T>
PoolAllocator<T>::~PoolAllocator()
{
    if (ref_count_!=nullptr)
    {
        --(*ref_count_);
        if (*ref_count_==0)
        {
            if (memory_!=nullptr)
            {
                for (auto& it : *memory_)
                {
                    delete[] it.buf;
                }
                delete memory_;
            }
            delete ref_count_;
        }
    }
}

template<typename T>
T* 
PoolAllocator<T>::allocate(std::size_t n)
{
    MemChunk<T>* mem_chunk=&memory_->back();
    if ((mem_chunk->used+n)>mem_chunk->buf_size)
    {
        default_buf_size_*=2;
        memory_->emplace_back();
        mem_chunk=&memory_->back();
        std::size_t buf_size=default_buf_size_;
        if (n>default_buf_size_)
        {
            buf_size=n;
        }
        mem_chunk->buf_size=buf_size;
        mem_chunk->buf=new T[mem_chunk->buf_size];
        mem_chunk->top=mem_chunk->buf;
    }
    T* r=mem_chunk->top;
    mem_chunk->top+=n;
    mem_chunk->used+=n;
    return r;
}

template<typename T>
void 
PoolAllocator<T>::deallocate(T* addr,std::size_t n) noexcept
{
    MemChunk<T>* mem_chunk=&memory_->back();
    if (mem_chunk->used>n and (mem_chunk->top-n)==addr)
    {
        mem_chunk->used-=n;
        mem_chunk->top-=n;
    }
}

template<typename U1,typename U2>
bool operator==(PoolAllocator<U1> const& lhs,PoolAllocator<U2> const& rhs) noexcept
{
    return (std::is_same<U1,U2>::value and lhs.memory_==rhs.memory_);
}

使用以下方式修改的示例：

#include <iostream>
#include <vector>
#include <random>   
#include "PoolAlloc.hh"

using namespace std;

int main() 
{
    // Random generator and distribution
    mt19937 gen(123456);
    uniform_real_distribution<> dis01(0.,1.);
    PoolAllocator<int> palloc{1000000};

    // Make or delete 10E6 vectors.
    vector< vector<int,PoolAllocator<int>> > v; //the inner vectors will make many calls to new and delete

    v.reserve(10E5); //assume some size.

    for(int i=0; i<10E6; ++i)
    {
        if(dis01(gen)<0.6) // if true: make new sub-vector
        {
            v.emplace_back(palloc); //new sub-vector
            v.back().reserve(10);

            for(int k=0; k<10; ++k)
                v.back().emplace_back(k); //fill it with some numbers
        }
        else // else,delete the last entry if there is one.
            if(!v.empty())
                v.pop_back();
    }

    cout<<"v.size()= "<<v.size();   
    return 0;
}

对malloc的调用次数从~6e6下降到21
指令数从3.7e9下降到2.5e9(使用-O3,
用valgrind测量–tool = callgrind).

有一些实施细节会影响到
在不同的使用情况下的表现.

目前使用多个缓冲区.如果一个满了,另一个满了
被建造.这种方式永远不必重新分配
操作会让你进入一个受伤的世界(见
评论).

最大的问题是,如何处理解除分配的内存.
目前使用的是一种简单的方法,只能进行解除分配
内存可用于稍后在它结束时分配
缓冲.对于你的例子就足够了,就像你一样
在缓冲区的末尾释放内存.

对于更复杂的场景,您需要更复杂的场景
机制.存储地址需要一些数据结构
和可用内存块的大小.多个概念是可能的
在这里,他们的表现会因具体情况而有所不同
它们被用于.我怀疑有一个很好的一刀切
解决方案在这

[1] http://howardhinnant.github.io/stack_alloc.html

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

浅谈C/C++中的static和extern关键字
一.C语言中的static关键字 在C语言中，static可以用来修饰局部变量，全局变量以及函数。在不同的情况下static的作用不尽相同。 (1)修饰局部变量 一般情况下，对于局部变量是存放在栈区的，并且局部变量的生命周期在该语句块执行结束时便结束了。但是如果用static进行修饰的话，该变量便存
浅谈C/C++中的指针和数组（二）
浅谈C/C++中的指针和数组（二） 前面已经讨论了指针和数组的一些区别，然而在某些情况下，指针和数组是等同的，下面讨论一下什么时候指针和数组是相同的。C语言标准对此作了说明：规则1：表达式中的数组名被编译器当做一个指向该数组第一个元素的指针； 注：下面几种情况例外 1)数组名作为sizeof的操作数
浅谈C/C++中的指针和数组（一）
浅谈C/C++中的指针和数组（一）指针是C/C++的精华，而指针和数组又是一对欢喜冤家，很多时候我们并不能很好的区分指针和数组，对于刚毕业的计算机系的本科生很少有人能够熟练掌握指针以及数组的用法和区别。造成这种原因可能跟现在大学教学以及现在市面上流行的很多C或者C++教程有关，这些教程虽然通俗易懂，
从两个例子分析C语言的声明
从两个例子分析C语言的声明 在读《C专家编程》一书的第三章时，书中谈到C语言的声明问题，《C专家编程》这本书只有两百多页，却花了一章的内容去阐述这个问题，足以看出这个问题的重要性，要想透彻理解C语言的声明问题仅仅看书是远远不够的，需要平时多实践并大量阅读别人写的代码。下面借鉴《C专家编程》书中的两个
C语言文件操作解析(一)
C语言文件操作解析(一)在讨论C语言文件操作之前，先了解一下与文件相关的东西。一.文本文件和二进制文件 文本文件的定义：由若干行字符构成的计算机文件，存在于计算机系统中。文本文件只能存储文件中的有效字符信息，不能存储图像、声音等信息。狭义上的二进制文件则指除开文本文件之外的文件，如图片、DOC文档。
C语言文件操作解析(三)
C语言文件操作解析(三) 在前面已经讨论了文件打开操作，下面说一下文件的读写操作。文件的读写操作主要有4种，字符读写、字符串读写、块读写以及格式化读写。一.字符读写 字符读写主要使用两个函数fputc和fgetc，两个函数的原型是: int fputc(int ch,FILE *fp);若写入成功则
浅谈C语言中的位段
浅谈C语言中的位段 位段(bit-field)是以位为单位来定义结构体(或联合体)中的成员变量所占的空间。含有位段的结构体(联合体)称为位段结构。采用位段结构既能够节省空间，又方便于操作。 位段的定义格式为: type [var]:digits 其中type只能为int，unsigned int，s
C语言文件操作解析(五)之EOF解析
C语言文件操作解析(五)之EOF解析 在C语言中，有个符号大家都应该很熟悉，那就是EOF(End of File)，即文件结束符。但是很多时候对这个理解并不是很清楚，导致在写代码的时候经常出错，特别是在判断文件是否到达文件末尾时，常常出错。1.EOF是什么? 在VC中查看EOF的定义可知: #def
关于VC++6.0中getline函数的一个bug
关于VC+ʶ.0中getline函数的一个bug 最近在调试程序时，发现getline函数在VC+ʶ.0和其他编译器上运行结果不一样，比如有如下这段程序：#include &lt;iostream&gt;#include &lt;string&gt;using namespace std;int
浅谈C/C++的浮点数在内存中的存储方式
C/C++浮点数在内存中的存储方式 任何数据在内存中都是以二进制的形式存储的，例如一个short型数据1156，其二进制表示形式为00000100 10000100。则在Intel CPU架构的系统中，存放方式为 10000100(低地址单元) 00000100(高地址单元)，因为Intel CPU
浅析C/C++中的switch/case陷阱
浅析C/C++中的switch/case陷阱 先看下面一段代码： 文件main.cpp#includeusing namespace std;int main(int argc, char *argv[]){ int a =0; switch(a) { case ...
浅谈C/C++中的typedef和#define
浅谈C/C++中的typedef和#define 在C/C++中，我们平时写程序可能经常会用到typedef关键字和#define宏定义命令，在某些情况下使用它们会达到相同的效果，但是它们是有实质性的区别，一个是C/C++的关键字，一个是C/C++的宏定义命令，typedef用来为一个已有的数据类型
关于数组指针的一道面试题
看下面一道面试题：#include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;int main(void) { int a[5]={1,2,3,4,5}; int *ptr=(int *)(&amp;aʱ); printf(&quot;%d,%d&quot;,*(
浅谈C语言中的联合体
联合体union 当多个数据需要共享内存或者多个数据每次只取其一时，可以利用联合体(union)。在C Programming Language 一书中对于联合体是这么描述的： 1)联合体是一个结构； 2)它的所有成员相对于基地址的偏移量都为0； 3)此结构空间要大到足够容纳最&quot;宽&quo
从一个程序的Bug解析C语言的类型转换
从一个程序的Bug解析C语言的类型转换 先看下面一段程序，这段程序摘自《C 专家编程》：#include&lt;stdio.h&gt;int array[]={23,34,12,17,204,99,16};#define TOTAL_ELEMENTS (sizeof(array)/sizeof(ar
大端和小端
大端和小端 嵌入式开发者应该对大端和小端很熟悉。在内存单元中数据是以字节为存储单位的，对于多字节数据，在小端模式中，低字节数据存放在低地址单元，而在大端模式中，低字节数据存放在高地址单元。比如一个定义一个short型的变量a，赋值为1，由于short型数据占2字节。在小端模式中，其存放方式为0X40
位运算和sizeof运算符
位运算和sizeof运算符 C语言中提供了一些运算符可以直接操作整数的位，称为位运算，因此位运算中的操作数都必须是整型的。位运算的效率是比较高的，而且位运算运用好的话会达到意想不到的效果。位运算主要有6种：与(&amp;)，或(|)，取反(~)，异或(^)，左移(&gt;)。1.位运算中的类型转换位
C语言文件操作解析(四)
C语言文件操作解析(四)在文件操作中除了打开操作以及读写操作，还有几种比较常见的操作。下面介绍一下这些操作中涉及到的函数。一.移动位置指针的函数 rewind函数和fseek函数，这两个函数的原型是:void rewind(FILE *fp); 将位置指针移动到文件首 int fseek(FILE
结构体字节对齐
结构体字节对齐 在用sizeof运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。从理论上讲，对于任何变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排
C语言文件操作解析(二)
C语言文件操作解析(二)C语言中对文件进行操作必须首先打开文件，打开文件主要涉及到fopen函数。fopen函数的原型为 FILE* fopen(const char *path,const char *mode) 其中path为文件路径，mode为打开方式 1)对于文件路径，只需注意若未明确给出绝
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot