效能優化-記憶體池的設計和實現

高效能架構探索 發表於 2021-12-02

大家好,我是雨樂!

在之前的文章中,我們分析了glibc記憶體管理相關的內容,裡面的是不是邏輯複雜😁,畢竟我們們用幾十行程式碼完成的功能,glibc要用上百乃至上千行程式碼來實現,畢竟它的受眾太多了,需要考慮跨平臺,各種邊界條件等。

其實,glibc的記憶體分配庫ptmalloc也可以看做是一個記憶體池,出於效能考慮,每次記憶體申請都是先從ptmalloc中進行分配,如果沒有合適的則通過系統分配函式進行申請;在釋放的時候,也是將被釋放記憶體先方式記憶體池中,記憶體池根據一定的策略,來決定是否進行shrink以歸還OS。

那麼,現一個記憶體池?我們該怎麼實現呢?今天,藉助這篇文章,我們一起來設計和實現一個記憶體池(文末附有github地址)。

背景

首先需要說明的是,該記憶體池是筆者在10年前完成的,下面先說下當時此專案的背景。

09年,在某所的時候,參與了某個國家級專案,該專案是防DDOS攻擊相關,因此更多的是跟IP相關,所以每次分配和釋放記憶體都是固定大小,經過測試,效能不是很滿意,所以,經過程式碼分析以及效能攻擊分析,發現裡面有大量的malloc/free,所以,當時就決定是否從malloc/free入手,能否優化整個專案的效能。

所以,決定實現一個Memory Pool,在做了調研以及研究了相關論文後,決定實現一個記憶體池,先試試水,所幸運的是,效能確實比glibc自帶的malloc/free要高,所以也就應用於專案上了。

本文所講的Memory Pool為C語言實現,旨在讓大家都能看懂,看明白(至少能夠完全理解本文所講的Memory Pool的實現原理)。

概念

首先,我們介紹下什麼是記憶體池?

預先在記憶體中申請一定數量的記憶體塊留作備用,當有新的記憶體需求時,就先從記憶體池中分配記憶體返回,在釋放的時候,將記憶體返回給記憶體池而不是OS,在下次申請的時候,重新返回

那麼為什麼要有記憶體池呢?這就需要從傳統記憶體分配的特點來進行分析,傳統記憶體分配釋放的優點無非就是 通用性強,應用廣泛,但是傳統的記憶體分配、釋放在某些特定的專案中,其不一定是最優、效率最高的方案。

傳統記憶體分配、釋放的缺點總結如下:

1、呼叫malloc/new,系統需要根據“最先匹配”、“最優匹配”或其他演算法在記憶體空閒塊表中查詢一塊空閒記憶體,呼叫free/delete,系統可能需要合併空閒記憶體塊,這些會產生額外開銷

2、頻繁的在堆上申請和釋放記憶體必然需要大量時間,降低了程式的執行效率。對於一個需要頻繁申請和釋放記憶體的程式來說,頻繁呼叫new/malloc申請記憶體,delete/free釋放記憶體都需要花費系統時間,頻繁的呼叫必然會降低程式的執行效率。

3、經常申請小塊記憶體,會將實體記憶體“切”得很碎,導致記憶體碎片。申請記憶體的順序並不是釋放記憶體的順序,因此頻繁申請小塊記憶體必然會導致記憶體碎片,造成“有記憶體但是申請不到大塊記憶體”的現象。

記憶體分配記憶體分配

從上圖中,可以看出,應用程式會呼叫glibc執行時庫的malloc函式進行記憶體申請,而malloc函式則會根據具體申請的記憶體塊大小,根據實際情況最終從sys_brk或者sys_mmap_pgoff系統呼叫申請記憶體,而大家都知道,跟os打交道,_效能損失_是毋庸置疑的。

其次,glibc作為通用的執行時庫,malloc/free需要滿足各種場景需求,比如申請的位元組大小不一,多執行緒訪問等。

效能優化-記憶體池的設計和實現

沒有比傳統malloc/free效能更優的方案呢?

答案是:有。

在程式啟動的時候,我們預分配特定數量的固定大小的塊,這樣每次申請的時候,就從預分配的塊中獲取,釋放的時候,將其放入預分配塊中以備下次複用,這就是所謂的_記憶體池技術_,每個記憶體池對應特定場景,這樣的話,較傳統的傳統的malloc/free少了很多複雜邏輯,效能顯然會提升不少。

效能優化-記憶體池的設計和實現

結合傳統malloc/free的缺點,我們總結下使用記憶體池方案的優點:

1、比malloc/free進行記憶體申請/釋放的方式快

2、不會產生或很少產生堆碎片

3、可避免記憶體洩漏

分類

根據分配出去的位元組大小是否固定,分為 固定大小記憶體池 和 可變大小記憶體池 兩類。

而可變大小記憶體池,可分配任意大小的記憶體池,比如ptmalloc、jemalloc以及google的tcmalloc。

效能優化-記憶體池的設計和實現

固定大小記憶體池,顧名思義,每次申請和釋放的記憶體大小都是固定的。每次分配出去的記憶體塊大小都是程式預先定義的值,而在釋放記憶體塊時候,則簡單的掛回記憶體池連結串列即可。

效能優化-記憶體池的設計和實現

本文主要講的是固定大小的記憶體池。

原理

記憶體池,重點在”池“字上,之所以稱之為記憶體池,是在真正使用之前,先預分配一定數量、大小預設的塊,如果有新的記憶體需求時候,就從記憶體池中根據申請的記憶體大小,分配一個記憶體塊,若當前記憶體塊已經被完全分配出去,則繼續申請一大塊,然後進行分配。

當進行記憶體塊釋放的時候,則將其歸還記憶體池,後面如果再有申請的話,則將其重新分配出去。

記憶體池結構圖記憶體池結構圖

上圖是本文所要設計的結構圖,下面在具體的設計之前,我們先講下本記憶體池的原理:

  • 建立並初始化頭結點MemoryPool
  • 通過MemoryPool進行記憶體分配,如果發現MemoryPool所指向的第一塊MemoryBlock或者現有MemoryPool沒有空閒記憶體塊,則建立一個新的MemoryBlock初始化之後將其插入MemoryPool的頭
  • 在記憶體分配的時候,遍歷MemoryPool中的單連結串列MemoryBlock,根據地址判斷所要釋放的記憶體屬於哪個MemoryBlock,然後根據偏移設定MemoryBlock的第一塊空閒塊索引,同時將空閒塊個數+1

上述只是一個簡單的邏輯講解,比較巨集觀,下面我們將通過圖解和程式碼的方式來進行講解。

設計

在上圖中,我們畫出了記憶體池的結構圖,從圖中,可以看出,有兩個結構變數,分別為MemoryPool和MemoryBlock。

下面我們將從資料結構和介面兩個部分出發,詳細講解記憶體池的設計。

資料結構

MemoryBlock

本文中所講述的記憶體塊的分配和釋放都是通過該結構進行操作,下面是MemoryBlock的示例圖:

MemoryBlockMemoryBlock

在上圖中,Header儲存該MemoryBlock的記憶體塊情況,比如可用的記憶體塊索引、當前MemoryBlock中可用記憶體塊的個數等等。

效能優化-記憶體池的設計和實現

定義如下所示:

struct MemoryBlock {
 unsigned int size;
 unsigned int free_size;
 unsigned int first_free;

 struct MemoryBlock *next;
 char a_data[0]; 
};

其中:

  • size為MemoryBlock下記憶體塊的個數
  • free_size為MemoryBlock下空閒記憶體塊的個數
  • first_free為MemoryBlock中第一個空閒塊的索引
  • next指向下一個MemoryBlock
  • a_data是一個柔性陣列

柔性陣列即陣列大小待定的陣列, C語言中結構體的最後一個元素可以是大小未知的陣列,也就是所謂的0長度,所以我們可以用結構體來建立柔性陣列。

它的主要用途是為了滿足需要變長度的結構體,為了解決使用陣列時記憶體的冗餘和陣列的越界問題。

MemoryPool

MemoryPool為記憶體池的頭,裡面定義了該記憶體池的資訊,比如本記憶體池分配的固定物件的大小,第一個MemoryBlock等

效能優化-記憶體池的設計和實現

struct MemoryPool {
 unsigned int obj_size;
 unsigned int init_size;
 unsigned int grow_size;

 MemoryBlock *first_block;
};

其中:

  • obj_size為記憶體池分配的固定記憶體塊的大小
  • init_size初始化記憶體池時候建立的記憶體塊的個數
  • grow_size當初始化記憶體塊使用完後,再次申請記憶體塊時候的個數
  • first_block指向第一個MemoryBlock

介面

memory_pool_create

MemoryPool *memory_pool_create(unsigned int init_size, 
                               unsigned int grow_size, 
                               unsigned int size);

本函式用來建立一個MemoryPool,並對其進行初始化,下面是引數說明:

  • init_size 表示第一個MemoryBlock中建立塊的個數
  • grow_size 表示當MemoryPool中沒有空閒塊可用,則建立一個新的MemoryBlock時其塊的個數
  • size 為塊的大小(即每次分配相同大小的固定size)

memory_alloc

void *memory_alloc(MemoryPool *mp);

本函式用了從mp中申請一塊記憶體返回

  • mp 為MemoryPool型別指標,即記憶體池的頭
  • 如果記憶體分配失敗,則返回NULL

memory_free

 void* memory_free(MemoryPool *mp, void *pfree);

本函式用來釋放記憶體

  • mp 為MemoryPool型別指標,即記憶體池的頭
  • pfree 為要釋放的記憶體

free_memory_pool

void free_memory_pool(MemoryPool *mp);

本函式用來釋放記憶體池

實現

在講解整個實現之前,我們先看先記憶體池的詳細結構圖。

效能優化-記憶體池的設計和實現

初始化記憶體池

MemoryPool是整個記憶體池的入口結構,該函式主要是用來建立MemoryPool物件,並使用引數對其內部的成員變數進行初始化。

函式定義如下:

MemoryPool *memory_pool_create(unsigned int init_size, unsigned int grow_size, unsigned int size)
{
 MemoryPool *mp;
 mp = (MemoryPool*)malloc(sizeof(MemoryPool));
 mp->first_block = NULL;
 mp->init_size = init_size;
 mp->grow_size = grow_size;

 if(size < sizeof(unsigned int))
  mp->obj_size = sizeof(unsigned int);
 mp->obj_size = (size + (MEMPOOL_ALIGNMENT-1)) & ~(MEMPOOL_ALIGNMENT-1);

 return mp;
}

記憶體分配

void *memory_alloc(MemoryPool *mp) {

 unsigned int i;
 unsigned int length;

 if(mp->first_block == NULL) {
  MemoryBlock *mb;
  length = (mp->init_size)*(mp->obj_size) + sizeof(MemoryBlock);
  mb = malloc(length);
  if(mb == NULL) {
   perror("memory allocate failed!\n");
   return NULL;
  }

  /* init the first block */
  mb->next = NULL;
  mb->free_size = mp->init_size - 1;
  mb->first_free = 1;
  mb->size = mp->init_size*mp->obj_size;

  mp->first_block = mb;
  
  char *data = mb->a_data;

  /* set the mark */
  for(i=1; iinit_size; ++i) {
   *(unsigned long *)data = i;
   data += mp->obj_size;
  }

  return (void *)mb->a_data;
 }

 MemoryBlock *pm_block = mp->first_block;

 while((pm_block != NULL) && (pm_block->free_size == 0)) {
  pm_block = pm_block->next;
 }

 if(pm_block != NULL) {
  char *pfree = pm_block->a_data + pm_block->first_free * mp->obj_size;

  pm_block->first_free = *((unsigned long *)pfree);
  pm_block->free_size--;

  return (void *)pfree;
 } else {
  if(mp->grow_size == 0)
   return NULL;
  
    MemoryBlock *new_block = (MemoryBlock *)malloc((mp->grow_size)*(mp->obj_size) + sizeof(MemoryBlock));

  if(new_block == NULL)
   return NULL;

  char *data = new_block->a_data;

  for(i=1; igrow_size; ++i) {
   *(unsigned long *)data = i;
   data += mp->obj_size;
  }  

  new_block->size = mp->grow_size*mp->obj_size;
  new_block->free_size = mp->grow_size-1;
  new_block->first_free = 1;
  new_block->next = mp->first_block;
  mp->first_block = new_block;
  
  return (void *)new_block->a_data;
 }
}

記憶體塊主要在MemoryBlock結構中,也就是說申請的記憶體,都是從MemoryBlock中進行獲取,流程如下:

  • 獲取MemoryPool中的first_block指標
    • 如果該指標為空,則建立一個MemoryBlock,first_block指向新建的MemoryBlock,並返回
    • 否則,從first_block進行單連結串列遍歷,查詢第一個free_size不為0的MemoryBlock,如果找到,則對該MemoryBlock的相關引數進行設定,然後返回記憶體塊
    • 否則,建立一個新的MemoryBlock,進行初始化分配之後,將其插入到連結串列的頭部(這樣做的目的是為了方便下次分配效率,即減小了連結串列的遍歷)

在上述程式碼中,需要注意的是第30-33行或者67-70行,這兩行的功能一樣,都是對新申請的記憶體塊進行初始化,這幾行的意思,是要將空閒塊連線起來,但是,並沒有使用傳統意義上的連結串列方式,而是通過index方式進行連線,具體如下圖所示: 效能優化-記憶體池的設計和實現

在上圖中,第0塊空閒塊的下一個空閒塊索引為1,而第1塊空閒塊的索引為2,依次類推,形成了如下連結串列方式

1->2->3->4->5

記憶體分配流程圖如下所示:

效能優化-記憶體池的設計和實現

記憶體釋放

void* memory_free(MemoryPool *mp, void *pfree) {
 if(mp->first_block == NULL) {
    return;
  }

 MemoryBlock *pm_block = mp->first_block;
 MemoryBlock *pm_pre_block = mp->first_block;
 
 /* research the MemoryBlock which the pfree in */
 while(pm_block && ((unsigned long)pfree < (unsigned long)pm_block->a_data || 
  (unsigned long)pfree>((unsigned long)pm_block->a_data+pm_block->size))) {
  //pm_pre_block = pm_block;
  pm_block = pm_block->next;

  if(pm_block == NULL) {
      return pfree;
    }
 }

 unsigned int offset = pfree -(void*) pm_block->a_data;

 if((offset&(mp->obj_size -1)) > 0) {
    return pfree;
  }

 pm_block->free_size++;
 *((unsigned int *)pfree) = pm_block->first_free;

 pm_block->first_free=(unsigned int)(offset/mp->obj_size);

 return NULL;
}

記憶體釋放過程如下:

  • 判斷當前MemoryPool的first_block指標是否為空,如果為空,則返回

  • 否則,遍歷MemoryBlock連結串列,根據所釋放的指標引數判斷是否在某一個MemoryBlock中

    • 如果找到,則對MemoryBlock中的各個引數進行操作,然後返回

    • 否則,沒有合適的MemoryBlock,則表明該被釋放的指標不在記憶體池中,返回

在上述程式碼中,需要注意第20-29行。

  • 第20行,求出被釋放的記憶體塊在MemoryBlock中的偏移
  • 第22行,判斷是否能被整除,即是否在這個記憶體塊中,算是個double check
  • 第26行,將該MemoryBlock中的空閒塊個數加1
  • 第27-29行,類似於連結串列的插入,將新釋放的記憶體塊的索引放入連結串列頭,而其內部的指向下一個可用記憶體塊

現在舉個例子,以便於理解,假設在一開始有5個空閒塊,其中前三個空閒塊都分配出去了,那麼此時,空閒塊連結串列如下

4->5,其中first_free = 4

然後在某一個時刻,第1塊釋放了,那麼釋放歸還之後,如下

1->4->5,其中first_free = 1

記憶體釋放流程圖如下:

記憶體釋放記憶體釋放

釋放記憶體池

void free_memory_pool(MemoryPool *mp) {
 MemoryBlock *mb = mp->first_block;

 if(mb != NULL) {
  while(mb->next != NULL) {
   s_memory_block *delete_block = mb;
   mb = mb->next;

   free(delete_block);
  }

  free(mb);
 }
  
 free(mp);
}

效能優化-記憶體池的設計和實現

上圖是一個完整的分配和釋放示意圖,下面,我結合程式碼來分析:

  • (a)步,建立了一個MemoryPool結構體
    • obj_size = 4代表本記憶體池分配的記憶體塊大小為4
    • init_size = 5代表建立記憶體池的時候,第一塊MemoryBlock的空閒記憶體塊個數為5
    • grow_size = 5代表當申請記憶體的時候,如果沒有空閒記憶體,則建立的新的MemoryBlock的空閒記憶體塊個數為5
  • (b)步,分配出去一塊記憶體
    • 此時,free_size即該MemoryBlock中可用空閒塊個數為4
    • first_free = 1,代表將記憶體塊分配出去之後,下一個可用的記憶體塊的index為1
  • (c)步,分配出去一塊記憶體
    • 此時,free_size即該MemoryBlock中可用空閒塊個數為3
    • first_free = 2,代表將記憶體塊分配出去之後,下一個可用的記憶體塊的index為2
  • (d)步,分配出去一塊記憶體
    • 此時,free_size即該MemoryBlock中可用空閒塊個數為2
    • first_free = 3,代表將記憶體塊分配出去之後,下一個可用的記憶體塊的index為3
  • (e)步,分配出去一塊記憶體
    • 此時,free_size即該MemoryBlock中可用空閒塊個數為1
    • first_free = 4,代表將記憶體塊分配出去之後,下一個可用的記憶體塊的index為4
  • (f)步,釋放第1個記憶體塊
    • 將free_size進行+1操作
    • fire_free值為此次釋放的記憶體塊的索引,而釋放的記憶體塊的索引裡面的值則為之前first_free的值(此處釋放用的前差法)
  • (g)步,釋放第3個記憶體塊
    • 將free_size進行+1操作
    • fire_free值為此次釋放的記憶體塊的索引,而釋放的記憶體塊的索引裡面的值則為之前first_free的值(此處釋放用的前差法)
  • (h)步,釋放第3個記憶體塊
    • 將free_size進行+1操作
    • fire_free值為此次釋放的記憶體塊的索引,而釋放的記憶體塊的索引裡面的值則為之前first_free的值(此處釋放用的前差法)

測試

測試程式碼如下:

#include "memory_pool.h"
#include <sys/time.h>
#include 
#include 

int main() {
  MemoryPool *mp = memory_pool_create(8);

  struct timeval start;
  struct timeval end;

  int t[] = {20000, 40000, 80000, 100000, 120000, 140000, 160000, 180000, 200000};
  int s = sizeof(t)/sizeof(int);
  for (int i = 0; i < s; ++i) {
    gettimeofday(&start, NULL);
    for (int j = 0; j < t[i]; ++j) {

      void *p = memory_alloc(mp);
      memory_free(mp, p);
     //
     //void *p = malloc(8);
     //free(p);
    }
    gettimeofday(&end, NULL);
    long cost = 1000000 * (end.tv_sec - start.tv_sec) +
                  end.tv_usec - start.tv_usec;

    printf("%ld\n",cost);
  }
  
  free_memory_pool(mp);
  return 0;
}

資料對比如下:

效能優化-記憶體池的設計和實現

從上圖可以看出,pool的分配效率高於傳統的malloc方式,效能提高接近100%

本測試結果僅針對當時的專案,對其他測試case不具有普遍性

擴充套件

在文章前面,我們有提過本記憶體池是_單執行緒、固定大小的_,但是往往這種還是不能滿足要求,如下幾個場景

  • 單執行緒多固定大小
  • 多執行緒固定大小
  • 多執行緒多固定大小

多固定大小,指的是提前預支需要申請的記憶體大小

單執行緒多固定大小: 針對此場景,由於已經預知了所申請的size,所以可以針對每個size建立一個記憶體池

多執行緒固定大小:針對此場景,有以下兩個方案

  • 使用ThreadLocalCache
  • 每個執行緒建立一個記憶體池
  • 使用加鎖,操作全域性唯一記憶體池(每次加鎖解鎖耗時100ns左右)

多執行緒多固定大小:針對此場景,可以結合上述兩個方案,即

  • 使用ThreadCache,每個執行緒內建立多固定大小的記憶體池
  • 每個執行緒內建立一個多固定大小的記憶體池
  • 使用加鎖,操作全域性唯一記憶體池(每次加鎖解鎖耗時100ns左右)

上述幾種方案,僅僅是在使用固定大小記憶體池基礎上進行的擴充套件,具體的方案,需要根據具體情況來具體分析

結語

本文主要講了固定大小記憶體池的實現方式,因為實現方案的侷限性,此記憶體池設計方案僅適用於每次申請都是特定大小的場景。雖然在擴充套件部分做了部分思維發散,但因為未做充分的資料對比,所以僅限於思維擴散。

目前,開源的記憶體分配庫很多,比較優秀的有谷歌的tcmalloc以及微軟的mimalloc,大家可以根據自己專案的需求場景,選擇合適的記憶體分配庫。

今天的文章就到這裡,下期見。

本文所講的記憶體池原始碼地址:

https://github.com/namelij/fixedsize_memorypool

別忘了給個star哦😁

相關文章