Python內存分配器（如何產生一個對象的過程）

時間  2019-11-09
標籤 python 內存 分配器 如何 產生 一個 對象 過程 欄目 Python 简体版
原文   原文鏈接

目錄python

內存分配器

Python中，當要分配內存時，不單純使用malloc/free,而是在其基礎上堆放三個獨立的分層，有效的進行分配。數組

舉個栗子：c語言中申請一片空間就須要使用malloc當釋放這個空間的時候就要使用free。Python把這一操做放在最底層也就是0層來實現。那麼0層之上是用來作什麼呢？咱們可能遇到過在python裏新建了a=5，b=5兩個對象，可是這兩個對象id是同樣的。這就是Python內存分配器的特色之一，它能夠不使用malloc申請空間，而是把對象池裏已有的對象返回給你。當這個數字足夠大好比說a=560000，b=560000,這時候就會發現兩個對象的id是不同的。這其實就是用了0層的malloc了。緩存

Python分配器分層

第0層往下是OS的功能。-2是隱含和機器的物理性相關聯的部分，OS的虛擬內存管理器負責這部分功能。-1層是與機器實際進行交互的部分，OS會執行這部分功能。安全

第3層到第0層調用了一些具備表明性的函數，下圖示：以生成字典對象爲例函數

咱們能夠看到，生成字典它從第三層的分配器，一直走，層層調用。直到使用malloc申請空間。性能

第零層--通用的基礎分配器

以Linux爲例，第0層就是指glibc的malloc()。對系統內存進行申請。測試

Python中並非在生成全部對象時都去調用malloc()，而是根據要分配的內存大小來改變分配方法。申請的內存大小若是大於256字節(源碼中規定爲256，可查看源碼)，就是用malloc()；若是小於256就是用1層或者2層。ui

Objects/obmalloc.c3d

#define SMALL_REQUEST_THRESHOLD   256

第一層--低級內存分配器

Python中的對象基本上都是小於等於256字節的，而且幾乎都是產生後立刻就要被廢棄的對象。指針

在這種狀況下，如過逐次從0層分配器開始，就會頻繁的malloc和free。效率上會有折扣。

所以再分配小對象時，Python內部就會有特殊的處理。實際上執行這一過程的正是第一層和第二層內存分配器。當須要分配小於等於256字節的對象時，就利用第一層的內存分配器，在這一層會事先從第0層開始迅速保留內存空間，將其蓄積起來。第一層的做用就是管理蓄積的空間。(其實就是一個對象池，上層對它進行管理，以應對頻繁產生又釋放的對象。)

內存結構

根據管理的空間不一樣，他們各自的叫法也不一樣。他們之間的關係式包含關係。

  • 最小的單位爲block，最終給申請者的就是block的地址。
  • 比他大的是pool(pool包含block)。
  • 最大的是arena(arena包含pool)。

arena > pool >block。爲避免頻繁的嗲用malloc和free，第0層分配器會以最大的單位arena來保留內存。pool是用於有效管理空的block的。

arena

Objects/objmalloc.c

struct arena_object {
    /* malloc後的arena的地址*/
    uptr address;
    /* 將arena的地址用於給pool使用而對齊的地址 */
    block* pool_address;
    /* 此arena中空閒的pool數量 */
    uint nfreepools;
    /* 此arena中pool的總數 */
    uint ntotalpools;
    /* 鏈接空閒pool的單向鏈表 */
    struct pool_header* freepools;
    /* 稍後說明 */
    struct arena_object* nextarena;
    struct arena_object* prevarena;
    };

以上就是 arena_object結構體，它管理者arena。

  • arena_object的成員address保存的是使用第0層內存分配器分配的arena地址。arena大小固定爲256k。此大小也是宏定義好的。
  • arena_object的成員pool_address中保存的是arena裏開頭的pool地址。這裏有個問題，爲何除了域address以外還要一個pool地址呢？arena的地址和其中第一個的pool地址應該是一致的呀！這是由於咱們用到了系統中的頁，爲了使用頁的功能，因此要和頁對齊才致使arena地址不是第一個pool地址。(以後又詳細說明)
  • arena_object還承擔着保持被分配的pool的數量，將空pool鏈接到單向鏈表的功能。
  • 此外arena_object被數組arenas管理。

Objects/obmalloc.c

/* 將arena_object做爲元素的數組 */
static struct arena_object* arenas = NULL;
/* arenas的元素數量 */
static uint maxarenas = 0;

  • arena_object中有uptr和block和uint。他們都是用宏定義 定義的別名。
#undef uchar 
#define uchar     unsigned char     /* 約8位 unsigned表示無符號*/
#undef uint 
#define uint      unsigned int      /* 約大於等於16位 */
#undef ulong 
#define ulong     unsigned long     /* 約大於等於32位 */
#undef uptr 
#define uptr      Py_uintptr_t
typedef uchar block;
  • 其中Py_uintptr_t是整數型的別名，用來存放指針的，根據編譯環境的不一樣略有差別。定義以下
//Include/pyport.h
typedef uintptr_t     Py_uintptr_t;

當cpu爲32位時，指針幾乎都是4字節，當64位時，指針則是8字節。咱們在32位的機器上把指針轉化爲整數沒問題(由於要把指針當整數存儲)，可是64位上時面對8字節的指針，4字節的int就會溢出。因此 出現了uintptr_t。它負責安全的根據環境變換成4字節或8字節，將指針安全的轉化，避免發生溢出。

pool

arena內部各個pool的大小固定爲4k字節。（計算機內存中的頁就是這麼大，設置爲4k字節）

大多數的OS都是以頁爲單位來管理內存的。把pool的大小和頁設置爲同樣，就能讓OS以pool爲單位來管理內存。

arena內的pool內存被劃分爲4k字節的倍數進行對齊。也就是說，每一個pool開頭的地址爲4k字節的倍數。在這裏就發現了arena的地址和第一個pool的地址頗有多是不同的。因此咱們要把pool對齊在內存上。

咱們來看看pool的頭部存的信息。

struct pool_header {
    /* 分配到pool裏的block的數量 */
    union { block *_padding;
        uint count; } ref;
    /* block的空閒鏈表的開頭 */
    block *freeblock;
    /* 指向下一個pool的指針（雙向鏈表） */
    struct pool_header *nextpool;
    /* 指向前一個pool的指針（雙向鏈表） */
    struct pool_header *prevpool;
    /* 本身所屬的arena的索引（對於arenas而言） */
    uint arenaindex;
    /* 分配的block的大小 */
    uint szidx;
    /* 到下一個block的偏移 */
     uint nextoffset;
    /* 到能分配下一個block以前的偏移 */
    uint maxnextoffset;
};

結構體pool_header就跟它的名字同樣，必須安排在各個pool開頭。pool_header 在arena內將各個pool相鏈接,保持pool內的block的大小和個數。

new arena

生成arena的代碼是用new_arena() 函數寫的，因此咱們先來粗略地看一下new_ arena() 函數的總體結構。

Objects/obmalloc.c:new_arena()

static struct arena_object*
new_arena(void) {

    struct arena_object* arenaobj;
    if (unused_arena_objects == NULL) {
       /* 生成arena_object */
       /* 把生成的arena_object 補充到arenas和unused_arena_objects裏        */
    }
    /* 把arena分配給未使用的arena_object */
    /* 把arena內部分割成pool */
    return arenaobj; /* 返回新的arena_object */ }

具體怎麼分配的，這裏就不細說了。

usable_arenas和unused_arena_objects

管理arena的全局變量usable_arenas和unused_ared_arena_objects。咱們來看看他倆的功能。

unused_arena_objects
          將如今未被使用的arena_object鏈接到單向鏈表。
          （能夠說arena還未獲得保留）
          arena_object是從new_arena()內列表的開頭取的。
          此外，在 PyObject_Free()時arena爲空的狀況下，arena_object會被追加到這個列表的開頭。
          注意：只有當結構體arena_object的成員address爲0時，纔將其存入這個列表。
          
usable_arenas
          這是持有arena的arena_object的雙向鏈表，其中arena分配了可利用的pool。
          這個pool正在等待被再次使用，或者還未被使用過。
          這個鏈表按照block數量最多的arena的順序排列。
          （基於成員nfreepools升序排列）
          這意味着下次分配會從使用得最多的arena開始取。
          而後它也會給不少將幾乎爲空的arena返回系統的機會。
          根據個人測試，這項改善可以在很大程度上釋放arena。

在沒有能用的arena時，咱們使用unused_arena_objects。若是在分配時沒有arena就從這個鏈表中取出一個arena_object，分配一個新的arena。

當沒有能用的pool時，則使用usable_arenas。若是再分配時沒有pool，就從這個鏈表中取出arena_object，從分配的arena中拿一個pool。

unused_arena_objects是單向鏈表，usable_arenas是雙向鏈表。當咱們採用unused_aren_objects時，只能使用結構體arena_object的成員nextarena；而當咱們採用usable_arenas時，則可使用成員nextarena和成員pervarena。其中成員nextarena和成員pervarena。在不一樣狀況下用法是不一樣的。

第一層總結

第一層分配器的任務就是生成arena和pool，將其存入arenas裏，或者鏈接到unused_arena_objects，用一句話來講就是管理arena。

第二層--對象分配器

第二層的分配器是負責管理pool內的block的。這一層將block的開頭地址返回給申請者，並釋放block等。

block

  • pool被分割成一個個block，Python的對象最終都會是這個block(在不大於256字節的狀況下)
  • block劃分的大小在pool初始化的時候就決定了，咱們將每一個block大小定位8的倍數，相應的地址也就是8的倍數了。
  • 爲何要使用8個字節呢？咱們以前說過兼容性的一個問題。block設置爲8在64位和32位cpu中都是兼容的，固然有興趣也能夠設置爲24。可是若是不這樣作就有可能出現「非法對齊的狀況」。

申請的大小和對應的block大小以下表示：

利用地址對齊的hack

假設結構體存入某個指針，若是malloc()返回的地址是按8字節對齊的，那麼指針低三位確定爲0。因而咱們想用它來作標誌使用。當咱們真的要訪問這個指針時，就將低三位設爲0，無視標識。

usedpools

Python的分配器採用Best-fit的策略，也就是說盡量的分配大小接近的塊。所以在一開始就要找到適合大小的block的pool。並且搜索這個pool必須是高速的，不然會影響程序的性能。

翻過來，當咱們找到pool後，無論大小如何，只要在發現的pool內找到一個空的block就能輕鬆地劃分block。那麼怎麼實現告訴搜索pool呢？這就是咱們要介紹的usedpools。

usedpools是保持pool的數組，其結果以下圖示：

每一個pool用雙向鏈表相連，造成了一個雙循環鏈表，usedpools裏存儲的是指向開頭pool的指針。usedpools負責從衆多pool裏返回適和申請的pool。那麼申請空間的大小和對應的pool對應關係以下圖示：

也就是說，若是申請大小爲20字節，根據上表索引出2的元素中的pool。這樣咱們就能以O(1)的搜索時間申請符合大小的pool了。

這個usedpools內的pool鏈表是雙向鏈表鏈接的，事實上，一旦pool內部的全部block被釋放，就會將這個空pool返回給arena。可是咱們並不知道那個pool釋放的block，所以這就增長了pool鏈表的中途釋放block的可能性。

在這種狀況下，咱們就必須從鏈表中取出pool。

在實際狀況中usedpools並非咱們上圖所示，應該是以下圖示纔對：

並且每一pool都有pool_header,保存它的相關信息。

struct pool_header {
    union { block *_padding;
    uint count; } ref;
    block *freeblock;
    struct pool_header *nextpool;
    struct pool_header *prevpool;
    uint arenaindex;
    uint szidx;
    uint nextoffset;
    uint maxnextoffset;
    };

這裏有成員nextpool和prevpool。就是雙向鏈表的下和上。

上面的過程有一點是想不通的，爲何不直接那usedpools來當結構體pool_header的數組？咱們來想一想爲何不讓他存信息。加入說咱們要緩存used_pools呢？那是否是usedpools就會變得很大，難以被緩存。因此咱們以爲不給它裏面放入信息，減輕緩存的壓力，這種思路在之後也是用獲得的。

block狀態管理

pool內被block徹底填滿了，那麼pool是怎麼進行狀態管理的呢？block狀態分爲如下三種。

  • 已經分配
  • 使用完畢 使用過一次，已經被釋放的block。
  • 未使用 一次都沒有使用過的block。

當mutator申請分配block時，pool必須迅速的把使用完畢或者未使用的block傳過去。pool中分別使用不一樣方法來管理使用完畢的pool和未使用的pool。

使用完畢的pool：會被鏈接到一個叫作freeblock的空閒鏈表進行管理。block是在釋放的時候會被鏈接到空閒鏈表的。由於使用完畢的block確定會通過了使用-》釋放的流程，因此釋放時空閒鏈表開頭的地址就會被直接寫入做爲釋放對象的block內。以後咱們將釋放完畢的block的地址存入freeblock中，這個freeblock是由pool_header定義的。咱們將freeblock放在開頭，造成block的空閒鏈表。

未使用的block：由於他沒有使用過，所以咱們使用從pool開頭的偏移量來進行管理。pool_header的成員nextoffset中保留着偏移量。

此咱們分配的未使用的block是連續的block。由於分配時是從pool的開頭開始分配 block 的，因此其中不會出現使用完畢的 block 和已經分配的 block。所以咱們只要將偏移量 偏移到下一個 block，就知道它確實是未使用的 block 了。

PyObject_Malloc()

PyObject_Malloc()函數有三個做用，分配block，分配pool，分配arena。

函數功能以下Objects/obmalloc.c:PyObject_Malloc()

void* PyObject_Malloc(size_t nbytes) {
    /* 是否小於等於256字節？ */
    if ((nbytes - 1) < SMALL_REQUEST_THRESHOLD) {
    
        /* 將申請的字節數，經過公式轉化成usedpools的索引。
            拿到索引後判斷pool是否已經鏈接到了索引指定的usedpools的
            若是已經鏈接到了，pool和pool->nextpool的地址就會不一樣。
        */
        
        if (pool != pool->nextpool) {
        
            /* 若是已經鏈接到了（pool已經被分配） */
            /* 從空閒鏈表上取出block，當block內的鏈表下一個空block地址爲NULL時，經過偏移量取出block*/
            /*拿到block後 return*/
            
        }
        
        /* 是否存在可使用的arena？pool未被分配 */
        if (usable_arenas == NULL) {
            /* 使用new_arena()方法產生新的arena
            /* 將新的arena_object設置到usable_arenas中。 */
            
            }
            
     /* 從arena取出使用完畢的pool */
     
     pool = usable_arenas->freepools;
     
        /* 是否存在使用完畢的pool？ */
        if (pool != NULL) {
            /* 從arnea中取出使用完畢的pool */
            /* 對arena中可用的pool數進行減一*/
            /*判斷arena中還有沒有可用的pool，若是沒有咱們將下一個arena_object設置到usable_arenas裏。由於咱們設置的新arena是在鏈表的開頭，因此他沒有prevarena，因此要設置爲NULL.
            
            /* 將pool鏈接到usedpools開頭 */
            /* 比較申請的大小和pool中固定的block大小*/
            /*若是是舊的pool，就有合適的大小，取出對應的block並返回。*/
            /*不然，就要初始化block*/
            /*返回合適的block地址*/
        }
        
        /* 初始化空pool */
        
        /* 將pool鏈接到usedpools開頭 */
        /* 比較申請的大小和pool中固定的block大小*/
        /*若是是舊的pool，就有合適的大小，取出對應的block並返回。*/
        /*不然，就要初始化block*/
        /*返回合適的block地址*/
    }
    
redirect:
    /* 當大於等於256字節時，按通常狀況調用malloc */
    return (void *)malloc(nbytes); }

PyObject_Free()

該函數有三個做用，釋放block，釋放pool，釋放arena
函數功能以下Objects/obmalloc.c:PyObject_Free()

void PyObject_Free(void *p) {

    pool = POOL_ADDR(p);
    if (Py_ADDRESS_IN_RANGE(p, pool)) {
    
        LOCK();
        
        /* 把做爲釋放對象的block鏈接到freeblock開頭 */
        
        /* 這個pool中最後free的block是否爲NULL？ */
        if (lastfree) {
        
            /* pool中有已經分配的block */
            if (--pool->ref.count != 0) {
            /* 不執行任何操做 */
            UNLOCK();
            return;
            }
            
            /* 當pool中全部的block爲空時候將pool返回給arena，鏈接到freepools。 */
            
            /* 當arena內全部pool爲空時 */
            if (nf == ao->ntotalpools) {
            
            /* 這時候就要釋放arena，從used_arenas取出對象arena_object,將其鏈接到unused_arena_objects */
            /*以後釋放arena，在釋放後，爲了識別arena沒由被分配，將其arena_object的成員address設爲0*/
    
            
            return;
            }
            /* arena還剩一個空pool */
            if (nf == 1) {
            
            /* 將arena_object鏈接到useable_arenas的開頭 */
            
            return;
            }
            
            /* 針對usable_arenas,將空pool少的arenas排在前面。 */
            
            return;
            }
            
            /* 當lastfree爲NULL時，也就是說，將要執行釋放block操做的時候。*/
            /* 在usedpools的開頭插入pool */
        
        return;
        }
        
    /* 釋放其餘空間 */
    
    free(p);
    }

arena和pool的釋放策略

在PyObject_Free() 函數中咱們用到了幾個小技巧，其中的一個就是「優先使用被利用最多的內存空間」。 在插入 pool 的過程當中，當從 usedpools取出的pool經過釋放 block 的操做返回 usedpools 時，這個 pool 已經被插入了usedpools的元素內的開頭。

這樣的操做，可使一些不常用的內存空間變爲空，將其回收。同時也提升了內存的利用率。

從block搜索pool的技巧

咱們來看看一個宏定義。

#define POOL_ADDR(P) (P & 0xfffff000)

以前咱們說過，pool地址是按4k對齊的，也就是說只要從pool內部某處block地址開始用0xffff000標記，確定能取到pool的開頭。

計算和順序查找嘛。（通常來講採用計算會比較快一點）

通常認爲從地址去找所屬的 pool 是一項很是花時間的處理。比較笨的辦法就是取出一個 pool，檢查其範圍內是否有對象的地址，若是沒有就再取出下一個pool……可是這樣一來， 每次 pool 增長時計算量也會相應地增長。

第三層--對象特有的分配器

對象有列表和元組等類型。在生成他們的時候要使用個自特有的分配器。下面以字典爲例。

Objects/dictobject.c

#ifndef PyDict_MAXFREELIST
#define PyDict_MAXFREELIST 80
#endif
static PyDictObject *free_list[PyDict_MAXFREELIST];
static int numfree = 0;

這裏將空閒鏈表定義爲有80個元素的數組，使用完畢的鏈表對象會被初始化並存入空閒鏈表中。

負責釋放字典對象的函數以下示：

Objects/dictobject.c

static void
dict_dealloc(register PyDictObject *mp)
{    /* 省略部分：釋放字典對象內的元素 */
    /* 檢查空閒鏈表是否爲空 */    /* 檢查釋放對象是否爲字典型 */    if (numfree < PyDict_MAXFREELIST && Py_TYPE(mp) == &PyDict_Type)
        free_list[numfree++] = mp;
    else
        Py_TYPE(mp)->tp_free((PyObject *)mp);
}

若是釋放字典對象時空閒鏈表有空間，那麼就將使用完畢的字典對象存入空鏈表。另外一方面若是使用完畢的字典對象吧用於空閒鏈表的數組填滿了，就認爲沒有必要再去保留這個對象了，直接進行釋放操做。

分配字典對象 Objects/dictobject.c

PyObject *
PyDict_New(void)
{
    register PyDictObject *mp;
    /* 檢查空閒鏈表內是否有對象 */
    if (numfree) {
        mp = free_list[--numfree];
        _Py_NewReference((PyObject *)mp);
    } else {        
        /* 若是沒有對象就新分配對象 */
        mp = PyObject_GC_New(PyDictObject, &PyDict_Type);
        if (mp == NULL)
            return NULL;
    }
    return (PyObject *)mp;
}

若是空閒鏈表有對象，函數就返回它。若是空閒鏈表裏沒有對象，那就分配對象。用到這個空閒鏈表的分配器就是第一次的「對象特有的分配器」。

這個對象特有的分配器還實現了列表，元組等。這些類型都會頻繁的生產和銷燬對象。所以咱們都採用這種方法經過使用鏈表就能重複利用必定個數的對象。

這個空閒鏈表和棧同樣採用FILO（First In Last Out）。

分配器總結

Python再生產字典對象時，分配器的交互以下圖示：

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程