linux stl内存池的应用

在stl里面，stl对容器中元素内存的分配，与元素的构造、析构过程进行了分离

 c++ 在全局定义了 operator new(size_t size), 调用malloc(size)

operator new(size_t size,void* buf) 什么也不做直接return buf

operator delete(void* buf); 调用free(buf)

对于ClassA* ptr = new ClassA()，编译器步骤为(分配内存+调用构造函数)

void * mem=operator new(sizeof(ClassA));

ClassA* ptr=(ClassA*)mem;

ptr->ClassA::ClassA();

对于new(_mem) ClassA(), 编译器步骤为(使用已分配的内存(内存需要对齐) + 调用构造函数，相当于分离分配过程)

void* mem = operator new(sizeof(ClassA),_mem); //其实什么也没做，直接返回mem

ClassA* ptr=(ClassA*)mem;

ptr->ClassA::ClassA(); //通过指针直接调用时，无法编译

可以使用stl里面实现的标准内存分配器std::allocator

在windows上其使用_Default_allocate_traits实现空间分配，比较直接使用 operator new直接分配，施放则是直接调用_Deallocate函数使用operator delete释放

在linux上是使用new_allocator类进行分配、释放，也是直接operator new、operator delete

allocator<Foo> alloc;
//Allocate memory for one or n objects，根据Foo对象内存对齐后的原始内存
auto p = alloc.allocate(1);
//Construct an object of Foo on allocated memory block p, by calling one of Foo's constructors
alloc.construct(p, args, ...);

//OK, p now points to a Foo object ready for use...

//Call Foo's destructor but don't release memory of p
alloc.destroy(p);
//Release memory
alloc.deallocate(p, 1);

在linux上，编译器版本为9.4.0扩展了mt_alloc，适用于单线程、多线程，具有内存池功能; 分为一级管理与二级管理，一级管理直接new、delete，二级管理采用内存池。默认情况大于128bytes使用一级管理，小于采用二级管理；当采用二级管理时，每次申请都是先查询释放链表有没有释放过的，有释放过的先复用，然后才是在内存池中割一块新的，或者重新分配一块

#include <ext/mt+allocator.h>
int main(argc , char **argv)
{
    //__ommon_pool_policy模板参数bool表示是否用于多线程
    typedef __gnu__cxx::__mt_alloc<<XXXX>, __gnu_cxx::__common_pool_policy<__gnu_cxx::_pool, false>> MtPoolAlloc;
    typedef __gnu_cxx::__pool_base::_Tune MtPoolAllocTune;
    
    MtPoolAlloc alloc;
    /*
    size_t _M_align; //字节对齐
    size_t _M_max_bytes; //默认为128，表示128字节以上的用new直接分配
    size_t _M_min_bin;//可分配的最小的内存大小，默认为8
    size_t _M_chunk_size;//每次从os申请的内存块的大小，默认为4096 - 4 *sizeof(void*)
    size_t _M_max_threads;//可支持的最多的线程数，默认4096
    size_t _M_freelist_headroom;//单线程能保存的空闲块的百分比，默认10%
    bool   _M_force_new;//是否直接使用new和delete
    */
    MtPoolAllocTune opt{8, sizeof(XXXX), sizeof(XXXX), 4096 - 4 * sizeof(void*), 1, 10, false};
    //alloc._M_get_options可以返回正在使用的，修改部分也可以
    alloc._M_set_options(opt);
    auto *tt1 = alloc.allocate(1);
    alloc.construct(tt1, 1, 2);//调用构造函数
    std::cout << reinterpret_cast<unsigned long long>((void*)tt1) << std::endl;
    alloc.destroy(tt1); //调用析构函数; 如果析构是虚函数，没有调用构造函数的话，这里会崩溃
    alloc.deallocate(tt1, 1); //放回内存池
    tt1 = alloc.allocate(1);
    alloc.construct(tt1, 1, 2);//调用构造函数
    std::cout << reinterpret_cast<unsigned long long>((void*)tt1) << std::endl;
    alloc.destroy(tt1);
    alloc.deallocate(tt1, 1); //放回内存池
}

运行结果为:

94504784214136
XXXX() //构造函数打印
~XXXX() //析构函数打钱
94504784214136
XXXX() //构造函数打印
~XXXX() //析构函数打钱

与allocator这一类分配器，相配对的还有专门的stl算法函数，如uninitialized_copy、uninitialized_copy_n、uninitialized_fill、uninitialized_fill_n等，都是把输入源拷贝到已分配(但未初始化)的内存上，在对应位置直接调用对应的类的拷贝构造函数

自定义allocator，范例如下

#include <vector>
#include <ext/mt_allocator.h>

template<typename T>
class SelfAlloc{
    public:
    typedef T value_type;

    SelfAlloc() = default;

    template<typename T1>
    SelfAlloc(const SelfAlloc<T1>& other){}

    T* address(T &x){
        return static_cast<T*>(&x);
    }
    const T* address(const T &x){
        return static_cast<const T*>(&x);
    }

    T* allocate(size_t _n,const void* hit=0 ){
        return static_cast<T*>(::operator new(_n*sizeof(T)));
    }

    void deallocate(T* p, size_t _n){
        ::operator delete(p);
    }

    size_t max_size()const throw(){
        return static_cast<size_t>(std::numeric_limits<int>::max()/sizeof(T));
    }

    template<typename _Up, typename... _Args>
    void construct(_Up* __p, _Args&&... __args){
        ::new((void *)__p) _Up(std::forward<_Args>(__args)...);
    }

    template<typename _Up>
    void destroy(_Up* __p){
        __p->~_Up();
    }
};

template<typename T>
inline bool operator==(const SelfAlloc<T> &, const SelfAlloc<T> &){
    return true;
}

template<typename T>
inline bool operator!=(const SelfAlloc<T> &, const SelfAlloc<T> &){
    return false;
}

int main(int argc, char **argv){
    std::vector<int, SelfAlloc<int>> ewefwi; 
    ewefwi.push_back(2);
    ewefwi.push_back('a');
    auto wefwff = ewefwi;
    std::vector<int, SelfAlloc<int>> jlllll;
    jlllll = ewefwi;

    return 0;
}