Python的記憶體管理機制（一 小記憶體塊的申請）
哈哈哈，看的有點兒興奮了，筆記下：
在Python的內部同時維護著巨集和記憶體管理函式兩種記憶體管理機制，巨集定義可以節省一次函式呼叫的開銷，
提高執行效率，但同時，使用巨集是危險的，因為隨著Python的演進，記憶體管理機制的實現可能會發生改變，因為巨集的名字雖然是不會改變的，但其實現程式碼可能會發生改變，導致舊的巨集編寫的C擴充套件與新版本的Python產生二進位制不相容，這樣十分危險，所以，在Python的內部維護了函式和巨集兩套介面，自己編寫擴充套件時，最好使用函式
1 小塊的記憶體池
在Python執行的過程中，很多時候都是小塊記憶體的申請，申請後又很快釋放，也就意味著大量的malloc和free
操作，導致作業系統頻繁的在使用者態和核心態之間進行切換，影響py的執行效率，為了解決這個問題Py引入了快取池的機制(Pymalloc)，整個小塊記憶體的記憶體池可以視為一個層次結構，在這個層次可以分為4層，從上到下依次為：block , pool , arean和記憶體池
1.1 先看下block吧：
在最底層block是一個確定大小的記憶體，在py中有很多種block，每個block有不同的記憶體大小，這個記憶體的大小稱為size class，可以不記得，記得這是最小單元就好，所有block事8位元組對齊的，同時，py為block的大小設定了一個上限，當申請的記憶體大小小於這個上限時，py可以使用不同種類的block來滿足需求，大於這個上限的時候，py轉交給第一次的記憶體管理機制來處理，即pyMem函式族，在py2.5版本，這個值為256k
不同種類的block的大小分別為 8，16，32 ..... ,256，每個size class對應一個size class index ，這個index從0開始，假設申請記憶體為28，會得到一個32的block，能滿足的最小值
1.2 那麼超過256的記憶體申請怎麼辦呢 ？ 來一起看下pool吧：
/* Pool for small blocks. */
struct pool_header {
union { block *_padding;
uint count; } ref;/* number of allocated blocks */
block *freeblock;/* pool's free list head */
struct pool_header *nextpool;/* next pool of this size class */
struct pool_header *prevpool;/* previous pool "" */
uint arenaindex;/* index into arenas of base adr */
uint szidx; /* block size class index */
uint nextoffset;/* bytes to virgin block */
uint maxnextoffset;/* largest valid nextoffset */
};
一組block的集合稱為pool，也就是一個pool管理著多個有固定大小的block，一個pool的大小通常是一個記憶體頁，py將其定義為4k，一個pool裡邊的block的大小是固定的，比如，可能管理了100個32k的block，也可能管理了100個64k的block，但是不可能一個pool裡既有32k的block也有64k的block，每一個pool都和一個size聯絡到一起，更確切的說是和一個size class index聯絡到一起，這就是pool header裡邊的sindex的意義所在
一起看下pool是怎麼把block組合到一起的：
/*
* Initialize the pool header, set up the free list to
* contain just the second block, and return the first
* block.
*/
pool->szidx = size;
size = INDEX2SIZE(size);
bp = (block *)pool + POOL_OVERHEAD;
pool->nextoffset = POOL_OVERHEAD + (size << 1);
pool->maxnextoffset = POOL_SIZE - size;
pool->freeblock = bp + size;
*(block **)(pool->freeblock) = NULL;
UNLOCK();
return (void *)bp;
pool中的第一塊記憶體是分配給pool_header的，所以pool的結構體中ref.count是1，第一塊地址被分配後返回bp的是一個實際地址(也就是申請pool之後的返回)，在這個地址之後會有進4k的記憶體都是實際可用的，但是可以肯定的是申請記憶體的函式只會使用[bp,bp+size]這個區間的記憶體，這是size class index保證的，
我該怎麼畫圖呢 ？ ......先跳過了
/*
* There is a used pool for this size class.
* Pick up the head block of its free list.
*/
++pool->ref.count;
bp = pool->freeblock;
assert(bp != NULL);
if ((pool->freeblock = *(block **)bp) != NULL) {
UNLOCK();
return (void *)bp;
}
/*
* Reached the end of the free list, try to extend it.
*/
if (pool->nextoffset <= pool->maxnextoffset) {
/* There is room for another block. */
pool->freeblock = (block*)pool +
pool->nextoffset;
pool->nextoffset += INDEX2SIZE(size);
*(block **)(pool->freeblock) = NULL;
UNLOCK();
return (void *)bp;
}
假設連續申請5塊大小為28位元組的記憶體，由於28位元組的對應size class index為3，所以會申請5塊32位元組的記憶體，原來freeblock執行的是下一個可用bock的起始地址，再次申請是，只需要返回freeblock指向的地址就可
以了，很顯然，freeblock需要前進，指向下一個可用block，此時nextoffset就發光發熱了，在pool header裡，nextoffset和maxoffset是對pool中的block步進迭代的變數，偏移地址恰好是下一個block的可用地址，在分配
完一個block之後，freeblock和nextoffset就移動一個block的距離，maxoffset則定義了最大的可用大小，劃定了block的邊界，nextoffset > maxoffset的時候，pool中的block就遍歷完了，恩，就是這樣的，申請->前進->
申請->前進......
但是假如一個block用完釋放了，假如申請了連續5塊32位元組的記憶體，2用完釋放了，下一個申請是用2還是6 ？
一旦py執行會有大量的這種記憶體碎片產生，py必須用一種機制把離散的記憶體管理起來，這就是自由的block連結串列，連結串列的關鍵就是header中的freeblock，回到上邊，pool申請初始化完成之後，會指向一個有效地址，為下一個可分配的記憶體地址，還設定了一個*freeblock，等到有記憶體釋放的時候，freeblock就會變成一個小精靈，
在這4k的記憶體上靈活舞動，哈哈~~
pool = POOL_ADDR(p);
if (Py_ADDRESS_IN_RANGE(p, pool)) {
/* We allocated this address. */
LOCK();
/* Link p to the start of the pool's freeblock list. Since
* the pool had at least the p block outstanding, the pool
* wasn't empty (so it's already in a usedpools[] list, or
* was full and is in no list -- it's not in the freeblocks
* list in any case).
*/
assert(pool->ref.count > 0);/* else it was empty */
*(block **)p = lastfree = pool->freeblock;
pool->freeblock = (block *)p;
if (lastfree) {
struct arena_object* ao;
uint nf; /* ao->nfreepools */
/* freeblock wasn't NULL, so the pool wasn't full,
* and the pool is in a usedpools[] list.
*/
if (--pool->ref.count != 0) {
/* pool isn't empty: leave it in usedpools */
UNLOCK();
return;
}
來看下，block釋放的時候，freeblock指向一個有效的pool地址，但是*freeblock是NULL，假設釋放的block是blockA，在pool->freeblock = (block *)p;的時候，freeblock的值被更新了，指向了blockA的首地址，在釋放下一個block的時候，同樣通過
*(block **)p = lastfree = pool->freeblock;
pool->freeblock = (block *)p;
把釋放的block連線到一起，形成自由連結串列，在需要記憶體的時候可以很方便的遍歷這個連結串列，優先使用被釋放的記憶體，當pool->freeblock為NULL的時候就不存在離散的自由連結串列了，分配nextblock即可，nextoffset > maxoffset時，一個pool就用完了，怎麼辦 ？哈哈，莫著急，一定是存在一個pool的集合的，這就是下邊要說的arean