內存池的使用場景
為什么要用內存池
為什么要用內存池？首先，在7 * 24h的服務器中如果不使用內存池，而使用malloc和free，那么就非常容易產生內存碎片，早晚都會申請內存失敗；并且在比較復雜的代碼或者繼承的屎山中，非常容易出現內存泄漏導致mmo的問題。
為了解決這兩個問題，內存池就應運而生了。內存池預先分配一大塊內存來做一個內存池，業務中的內存分配和釋放都由這個內存池來管理，內存池內的內存不足時其內部會自己申請。所以內存碎片的問題就交由內存池的算法來優化，而內存泄漏的問題只需要遵守內存池提供的api，就非常容易避免內存泄漏了。
即使出現了內存泄漏，排查的思路也很清晰。1.檢查是不是內存池的問題；2.如果不是內存池的問題，就檢查是不是第三方庫的內存泄漏。
內存池的使用場景
- 全局內存池
- 一個連接一個內存池(本文實現這個場景的內存池)
設計一個內存池
總體介紹
由于本文是一個連接一個內存池，所以后續介紹和代碼都是以4k為分界線，大于4k的我們認為是大塊內存；小于4k的我們認為是小塊內存。并且注意這里的4k，并不是嚴格遵照4096，而是在描述上，用4k比較好描述。
在真正使用內存之前，內存池提前分配一定數量且大小相等的內存塊以作備用，當真正被用戶調用api分配內存的時候，直接從內存塊中獲取內存（指小塊內存），當內存塊不夠用了，再有內存池取申請新的內存塊。而如果是需要大塊內存，則內存池直接申請大塊內存再返回給用戶。
內存池：就是將這些提前申請的內存塊組織管理起來的數據結構，內存池實現原理主要分為分配，回收，擴容三部分。
內存池原理之小塊內存：分配=> 內存池預申請一塊4k的內存塊，這里稱為block，即block=4k內存塊。當用戶向內存池申請內存size小于4k時，內存池從block的空間中劃分出去size空間，當再有新申請時，再劃分出去。擴容=> 直到block中的剩余空間不足以分配size大小，那么此時內存池會再次申請一塊block，再從新的block中劃分size空間給用戶。回收=> 每一次申請小內存，都會在對應的block中引用計數加1，每一次釋放小內存時，都會在block中引用計數減1，只有當引用計數為零的時候，才會回收block使他重新成為空閑空間，以便重復利用空間。這樣，內存池避免頻繁向內核申請/釋放內存，從而提高系統性能。
內存池原理之大塊內存：分配=> 因為大塊內存是大于4k的，所以內存池不預先申請內存，也就是用戶申請的時候，內存池再申請內存，然后返回給用戶。擴容=> 大塊內存不存在擴容。回收=> 對于大塊內存來說，回收就直接free掉即可。
上面理論講完了，下面來介紹如何管理小塊內存和大塊內存。
小塊內存的分配與管理
在創建內存池的時候，會預先申請一塊4k的內存，并且在起始處將pool的結構體和node的結構體放進去，從last開始一直到end都是空閑內存，中間的區域就用來存儲小塊內存。每一次mp_malloc，就將last指針后移，直到 e n d ? l a s t < s i z e end - last < size end?last
初始狀態
分配內存
擴容
大塊內存的分配與管理
對于大塊內存，前面已經說了，用戶申請的時候，內存池才申請
申請一塊大內存
再申請一塊大內存
內存池代碼實現
向外提供的api
- mp_create_pool：創建一個線程池，其核心是創建struct mp_pool_s這個結構體，并申請4k內存，將各個指針指向上文初始狀態的圖一樣。
- mp_destroy_pool：銷毀內存池，遍歷小塊結構體和大塊結構體，進行free釋放內存
- mp_malloc：提供給用戶申請內存的api
- mp_calloc：通過mp_malloc申請內存后置零，相當于calloc
- mp_free：釋放由mp_malloc返回的內存
- mp_reset_pool：將block的last置為初始狀態，銷毀所有大塊內存
- monitor_mp_poll：監控內存池狀態
struct mp_pool_s *mp_create_pool(size_t size);
void mp_destroy_pool(struct mp_pool_s *pool);
void *mp_malloc(struct mp_pool_s *pool, size_t size);
void *mp_calloc(struct mp_pool_s *pool, size_t size);
void mp_free(struct mp_pool_s *pool, void *p);
void mp_reset_pool(struct mp_pool_s *pool);
void monitor_mp_poll(struct mp_pool_s *pool, char *tk);
相關結構體的定義
mp_pool_s 就是整個內存池的管理結構，我們做的內存池是一個連接一個內存池，所以對于整個程序而言，內存池對象是有很多個的。
可能讀者會有疑問，有了head，為什么還有current，是因為如果一個block剩余空間小于size超過一定次數后，將current指向下一個block，這樣就加快內存分配效率，減少遍歷次數。
//每4k一block結點
struct mp_node_s {
unsigned char *end;//塊的結尾
unsigned char *last;//使用到哪了
struct mp_node_s *next;//鏈表
int quote;//引用計數
int failed;//失效次數
};
struct mp_large_s {
struct mp_large_s *next;//鏈表
int size;//alloc的大小
void *alloc;//大塊內存的起始地址
};
struct mp_pool_s {
struct mp_large_s *large;
struct mp_node_s *head;
struct mp_node_s *current;
};
內存對齊
訪問速度是內存對齊的原因之一，另外一個原因是某些平臺(arm)不支持未內存對齊的訪問
在4k里面劃分內存，那么必然有很多地方是不對齊的，所以這里提供兩個內存對齊的函數。那么為什么要內存對齊呢？其一：提高訪問速度；其二：某些平臺arm不支持未對其的內存訪問，會出錯。
#define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
#define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))
創建與銷毀內存池
創建一個線程池，其核心是創建struct mp_pool_s這個結構體，并申請4k內存，將各個指針指向上文初始狀態的圖一樣。
銷毀內存池，遍歷小塊結構體和大塊結構體，進行free釋放內存。
//創建內存池
struct mp_pool_s *mp_create_pool(size_t size) {
struct mp_pool_s *pool;
if (size < PAGE_SIZE || size % PAGE_SIZE != 0) {
size = PAGE_SIZE;
}
//分配4k以上不用malloc，用posix_memalign
/*
int posix_memalign (void **memptr, size_t alignment, size_t size);
*/
int ret = posix_memalign((void **) &pool, MP_ALIGNMENT, size); //4K + mp_pool_s
if (ret) {
return NULL;
}
pool- >large = NULL;
pool- >current = pool- >head = (unsigned char *) pool + sizeof(struct mp_pool_s);
pool- >head- >last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
pool- >head- >end = (unsigned char *) pool + PAGE_SIZE;
pool- >head- >failed = 0;
return pool;
}
//銷毀內存池
void mp_destroy_pool(struct mp_pool_s *pool) {
struct mp_large_s *large;
for (large = pool- >large; large; large = large- >next) {
if (large- >alloc) {
free(large- >alloc);
}
}
struct mp_node_s *cur, *next;
cur = pool- >head- >next;
while (cur) {
next = cur- >next;
free(cur);
cur = next;
}
free(pool);
}
提供給用戶的內存申請api
申請的內存以size做區分，如果大于4k就分配大塊內存，小于4k就去block里面劃分。
//分配內存
void *mp_malloc(struct mp_pool_s *pool, size_t size) {
if (size <= 0) {
return NULL;
}
if (size > PAGE_SIZE - sizeof(struct mp_node_s)) {
//large
return mp_malloc_large(pool, size);
}
else {
//small
unsigned char *mem_addr = NULL;
struct mp_node_s *cur = NULL;
cur = pool- >current;
while (cur) {
mem_addr = mp_align_ptr(cur- >last, MP_ALIGNMENT);
if (cur- >end - mem_addr >= size) {
cur- >quote++;//引用+1
cur- >last = mem_addr + size;
return mem_addr;
}
else {
cur = cur- >next;
}
}
return mp_malloc_block(pool, size);// open new space
}
}
void *mp_calloc(struct mp_pool_s *pool, size_t size) {
void *mem_addr = mp_malloc(pool, size);
if (mem_addr) {
memset(mem_addr, 0, size);
}
return mem_addr;
}
小塊內存block擴容
所有的block都 e n d ? l a s t < s i z e end - last < size end?last
//new block 4k
void *mp_malloc_block(struct mp_pool_s *pool, size_t size) {
unsigned char *block;
int ret = posix_memalign((void **) &block, MP_ALIGNMENT, PAGE_SIZE); //4K
if (ret) {
return NULL;
}
struct mp_node_s *new_node = (struct mp_node_s *) block;
new_node- >end = block + PAGE_SIZE;
new_node- >next = NULL;
unsigned char *ret_addr = mp_align_ptr(block + sizeof(struct mp_node_s), MP_ALIGNMENT);
new_node- >last = ret_addr + size;
new_node- >quote++;
struct mp_node_s *current = pool- >current;
struct mp_node_s *cur = NULL;
for (cur = current; cur- >next; cur = cur- >next) {
if (cur- >failed++ > 4) {
current = cur- >next;
}
}
//now cur = last node
cur- >next = new_node;
pool- >current = current;
return ret_addr;
}
分配大塊內存
//size >4k
void *mp_malloc_large(struct mp_pool_s *pool, size_t size) {
unsigned char *big_addr;
int ret = posix_memalign((void **) &big_addr, MP_ALIGNMENT, size); //size
if (ret) {
return NULL;
}
struct mp_large_s *large;
//released struct large resume
int n = 0;
for (large = pool- >large; large; large = large- >next) {
if (large- >alloc == NULL) {
large- >size = size;
large- >alloc = big_addr;
return big_addr;
}
if (n++ > 3) {
break;// 為了避免過多的遍歷，限制次數
}
}
large = mp_malloc(pool, sizeof(struct mp_large_s));
if (large == NULL) {
free(big_addr);
return NULL;
}
large- >size = size;
large- >alloc = big_addr;
large- >next = pool- >large;
pool- >large = large;
return big_addr;
}
釋放內存
如果是大塊內存，找到之后直接釋放；如果是小塊內存，將引用計數減1，如果引用計數為0則重置last。
//釋放內存
void mp_free(struct mp_pool_s *pool, void *p) {
struct mp_large_s *large;
for (large = pool- >large; large; large = large- >next) {//大塊
if (p == large- >alloc) {
free(large- >alloc);
large- >size = 0;
large- >alloc = NULL;
return;
}
}
//小塊 引用-1
struct mp_node_s *cur = NULL;
for (cur = pool- >head; cur; cur = cur- >next) {
// printf("cur:%p p:%p end:%pn", (unsigned char *) cur, (unsigned char *) p, (unsigned char *) cur- >end);
if ((unsigned char *) cur <= (unsigned char *) p && (unsigned char *) p <= (unsigned char *) cur- >end) {
cur- >quote--;
if (cur- >quote == 0) {
if (cur == pool- >head) {
pool- >head- >last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
}
else {
cur- >last = (unsigned char *) cur + sizeof(struct mp_node_s);
}
cur- >failed = 0;
pool- >current = pool- >head;
}
return;
}
}
}
內存池測試
//
// Created by 68725 on 2022/7/26.
//
#include < stdlib.h >
#include < stdio.h >
#include < string.h >
#define PAGE_SIZE 4096
#define MP_ALIGNMENT 16
#define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
#define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))
//每4k一block結點
struct mp_node_s {
unsigned char *end;//塊的結尾
unsigned char *last;//使用到哪了
struct mp_node_s *next;//鏈表
int quote;//引用計數
int failed;//失效次數
};
struct mp_large_s {
struct mp_large_s *next;//鏈表
int size;//alloc的大小
void *alloc;//大塊內存的起始地址
};
struct mp_pool_s {
struct mp_large_s *large;
struct mp_node_s *head;
struct mp_node_s *current;
};
struct mp_pool_s *mp_create_pool(size_t size);
void mp_destroy_pool(struct mp_pool_s *pool);
void *mp_malloc(struct mp_pool_s *pool, size_t size);
void *mp_calloc(struct mp_pool_s *pool, size_t size);
void mp_free(struct mp_pool_s *pool, void *p);
void mp_reset_pool(struct mp_pool_s *pool);
void monitor_mp_poll(struct mp_pool_s *pool, char *tk);
void mp_reset_pool(struct mp_pool_s *pool) {
struct mp_node_s *cur;
struct mp_large_s *large;
for (large = pool- >large; large; large = large- >next) {
if (large- >alloc) {
free(large- >alloc);
}
}
pool- >large = NULL;
pool- >current = pool- >head;
for (cur = pool- >head; cur; cur = cur- >next) {
cur- >last = (unsigned char *) cur + sizeof(struct mp_node_s);
cur- >failed = 0;
cur- >quote = 0;
}
}
//創建內存池
struct mp_pool_s *mp_create_pool(size_t size) {
struct mp_pool_s *pool;
if (size < PAGE_SIZE || size % PAGE_SIZE != 0) {
size = PAGE_SIZE;
}
//分配4k以上不用malloc，用posix_memalign
/*
int posix_memalign (void **memptr, size_t alignment, size_t size);
*/
int ret = posix_memalign((void **) &pool, MP_ALIGNMENT, size); //4K + mp_pool_s
if (ret) {
return NULL;
}
pool- >large = NULL;
pool- >current = pool- >head = (unsigned char *) pool + sizeof(struct mp_pool_s);
pool- >head- >last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
pool- >head- >end = (unsigned char *) pool + PAGE_SIZE;
pool- >head- >failed = 0;
return pool;
}
//銷毀內存池
void mp_destroy_pool(struct mp_pool_s *pool) {
struct mp_large_s *large;
for (large = pool- >large; large; large = large- >next) {
if (large- >alloc) {
free(large- >alloc);
}
}
struct mp_node_s *cur, *next;
cur = pool- >head- >next;
while (cur) {
next = cur- >next;
free(cur);
cur = next;
}
free(pool);
}
//size >4k
void *mp_malloc_large(struct mp_pool_s *pool, size_t size) {
unsigned char *big_addr;
int ret = posix_memalign((void **) &big_addr, MP_ALIGNMENT, size); //size
if (ret) {
return NULL;
}
struct mp_large_s *large;
//released struct large resume
int n = 0;
for (large = pool- >large; large; large = large- >next) {
if (large- >alloc == NULL) {
large- >size = size;
large- >alloc = big_addr;
return big_addr;
}
if (n++ > 3) {
break;// 為了避免過多的遍歷，限制次數
}
}
large = mp_malloc(pool, sizeof(struct mp_large_s));
if (large == NULL) {
free(big_addr);
return NULL;
}
large- >size = size;
large- >alloc = big_addr;
large- >next = pool- >large;
pool- >large = large;
return big_addr;
}
//new block 4k
void *mp_malloc_block(struct mp_pool_s *pool, size_t size) {
unsigned char *block;
int ret = posix_memalign((void **) &block, MP_ALIGNMENT, PAGE_SIZE); //4K
if (ret) {
return NULL;
}
struct mp_node_s *new_node = (struct mp_node_s *) block;
new_node- >end = block + PAGE_SIZE;
new_node- >next = NULL;
unsigned char *ret_addr = mp_align_ptr(block + sizeof(struct mp_node_s), MP_ALIGNMENT);
new_node- >last = ret_addr + size;
new_node- >quote++;
struct mp_node_s *current = pool- >current;
struct mp_node_s *cur = NULL;
for (cur = current; cur- >next; cur = cur- >next) {
if (cur- >failed++ > 4) {
current = cur- >next;
}
}
//now cur = last node
cur- >next = new_node;
pool- >current = current;
return ret_addr;
}
//分配內存
void *mp_malloc(struct mp_pool_s *pool, size_t size) {
if (size <= 0) {
return NULL;
}
if (size > PAGE_SIZE - sizeof(struct mp_node_s)) {
//large
return mp_malloc_large(pool, size);
}
else {
//small
unsigned char *mem_addr = NULL;
struct mp_node_s *cur = NULL;
cur = pool- >current;
while (cur) {
mem_addr = mp_align_ptr(cur- >last, MP_ALIGNMENT);
if (cur- >end - mem_addr >= size) {
cur- >quote++;//引用+1
cur- >last = mem_addr + size;
return mem_addr;
}
else {
cur = cur- >next;
}
}
return mp_malloc_block(pool, size);// open new space
}
}
void *mp_calloc(struct mp_pool_s *pool, size_t size) {
void *mem_addr = mp_malloc(pool, size);
if (mem_addr) {
memset(mem_addr, 0, size);
}
return mem_addr;
}
//釋放內存
void mp_free(struct mp_pool_s *pool, void *p) {
struct mp_large_s *large;
for (large = pool- >large; large; large = large- >next) {//大塊
if (p == large- >alloc) {
free(large- >alloc);
large- >size = 0;
large- >alloc = NULL;
return;
}
}
//小塊 引用-1
struct mp_node_s *cur = NULL;
for (cur = pool- >head; cur; cur = cur- >next) {
// printf("cur:%p p:%p end:%pn", (unsigned char *) cur, (unsigned char *) p, (unsigned char *) cur- >end);
if ((unsigned char *) cur <= (unsigned char *) p && (unsigned char *) p <= (unsigned char *) cur- >end) {
cur- >quote--;
if (cur- >quote == 0) {
if (cur == pool- >head) {
pool- >head- >last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
}
else {
cur- >last = (unsigned char *) cur + sizeof(struct mp_node_s);
}
cur- >failed = 0;
pool- >current = pool- >head;
}
return;
}
}
}
void monitor_mp_poll(struct mp_pool_s *pool, char *tk) {
printf("rnrn------start monitor poll------%srnrn", tk);
struct mp_node_s *head = NULL;
int i = 0;
for (head = pool- >head; head; head = head- >next) {
i++;
if (pool- >current == head) {
printf("current== >第%d塊n", i);
}
if (i == 1) {
printf("第%02d塊small block 已使用:%4ld 剩余空間:%4ld 引用:%4d failed:%4dn", i,
(unsigned char *) head- >last - (unsigned char *) pool,
head- >end - head- >last, head- >quote, head- >failed);
}
else {
printf("第%02d塊small block 已使用:%4ld 剩余空間:%4ld 引用:%4d failed:%4dn", i,
(unsigned char *) head- >last - (unsigned char *) head,
head- >end - head- >last, head- >quote, head- >failed);
}
}
struct mp_large_s *large;
i = 0;
for (large = pool- >large; large; large = large- >next) {
i++;
if (large- >alloc != NULL) {
printf("第%d塊large block size=%dn", i, large- >size);
}
}
printf("rnrn------stop monitor poll------rnrn");
}
int main() {
struct mp_pool_s *p = mp_create_pool(PAGE_SIZE);
monitor_mp_poll(p, "create memory pool");
#if 0
printf("mp_align(5, %d): %d, mp_align(17, %d): %dn", MP_ALIGNMENT, mp_align(5, MP_ALIGNMENT), MP_ALIGNMENT,
mp_align(17, MP_ALIGNMENT));
printf("mp_align_ptr(p- >current, %d): %p, p- >current: %pn", MP_ALIGNMENT, mp_align_ptr(p- >current, MP_ALIGNMENT),
p- >current);
#endif
void *mp[30];
int i;
for (i = 0; i < 30; i++) {
mp[i] = mp_malloc(p, 512);
}
monitor_mp_poll(p, "申請512字節30個");
for (i = 0; i < 30; i++) {
mp_free(p, mp[i]);
}
monitor_mp_poll(p, "銷毀512字節30個");
int j;
for (i = 0; i < 50; i++) {
char *pp = mp_calloc(p, 32);
for (j = 0; j < 32; j++) {
if (pp[j]) {
printf("calloc wrongn");
exit(-1);
}
}
}
monitor_mp_poll(p, "申請32字節50個");
for (i = 0; i < 50; i++) {
char *pp = mp_malloc(p, 3);
}
monitor_mp_poll(p, "申請3字節50個");
void *pp[10];
for (i = 0; i < 10; i++) {
pp[i] = mp_malloc(p, 5120);
}
monitor_mp_poll(p, "申請大內存5120字節10個");
for (i = 0; i < 10; i++) {
mp_free(p, pp[i]);
}
monitor_mp_poll(p, "銷毀大內存5120字節10個");
mp_reset_pool(p);
monitor_mp_poll(p, "reset pool");
for (i = 0; i < 100; i++) {
void *s = mp_malloc(p, 256);
}
monitor_mp_poll(p, "申請256字節100個");
mp_destroy_pool(p);
return 0;
}
nginx內存池對比分析
相關結構體定義對比
創建內存池對比
內存申請對比
聲明：本文內容及配圖由入駐作者撰寫或者入駐合作網站授權轉載。文章觀點僅代表作者本人，不代表電子發燒友網立場。文章及其配圖僅供工程師學習之用，如有內容侵權或者其他違規問題，請聯系本站處理。
舉報投訴
-
服務器
+關注
關注
12文章
9609瀏覽量
87048 -
內存
+關注
關注
8文章
3102瀏覽量
74908 -
API
+關注
關注
2文章
1556瀏覽量
63344 -
malloc
+關注
關注
0文章
53瀏覽量
167
發布評論請先 登錄
相關推薦
熱點推薦
C++內存池的設計與實現
內存池是池化技術中的一種形式。通常我們在編寫程序的時候回使用 new delete 這些關鍵字來向操作系統申請內存，而這樣造成的后果就是每次申請內存
發表于 09-23 10:22
?1087次閱讀
Linux內存系統：內存使用場景
out of memory 的時代過去了嗎？no，內存再充足也不可任性使用。1、內存的使用場景· page 管理· slab（kmalloc、內存池
發表于 08-25 07:42
內存池可以調節內存的大小嗎
嵌入式–內存池直接上代碼，自己體會。嵌入式設備，一般keil提供的堆很小，一般都不使用。使用內存池，自己可以調節內存大小。頭文件 mallo
發表于 12-17 07:00
RT-Thread內存管理之內存池實現分析
適合它們的高效率的內存分配算法，就將變得復雜化。RT-Thread 操作系統在內存管理上，根據上層應用及系統資源的不同，有針對性地提供了不同的內存分配管理算法。總體上可分為兩類：內存堆
發表于 10-17 15:06
什么是內存池
1什么是內存池 1.1池化技術 所謂“池化技術”，就是程序先向系統申請過量的資源，然后自己管理，以備不時之需。之所以要申請過 量的資源，是因為每次申請該資源都有較大的開銷，不如提前申請
高并發內存池項目實現
本項目實現了一個高并發內存池，參考了Google的開源項目tcmalloc實現的簡易版；其功能就是實現高效的多線程內存管理。由功能可知，高并發指的是高效的多線程，而內存
如何實現一個高性能內存池
寫在前面 本文的內存池代碼是改編自Nginx的內存池源碼，思路幾乎一樣。由于Nginx源碼的變量命名我不喜歡，又沒有注釋，看得我很難受。想自己寫一版容易理解的代碼。 應
nginx內存池源碼設計
造輪子內存池原因引入 作為C/C++程序員, 相較JAVA程序員的一個重大特征是我們可以直接訪問內存, 自己管理內存, 這個可以說是我們的特色, 也是我們的苦楚了. java可以有虛擬
內存池主要解決的問題
內存池的定義 1.池化技術 池 是在計算機技術中經常使用的一種設計模式，其內涵在于：將程序中需要經常使用的核心資源 先申請出來，放到一個池內，由程序自己管理，這樣可以提高資源的使用效率
工商網監
評論