1. 前言

在分析完 nginx 的記憶體池之後，也想了解一下 C++ 的記憶體管理，於是就很自然得想到 STL。STL 是一個重量級的作品，據說當時的出現，完全可以說得上是一個劃時代意義的作品。泛型、資料結構和演算法的分離、底耦合、高複用… 啊，廢話不多說了，再說下去讓人感覺像王婆賣瓜了。

啊，還忘了得加上兩位 STL 大師的名字來聊表我的敬意了。泛型大牛 Alexander Stepanov 和 Meng Lee（李夢 — 讓人浮想的名字啊）。

2. SLT 記憶體的分配

以一個簡單的例子開始。

#include <vector>
#include <algorithm>
using namespace std;

void print( int elem)
{
        cout << elem <<  ' ';
}


int main()
{
        vector<int> vec;
	for (int i = 0; i != 10; ++i)
		vec.push_back(i);

	for_each(vec.begin(), vec.end(), print);
        //請允許我賣弄一點點小特性
	cout << endl;

	return 0;

}

1234567891011121314151617181920212223

#include <vector>#include <algorithm>using namespacestd;voidprint(intelem){cout<<elem<<' ';}intmain(){vector<int>vec;for(inti=0;i!=10;++i)vec.push_back(i);for_each(vec.begin(),vec.end(),print)

;//請允許我賣弄一點點小特性cout<<endl;return0;}

我們想知道的時候，當 vec 宣告的時候和 push_back 的時候，是怎麼分配的。

其實對於一個標準的 STL 容器，當 Vetor<int> vec 的真實語句應該是 vetor<int, allocator<int>>vec，allocator 是一個標準的配置器，其作用就是為各個容器管理記憶體。這裡需要注意的是在 SGI STL 中，有兩個配置器：allocator(標準的) 和 alloc(自己實現的，非常經典，這篇文章的主要目的就是為了分析它)。

3. 一個標準的配置器

要寫一個配置器並不是很難，最重要的問題是如何分配和回收記憶體。下面看下一個標準（也許只能稱為典型）的配置器的實現：

#include <new>// for new
#include <cstddef> //  size_t
#include <climits> // for unit_max
#include <iostream> // for cerr
using namespace std;

namespace SLD {
template <class T>
class allocator
{
public:
	typedef T		value_type;
	typedef T*		pointer;
	typedef const T*	const_pointer;
	typedef T&		reference;
	typedef const T&	const_reference;
	typedef size_t		size_type;
	typedef ptrdiff_t	difference_type;

	template <class U>
	struct rebind
	{
		typedef allocator<U> other;
	};

	//申請記憶體
	pointer allocate(size_type n, const void* hint = 0)
	{
		T* tmp = (T*)(::operator new((size_t)(n * sizeof(T))));
		//operator new 和new operator是不同的
		if (!tmp)
			cerr << "out of memory"<<endl;
		
		return tmp;

	}

	//釋放記憶體
	void deallocate(pointer p)
	{
		::operator delete(p);
	}
	
	//構造
	void construct(pointer p, const T& value)
	{
		new(p) T1(value);
	}
	
	//析構
	void destroy(pointer p)
	{
		p->~T();
	}
	
	//取地址
	pointer address(reference x)
	{
		return (pointer)&x;
	}
	

	const_pointer const_address(const_reference x)
	{
		return (const_pointer)&x;
	}

	size_type max_size() const 
	{
		return size_type(UINT_MAX/sizeof(T));
	}
};
}

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273

#include <new>// for new#include <cstddef> // size_t#include <climits> // for unit_max#include <iostream> // for cerrusing namespacestd;namespaceSLD{template<classT>classallocator{public:typedefTvalue_type;typedefT*pointer;typedefconstT*const_pointer;typedefT&reference;typedefconstT&const_reference;typedefsize_t size_type;typedefptrdiff_t difference_type;template<classU>structrebind{typedefallocator<U>other;};//申請記憶體pointer allocate(size_typen,constvoid*hint=0){T*tmp=(T*)(::operator new((size_t)(n *sizeof(T))));//operator new 和new operator是不同的if(!tmp)cerr<<"out of memory"<<endl;returntmp;}//釋放記憶體voiddeallocate(pointerp){::operator delete(p);}//構造voidconstruct(pointerp,constT&value){new(p)T1(value);}//析構voiddestroy(pointerp){p->~T();}//取地址pointer address(referencex){return(pointer)&x;}const_pointer const_address(const_referencex){return(const_pointer)&x;}size_type max_size()const{returnsize_type(UINT_MAX/sizeof(T));}};}

注：程式碼有比較大的改動，因為主要是為了理解。

在使用的時候，只需這樣 vector<int, SLD::allocator<int>>vec; 即可。vetor 便會自動呼叫我們的配置器分配記憶體了。要自己寫個配置器完全可以以這個類為模板。而需要做的工作便是寫下自己的 allocate 和 deallocate 即可。

其實 SGI 的 allocator 就是這樣直接呼叫 operator new 和::operator delete 實現的，不過這樣做的話效率就很差了。

4. SGI STL 中的 alloc

4.1 SGI 中的記憶體管理

SGI STL 預設的介面卡是 alloc，所以我們在宣告一個 vector 的時候實際上是這樣的 vetor<int, alloc<int>>vec. 這個配置器寫得非常經典,下面就來慢慢分析它。

在我們敲下如下程式碼：

CSld* sld = new CSld;的時候其實幹了兩件事情：

呼叫::operator new 申請一塊記憶體（就是 malloc 了）
呼叫了 CSld::CSld();

而在 SGI 中，其記憶體分配把這兩步獨立出了兩個函式：allocate 申請記憶體， construct 呼叫建構函式。他們分別在 <stl_alloc.h>, <stl_construct.h> 中。

SGI 的記憶體管理比上面所說的更復雜一些，首先看一些 SGI 記憶體管理的幾個主要檔案，如下圖所示：

<圖 1. SGI 記憶體管理>

在 stl_construct.h 中定義了兩個全域性函式 construct() 和 destroy() 來管理構造和析構。在 stl_allo.h 中定義了 5 個配置器，我們現在關心的是 malloc_alloc_template(一級)和 default_alloc_template(二級)。

在 SGI 中，如果用了一級配置器，便是直接使用了malloc() 和 free() 函式，而如果使用了二級介面卡，則如果所申請的記憶體區域大於 128b,直接使用一級介面卡，否則，使用二級介面卡。而 stl_uninitialized.h 中，則定義了一下全域性函式來進行大塊記憶體的申請和複製。

是不是和 nginx 中的記憶體池很相似啊，不過複雜多了。

4.2 一級配置器：__malloc_alloc_template

上面說過， SGI STL 中，如果申請的記憶體區域大於 128B 的時候，就會呼叫一級介面卡，而一級介面卡的呼叫也是非常簡單的，直接用 malloc 申請記憶體，用 free 釋放記憶體。

可也看下如下的程式碼：

class __malloc_alloc_template {

private:
  // oom = out of memroy,當記憶體不足的時候，我要用下面這兩個函式
  static void* _S_oom_malloc(size_t);
  static void* _S_oom_realloc(void*, size_t);

public:

  //申請記憶體
  static void* allocate(size_t __n)
  {
    void* __result = malloc(__n);
    //如果不足，我有不足的處理方法
    if (0 == __result) __result = _S_oom_malloc(__n);
    return __result;
  }

 //直接釋放掉了
  static void deallocate(void* __p, size_t /* __n */)
  {
    free(__p);
  }
 //重新分配記憶體
  static void* reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
  {
    void* __result = realloc(__p, __new_sz);
    if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);
    return __result;
  }
 //模擬C++的 set_new_handler,函式，
 //為什麼要模擬，因為現在用的是C的記憶體管理函式。
  static void (* __set_malloc_handler(void (*__f)()))()
  {
    void (* __old)() = __malloc_alloc_oom_handler;
    __malloc_alloc_oom_handler = __f;
    return(__old);
  }

};

12345678910111213141516171819202122232425262728293031323334353637383940

class__malloc_alloc_template{private:// oom = out of memroy,當記憶體不足的時候，我要用下面這兩個函式staticvoid*_S_oom_malloc(size_t);staticvoid*_S_oom_realloc(void*,size_t);public://申請記憶體staticvoid*allocate(size_t __n){void*__result=malloc(__n);//如果不足，我有不足的處理方法if(0==__result)__result=_S_oom_malloc(__n);return__result;}//直接釋放掉了staticvoiddeallocate(void*__p,size_t/* __n */){free(__p);}//重新分配記憶體staticvoid*reallocate(void*__p,size_t/* old_sz */,size_t __new_sz){void*__result=realloc(__p,__new_sz);if(0==__result)__result=_S_oom_realloc(__p,__new_sz);return__result;}//模擬C++的 set_new_handler,函式，//為什麼要模擬，因為現在用的是C的記憶體管理函式。staticvoid(*__set_malloc_handler(void(*__f)()))(){void(*__old)()=__malloc_alloc_oom_handler;__malloc_alloc_oom_handler=__f;return(__old);}};

好了，很簡單把，只是對 malloc，free, realloc 簡單的封裝。

4.3 二級配置器：__default_alloc_template

按上文所說的，SGI 的 __default_alloc_template 就是一個記憶體池了。

我們首先來看一下它的程式碼：

template <bool threads, int inst>
class __default_alloc_template {

private:
  // Really we should use static const int x = N
  // instead of enum { x = N }, but few compilers accept the former.
    enum {_ALIGN = 8};//小塊區域的上界
    enum {_MAX_BYTES = 128};//小塊區域的下降
    enum {_NFREELISTS = 16}; // _MAX_BYTES/_ALIGN，有多少個區域
/*SGI 為了方便記憶體管理， 把128B 分成16*8 的塊*/

//將Byte調到8的倍數
  static size_t
  _S_round_up(size_t __bytes) 
    { return (((__bytes) + (size_t) _ALIGN-1) & ~((size_t) _ALIGN - 1)); }

//管理記憶體的連結串列，待會會詳細分析這個
  union _Obj {
        union _Obj* _M_free_list_link;
        char _M_client_data[1];    /* The client sees this.        */
  };
private:
    //聲明瞭16個 free_list, 注意 _S_free_list是成員變數
    static _Obj* __STL_VOLATILE _S_free_list[_NFREELISTS];

 //同了第幾個free_list, 即_S_free_list[n],當然這裡是更具區域大小來計算的
  static  size_t _S_freelist_index(size_t __bytes) {
        return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1);
  }

  // Returns an object of size __n, and optionally adds to size __n free list.
  static void* _S_refill(size_t __n);

  // Allocates a chunk for nobjs of size size.  nobjs may be reduced
  // if it is inconvenient to allocate the requested number.
  static char* _S_chunk_alloc(size_t __size, int& __nobjs);

  // Chunk allocation state.
  static char* _S_start_free;//記憶體池的起始位置
  static char* _S_end_free;//記憶體池的結束位置
  static size_t _S_heap_size;//堆的大小

  /*這裡刪除一堆多執行緒的程式碼*/
public:

   //分配記憶體，容後分析
  /* __n must be > 0      */
  static void* allocate(size_t __n);

   //釋放記憶體，容後分析
  /* __p may not be 0 */
  static void deallocate(void* __p, size_t __n);

  //從新分配記憶體
  static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz);

 }

  //下面是一些 成員函式的初始值的設定
template <bool __threads, int __inst>
char* __default_alloc_template<__threads, __inst>::_S_start_free = 0;

template <bool __threads, int __inst>
char* __default_alloc_template<__threads, __inst>::_S_end_free = 0;

template <bool __threads, int __inst>
size_t __default_alloc_template<__threads, __inst>::_S_heap_size = 0;

template <bool __threads, int __inst>
typename __default_alloc_template<__threads, __inst>::_Obj* __STL_VOLATILE
__default_alloc_template<__threads, __inst> ::_S_free_list[] = 
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172

template<boolthreads,intinst>class__default_alloc_template{private:// Really we should use static const int x = N// instead of enum { x = N }, but few compilers accept the former.enum{_ALIGN=8};//小塊區域的上界enum{_MAX_BYTES=128};//小塊區域的下降enum{_NFREELISTS=16};// _MAX_BYTES/_ALIGN，有多少個區域/*SGI 為了方便記憶體管理，把128B 分成16*8 的塊*///將Byte調到8的倍數staticsize_t_S_round_up(size_t __bytes){return(((__bytes)+(size_t)_ALIGN-1)&~((size_t)_ALIGN-1));}//管理記憶體的連結串列，待會會詳細分析這個union_Obj{union _Obj*_M_free_list_link;char_M_client_data[1];/* The client sees this. */};private://聲明瞭16個 free_list, 注意 _S_free_list是成員變數static_Obj*__STL_VOLATILE _S_free_list[_NFREELISTS];//同了第幾個free_list, 即_S_free_list[n],當然這裡是更具區域大小來計算的staticsize_t _S_freelist_index(size_t __bytes){return(((__bytes)+(size_t)_ALIGN-1)/(size_t)_ALIGN-1);}// Returns an object of size __n, and optionally adds to size __n free list.

SGI STL 的記憶體管理

1. 前言

2. SLT 記憶體的分配

3. 一個標準的配置器

4. SGI STL 中的 alloc

4.1 SGI 中的記憶體管理

4.2 一級配置器：__malloc_alloc_template

4.3 二級配置器：__default_alloc_template

[SGI STL]空間配置器--記憶體管理

SGI STL 的記憶體管理

動態記憶體管理allocator類C++ STL標準模板庫vector實現

STL容器的記憶體管理

研究了一下SGI STL的記憶體演算法

SGI STL內存配置器存在內存泄漏嗎？

SGI STL內存配置器（一）：內存泄漏？

第四節：FreeRTOS 記憶體管理

Objective-C高階程式設計:iOS與OS X多執行緒和記憶體管理

找工作筆試面試那些事兒(3)---記憶體管理那些事

記憶體管理+記憶體佈局

Linux記憶體管理（最透徹的一篇）

[讀書筆記]iOS與OS X多執行緒和記憶體管理 [GCD部分]

c++之動態記憶體管理

Java_記憶體管理和繼承

Android 記憶體管理記錄

AMS之記憶體管理

三、Java虛擬機器自動記憶體管理機制、物件建立及記憶體分配

第七章—記憶體管理【計算機作業系統】

【c/c++】記憶體管理

SGI STL 的記憶體管理

1. 前言

2. SLT 記憶體的分配

3. 一個標準的配置器

4. SGI STL 中的 alloc

4.1 SGI 中的記憶體管理

4.2 一級配置器：__malloc_alloc_template

4.3 二級配置器：__default_alloc_template

相關推薦