C++ 分配器 allocator

在stl源码剖析里面叫空间配置器。

说明

     ~~~~     在C++编程中，分配器（英语：allocator）是C++标准库的重要组成部分。C++的库中定义了多种被统称为“容器”的数据结构（如链表、集合等），这些容器的共同特征之一，就是其大小可以在程序的运行时改变；为了实现这一点，进行动态内存分配就显得尤为必要，在此分配器就用于处理容器对内存的分配与释放请求。换句话说，分配器用于封装标准模板库（STL）容器在内存管理上的低层细节。默认情况下，C++标准库使用其自带的通用分配器，但根据具体需要，程序员也可自行定制分配器以替代之。

     ~~~~     分配器最早由亚历山大·斯特潘诺夫作为C++标准模板库（Standard Template Library，简称STL）的一部分发明，其初衷是创造一种能“使库更加灵活，并能独立于底层数据模型的方法”，并允许程序员在库中利用自定义的指针和引用类型；但在将标准模板库纳入C++标准时，C++标准委员会意识到对数据模型的完全抽象化处理会带来不可接受的性能损耗，为作折中，标准中对分配器的限制变得更加严格，而有鉴于此，与斯特潘诺夫原先的设想相比，现有标准所描述的分配器可定制程度已大大受限。

     ~~~~     虽然分配器的定制有所限制，但在许多情况下，仍需要用到自定义的分配器，而这一般是为封装对不同类型内存空间（如共享内存与已回收内存）的访问方式，或在使用内存池进行内存分配时提高性能而为。除此以外，从内存占用和运行时间的角度看，在频繁进行少量内存分配的程序中，若引入为之专门定制的分配器，也会获益良多。

使用需求

     ~~~~     任意满足分配器使用需求的C++类都可作分配器使用。具体来说，当一个类（在此设为类A）有为一个特定类型（在此设为类型T）的对象分配内存的能力时，该类就必须提供以下类型的定义：

• A::pointer指针
• A::const_pointer常量指针
• A::reference引用
• A::const_reference常量引用
• A::value_type值类型
• A::size_type所用内存大小的类型，表示类A所定义的分配模型中的单个对象最大尺寸的无符号整型
• A::difference_type指针差值得类型，为带符号整型，用于表示分配模型内的两个指针的差值。

     ~~~~     如此才能以通用的方式声明对象与对该类对象的引用T。allocator提供这些指针或者引用的类型定义的初衷，是隐蔽指针或者引用的物理实现细节；因为在16位编程时代，远指针是与普通指针非常不同的，allocator可以定义一些结构来表示这些指针或引用，而容器类用户不需要了解其实如何实现的。

远指针：
远指针不是让编译程序把程序数据段地址作为指针的段地址部分，而是把指针的段地址与指针的偏移量直接存放在指针内。
在分段体系结构计算机中，远指针是包括段选择器的指针，使得可以指向默认段之外的地址。
远指针的比较和算法是有问题的：可以有几个不同的段偏移地址对指向一个 物理地址。

     ~~~~     虽然按照标准，在库的实现过程中允许假定分配器（类）A的A::pointer和A::const_pointer即是对T与T const的简单的类型定义，但一般更鼓励支持通用分配器。
     ~~~~     另外，设有对于为某一对象类型T所设定的分配器A，则A必须包含四项成员函数，分别为，分配函数、解除分配函数、最大个数函数和地址函数：

• A::pointer A::allocate(size_type n, A::const_pointer hint = 0)。分配函数用以进行内存分配。其中调用参数n即为需要分配的对象个数，另一调用参数hint（须为指向已为A所分配的某一对象的指针）则为可选参数，可用于放分配过程中指定新数组所在的内存地址，以提高引用局部性，但在实际的分配过程中程序也可以根据情况自动忽略掉该参数。该函数调用时会返回指向分配所得的新数组的第一个元素的指针，而这一数组的大小足以容纳n个T类元素。在此需要注意的是，调用时只为此数组分配了内存，而并未实现构造对象。
• void A::deallocate(A:L:pointer p, A::size_type n)。解除分配函数。其中p为需要解除分配的对象指针（以A::allocate函数所返回的指针做参数），n为对象个数，而调用该函数时即是将以p起始的n个元素解除分配，但通时并不会析构之。C++标准明确要求在调用deallocate之前，改地址空间上的对象已经被析构。
• A::max_size()，最大个数函数。返回A::allocate一次调用所能成功分配的元素的最大个数，其返回值等价于A::size_t(-1)/sizeof(T)的结果。A::size_t(-1)获取的是该系统的最大值。
• A::pointer A::address(reference x)，地址函数。调用时返回一个指向x的指针。

     ~~~~     除此之外，由于对象的构造/析构过程与分配/解除分配过程分别进行，因而分配器还需要成员函数$A::construct$（构造函数）与$A::destory$（析构函数）以对对象进行构造和析构，且两者应等价于如下函数：

• template <\typename T> void A::construct(A::pointer p, A::const_reference t) { new ((void*) p) T(t); }
• template <\typename T> void A::destroy(A::pointer p){ ((T*)p)->~T(); }

     ~~~~     以上代码中使用了placement new语法，且直接调用了析构函数。
     ~~~~     分配器应该是可复制拷贝的，任举一个例子，为T类对象而设的分配器可以由另一为U类所设的分配器构造。若分配器分配了一段存储空间，则这段存储空间只能由与该分配器等价的分配器解除分配。
     ~~~~     分配器还需要提供一个模板类成员template <typename U> struct A::rebind { typedef A <U> other;}，以模板（C++）参数化的方式，借之来针对不同的数据类型获取不同的分配器。例如，若给定某一为整形而设的相关分配器。实际上，std::list <int>实际要分配的是包含了双向链表指针的node <int>，而不是实际分配int类型，这是引入了rebind的初衷。
     ~~~~     与分配器相关联的operator ==，仅当一个allocator分配的内存可以被另一个allocator释放时，上诉相等比较算符返回真。operator !=的返回结果与之相反。

自定义分配器

     ~~~~     定义自定义分配器的主要原因之一是提升性能。利用专用的自定义分配器可以提高程序的性能，又或提高内存使用效率，亦或者两者兼而有之。默认分配器使用new操作费分配存储空间，而这常利用C语言堆分配函数（malloc()）实现。由于堆分配函数常针对偶发的内存大量分配作优化，因此在为需要一次分配大量内存的容器（如向量、双端队列）分配内存时，默认分配器一般效率良好。但是，对于关联容器与双向链表这类需要频繁分配少量内存的容器来说，若采用默认的分配器分配内存，则通常效率很低。除此之外，基于malloc()的默认分配器还存在很多问题，诸如较差的引用局部性，以及可能造成内存碎片化。
     ~~~~     有鉴于此，在这一情况下，人们常使用基于内存池的分配器来解决频繁少量分配问题。与默认的“按需分配”方式不同，在使用基于内存池的分配器时，程序会预先为止分配大块内存（即内存池），而后在需要分配内存时，自定义分配器只需要向请求方返回一个指向池内内存的指针即可；在对象析构时，并不需要实际接触分配的内存，而是延迟到内存池的生命周期完结才真正接触分配。
     ~~~~     另外，在《C++程序设计语言》中，比雅尼·斯特劳斯特鲁普则认为“‘严格限制分配器，以免各对象信息不同’，这点显然问题不大”（大意），并指出大部分分配器并不需要状态，甚至没有状态情形下性能反倒更佳。他提出了三个自定义分配器的用例：内存池型的分配器、共享内存型分配器与垃圾回收型分配器，并展示了一个分配器的实现，此间利用了一个内部内存池，以快速分配/解除分配少量内存。但他也提到，如此优化可能已经在他所提供的样例分配器中实现。

     ~~~~     自定义分配器的另一用途是调试内存相关错误。若要做到这一点，可以编写一个分配器，令之在分配时分配额外的内存，并借此存放调试信息。这类分配器不仅可以保证内存由同类分配器分配/解除分配内存，还可在一定程度上保护程序免受缓存溢出之害。
     ~~~~     C++之父 Bjarne stroustrup 提到，自定义分配器的三个主要应用，即内存池分配器，共享内存分配器和垃圾收集(gc)分配器
     ~~~~     分享一个例子：设计一个简单地内存分配器(空间分配器)

使用方法

     ~~~~     当初始化标准容器时，若使用自定义分配器，则可将其写入模板参数，以替代默认的std::allocator，如下所示：

namespace std {

//vactor
  template <class T, class Allocator = allocator<T> > class vector;
// ...


//队列
template<class _Ty,
	class _Container = deque<_Ty> >
	class queue

     ~~~~     正如其他所有C++类模板般，在初始化同一个标准库容器时，若使用了不同的分配器，则所生成容器的类型亦不同。譬如，若函数需一整型向量数组std::vector <int>作为参数，则其只能接受由默认分配器生成的整型向量数组。

默认分配器

我们先不考虑怎么写自定义的分配器，我们先看一看stl提供的allocator，我们先看看它是怎么实现的，先上源码，来自gcc5.4版本，看代码我们会发现，默认分配器真正的实现是在new_allocator.h头文件中做的，头文件具体调用顺序为：bits/allocator.h -> bits/c++allocator.h(有时候找不到) -> new_allocator.h, 看代码我们知道，在前面两个头文件中基本没做什么，真正的实现为模板类new_allocator。具体目录在/usr/include/c++/5/下面:

qilimi@qilimi-desktop:/usr/include/c++/5$ find ./ -name "*allocator*"
./ext/array_allocator.h
./ext/extptr_allocator.h
./ext/malloc_allocator.h
./ext/pool_allocator.h
./ext/new_allocator.h
./ext/throw_allocator.h
./ext/bitmap_allocator.h
./ext/mt_allocator.h
./ext/debug_allocator.h
./bits/uses_allocator.h
./bits/allocator.h
./scoped_allocator
qilimi@qilimi-desktop:/usr/include/c++/5$

这里贴一下c++allocator.h文件的内容：

#ifndef _GLIBCXX_CXX_ALLOCATOR_H
#define _GLIBCXX_CXX_ALLOCATOR_H 1

#include <ext/new_allocator.h>

#if __cplusplus >= 201103L
namespace std
{
  /**
   *  @brief  An alias to the base class for std::allocator.
   *  @ingroup allocators
   *
   *  Used to set the std::allocator base class to
   *  __gnu_cxx::new_allocator.
   *
   *  @tparam  _Tp  Type of allocated object.
    */
  template<typename _Tp>
    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
}
#else
// Define new_allocator as the base class to std::allocator.
# define __allocator_base  __gnu_cxx::new_allocator
#endif

#endif

我们这里就看默认分配器new_allocator.h里面：

#ifndef _NEW_ALLOCATOR_H
#define _NEW_ALLOCATOR_H 1

#include <bits/c++config.h>
#include <new>
#include <bits/functexcept.h>
#include <bits/move.h>
#if __cplusplus >= 201103L
#include <type_traits>
#endif

namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  using std::size_t;
  using std::ptrdiff_t;

  /**
   *  @brief  An allocator that uses global new, as per [20.4].
   *  @ingroup allocators
   *
   *  This is precisely the allocator defined in the C++ Standard.
   *    - all allocation calls operator new
   *    - all deallocation calls operator delete
   *
   *  @tparam  _Tp  Type of allocated object.
   */
  template<typename _Tp>
    class new_allocator
    {
    public:
      typedef size_t     size_type;
      typedef ptrdiff_t  difference_type;
      typedef _Tp*       pointer;
      typedef const _Tp* const_pointer;
      typedef _Tp&       reference;
      typedef const _Tp& const_reference;
      typedef _Tp        value_type;

      template<typename _Tp1>
	struct rebind
	{ typedef new_allocator<_Tp1> other; };

#if __cplusplus >= 201103L
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 2103. propagate_on_container_move_assignment
      typedef std::true_type propagate_on_container_move_assignment;
#endif

      _GLIBCXX20_CONSTEXPR
      new_allocator() _GLIBCXX_USE_NOEXCEPT { }

      _GLIBCXX20_CONSTEXPR
      new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPT { }

      template<typename _Tp1>
	_GLIBCXX20_CONSTEXPR
	new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }

      ~new_allocator() _GLIBCXX_USE_NOEXCEPT { }

      pointer
      address(reference __x) const _GLIBCXX_NOEXCEPT
      { return std::__addressof(__x); }

      const_pointer
      address(const_reference __x) const _GLIBCXX_NOEXCEPT
      { return std::__addressof(__x); }

      // NB: __n is permitted to be 0.  The C++ standard says nothing
      // about what the return value is when __n == 0.
      _GLIBCXX_NODISCARD pointer
      allocate(size_type __n, const void* = static_cast<const void*>(0))
      {
	if (__n > this->max_size())
	  std::__throw_bad_alloc();

#if __cpp_aligned_new
	if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
	  {
	    std::align_val_t __al = std::align_val_t(alignof(_Tp));
	    return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
	  }
#endif
	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
      }

      // __p is not permitted to be a null pointer.
      void
      deallocate(pointer __p, size_type)
      {
#if __cpp_aligned_new
	if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
	  {
	    ::operator delete(__p, std::align_val_t(alignof(_Tp)));
	    return;
	  }
#endif
	::operator delete(__p);
      }

      size_type
      max_size() const _GLIBCXX_USE_NOEXCEPT
      {
#if __PTRDIFF_MAX__ < __SIZE_MAX__
	return size_t(__PTRDIFF_MAX__) / sizeof(_Tp);
#else
	return size_t(-1) / sizeof(_Tp);
#endif
      }

#if __cplusplus >= 201103L
      template<typename _Up, typename... _Args>
	void
	construct(_Up* __p, _Args&&... __args)
	noexcept(noexcept(::new((void *)__p)
			    _Up(std::forward<_Args>(__args)...)))
	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }

      template<typename _Up>
	void
	destroy(_Up* __p)
	noexcept(noexcept( __p->~_Up()))
	{ __p->~_Up(); }
#else
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 402. wrong new expression in [some_] allocator::construct
      void
      construct(pointer __p, const _Tp& __val)
      { ::new((void *)__p) _Tp(__val); }

      void
      destroy(pointer __p) { __p->~_Tp(); }
#endif

      template<typename _Up>
	friend bool
	operator==(const new_allocator&, const new_allocator<_Up>&)
	_GLIBCXX_NOTHROW
	{ return true; }

      template<typename _Up>
	friend bool
	operator!=(const new_allocator&, const new_allocator<_Up>&)
	_GLIBCXX_NOTHROW
	{ return false; }
    };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif

我们看一下分配和释放的接口allocate和deallocate，实现上只是单纯的将::operator new和::operator delete进行了一下封装，没用做特殊处理。

当然，如果我们不特别说明，直接在Linux系统下使用标准C++的stl容器，在为容器元素分配内存时，使用的方式就是类似于正常的new和delete，这种方式对于不频繁分配，并且一次分配大块内存的使用情况是适用的，典型的容器像vector和deque。
其中有些东西，前面写了就不多说了，主要还是allocate和deallocat函数。
重写就是主要重写allocate和deallocat函数，像实内存池。
看了内存分配器，我就发现了我之前几个项目的不足之处吧，尤其是有一个现在在用的一个分布式计算，他的容器的分配器确实应该自定义，因为有频繁申请，加入内存池还是很有必要的。

扩展分配器

在前面find，我们就发现了很多的xx_allocator.h文件，这些就是扩展分配器，下面是比较经典的：

• __pool_alloc ：比较出名的SGI内存池分配器
• __mt_alloc ： 多线程内存池分配器
• array_allocator ： 全局内存分配，只分配不释放，交给系统来释放
• malloc_allocator ： 封装了一下std::malloc和std::free

很多时候我们需要自定义分配器，我们都可以学习这些扩展分配器，来进行模仿和借鉴。

这些我之前没有认真学，之后会重新学习，等学完了，就会写出来，立下flag，才知道有多少事情没有做，不然就忘了。
(╯°Д°)╯︵┻━┻