介绍
这个项目是在阅读nginx内存池源码后，将其代码重新用C++面向对象的方式实现，大体与源码相同，旨在加深对nginx内存池的理解。
运行环境
-
VS2019
-
win10
内存池类成员声明
// ngx_mem_pool.h
#pragma once
#include <string.h>
using u_char = unsigned char;
using ngx_uint_t = unsigned int;
struct ngx_pool_s;
#define ngx_memzero(buf, n) (void) memset(buf, 0, n)
#define NGX_ALIGNMENT sizeof(unsigned long)
#define ngx_align(d, a) (((d) + (a - 1)) & ~(a - 1))
#define ngx_align_ptr(p, a) \
(u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
// 移植 nginx内存池代码，用C++ oop来实现
// _s代表struct, _t代表typedef之后的类型
// 清理资源的类型，每个对象绑定一个函数
typedef void (*ngx_pool_cleanup_pt)(void* data);
struct ngx_pool_cleanup_s {
ngx_pool_cleanup_pt handler; // 自定义的资源释放函数
void* data; // handler的参数
ngx_pool_cleanup_s* next; // 指向下一个清理操作（对象）
};
// 大块内存的头部信息
struct ngx_pool_large_s {
ngx_pool_large_s* next; // 大块内存的头部信息用链表连接起来
void* alloc; // 指向实际分配出的内存
};
// 小块内存的内存池的头部字段
struct ngx_pool_data_t {
u_char* last;
u_char* end;
ngx_pool_s* next;
ngx_uint_t failed;
};
struct ngx_pool_s {
ngx_pool_data_t d; // 小块内存池中的相关指针及参数
size_t max;
ngx_pool_s* current;
ngx_pool_large_s* large; // 大块内存分配的起点
ngx_pool_cleanup_s* cleanup;
};
// 从池中可获得的最大内存数为4095，即一个页面的大小
const int ngx_pagesize = 4096;
// 小块内存池可分配的最大空间
const int NGX_MAX_ALLOC_FROM_POOL = ngx_pagesize - 1;
// 表示一个默认内存池开辟的大小
const int NGX_DEFAULT_POOL_SIZE = 16 * 1024; // 16K
// 按16B对齐
const int NGX_POOL_ALIGNMENT = 16;
// ngx_align就是和SGI STL二级空间配置器的 _S_round_up函数相同，对齐到NGX_POOL_ALIGNMENT
// ngx小块内存池的最小size调整为 NGX_POOL_ALIGNMENT 的倍数
const int NGX_MIN_POOL_SIZE = ngx_align((sizeof(ngx_pool_s) + 2 * sizeof(ngx_pool_large_s)), NGX_POOL_ALIGNMENT);
class ngx_mem_pool
{
public:
void* ngx_create_pool(size_t size);
// 内存分配，支持内存对齐
void* ngx_palloc(size_t size);
// 内存分配，不支持内存对齐
void* ngx_pnalloc(size_t size);
// 内存分配，支持内存初始化为0
void* ngx_pcalloc(size_t size);
// 大块内存释放
void ngx_pfree(void* p);
// 内存池重置函数
void ngx_reset_pool();
// 内存池销毁函数
void ngx_destroy_pool();
// 内存池清理操作添加函数
ngx_pool_cleanup_s* ngx_pool_cleanup_add(size_t size);
private:
ngx_pool_s* pool; // 管理内存池的指针
// 小块内存分配
inline void* ngx_palloc_small(size_t size, ngx_uint_t align);
// 大块内存分配
void* ngx_palloc_large(size_t size);
// 分配的新的小块内存池
void* ngx_palloc_block(size_t size);
};
成员函数的定义实现
// ngx_mem_pool.cpp
#include "ngx_mem_pool.h"
#include <stdlib.h>
void* ngx_mem_pool::ngx_create_pool(size_t size)
{
ngx_pool_s* p;
p = (ngx_pool_s*)malloc(size);
if (p == nullptr)
{
return nullptr;
}
p->d.last = (u_char*)p + sizeof(ngx_pool_s);
p->d.end = (u_char*)p + size;
p->d.next = nullptr;
p->d.failed = 0;
size = size - sizeof(ngx_pool_s); // 内存池实际的可分配内存空间
p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;
p->current = p;
p->large = nullptr;
p->cleanup = nullptr;
pool = p;
return p;
}
inline void* ngx_mem_pool::ngx_palloc_small(size_t size, ngx_uint_t align)
{
u_char* m;
ngx_pool_s* p;
p = pool->current;
do {
m = (u_char*)p->d.last;
// m = (u_char*)p->current;
if (align)
{
m = ngx_align_ptr(m, NGX_ALIGNMENT);
}
if ((size_t)(p->d.end - m) >= size)
{
p->d.last = m + size;
return m;
}
p = p->d.next; // 到下一个小块内存池尝试
} while (p);
return ngx_palloc_block(size);
}
void* ngx_mem_pool::ngx_palloc_block(size_t size)
{
u_char* m;
size_t psize;
ngx_pool_s* p, * newpool;
psize = (size_t)(pool->d.end - (u_char*)pool);
m = (u_char*)malloc(psize);
if (m == NULL) {
return NULL;
}
newpool = (ngx_pool_s*)m;
newpool->d.end = m + psize;
newpool->d.next = NULL;
newpool->d.failed = 0;
m += sizeof(ngx_pool_data_t);
m = ngx_align_ptr(m, NGX_ALIGNMENT);
newpool->d.last = m + size;
for (p = pool->current; p->d.next; p = p->d.next) {
if (p->d.failed++ > 4) {
// 分配内存失败次数大于4就将current设置为下一个内存池块
pool->current = p->d.next;
}
}
p->d.next = newpool;
return m;
}
void* ngx_mem_pool::ngx_palloc_large(size_t size)
{
void* p;
ngx_uint_t n;
ngx_pool_large_s* large;
p = malloc(size); // malloc,实际分配的内存空间
if (p == nullptr) {
return nullptr;
}
n = 0;
// 复用已释放空间内存头信息
for (large = pool->large; large; large = large->next) {
if (large->alloc == nullptr) {
large->alloc = p;
return p;
}
if (n++ > 3) {
break;
}
}
// 大块内存的头信息也是存在小块内存池中！！
large = (ngx_pool_large_s*)ngx_palloc_small(sizeof(ngx_pool_large_s), 1);
if (large == nullptr) {
free(p);
return nullptr;
}
large->alloc = p;
large->next = pool->large; // 头插法
pool->large = large;
return p;
}
void ngx_mem_pool::ngx_pfree(void* p)
{
ngx_pool_large_s* l;
// 查找 alloc 与 p相同的内存将其释放掉
for (l = pool->large; l; l = l->next)
{
if (p == l->alloc)
{
free(l->alloc);
l->alloc = nullptr;
return;
}
}
}
void* ngx_mem_pool::ngx_palloc(size_t size)
{
if (size <= pool->max)
{
return ngx_palloc_small(size, 1);
}
return ngx_palloc_large(size);
}
void* ngx_mem_pool::ngx_pnalloc(size_t size)
{
if (size <= pool->max) {
return ngx_palloc_small(size, 0); // 不对齐
}
return ngx_palloc_large(size);
}
void* ngx_mem_pool::ngx_pcalloc(size_t size)
{
void* p;
p = ngx_palloc(size);
if (p)
{
ngx_memzero(p, size);
}
return p;
}
void ngx_mem_pool::ngx_reset_pool()
{
ngx_pool_s* p;
ngx_pool_large_s* l;
for (l = pool->large; l; l = l->next)
{
if (l->alloc)
{
free(l->alloc);
}
}
// 特殊处理第一块内存池
p = pool;
p->d.last = (u_char*)p + sizeof(ngx_pool_s);
p->d.failed = 0;
// 第二个到结尾内存池没有多余的头部信息，如current、cleanup
for (p = p->d.next; p; p = p->d.next) {
p->d.last = (u_char*)p + sizeof(ngx_pool_data_t);
p->d.failed = 0;
}
pool->current = pool;
pool->large = nullptr;
}
void ngx_mem_pool::ngx_destroy_pool()
{
ngx_pool_s* p, * n;
ngx_pool_large_s* l;
ngx_pool_cleanup_s* c;
// 释放外部资源，通过调用自己实现的释放资源函数
for (c = pool->cleanup; c; c = c->next)
{
if (c->handler)
{
c->handler(c->data);
}
}
// 大块内存池释放
for (l = pool->large; l; l = l->next)
{
if (l->alloc)
{
free(l->alloc);
}
}
// 小块内存池释放
for (p = pool, n = pool->d.next; ; p = n, n = n->d.next)
{
free(p);
if (n == nullptr)
{
break;
}
}
}
// size表示清理函数参数的大小
ngx_pool_cleanup_s* ngx_mem_pool::ngx_pool_cleanup_add(size_t size)
{
ngx_pool_cleanup_s* c;
// 头部信息存储在小块内存池
c = (ngx_pool_cleanup_s*)ngx_palloc(sizeof(ngx_pool_cleanup_s));
if (c == nullptr)
{
return nullptr;
}
if (size)
{
c->data = ngx_palloc(size);
if (c->data == nullptr)
{
return nullptr;
}
}
else
{
c->data = nullptr;
}
// 头插
c->handler = nullptr;
c->next = pool->cleanup;
pool->cleanup = c;
return c;
}
测试
#include "ngx_mem_pool.h"
#include <stdio.h>
#include <stdlib.h>
typedef struct Data stData;
struct Data
{
char* ptr;
FILE* pfile;
};
void func1(void* p)
{
char* pc = (char*)p;
printf("free ptr mem!");
free(p);
}
void func2(void* p)
{
FILE* pf = (FILE*)p;
printf("close file!");
fclose(pf);
}
int main()
{
// 512 - sizeof(ngx_pool_t) - 4095 => max
ngx_mem_pool mempool;
if (mempool.ngx_create_pool(512) == nullptr)
{
printf("ngx_create_pool fail...");
return -1;
}
void* p1 = mempool.ngx_palloc(128); // 从小块内存池分配的
if (p1 == nullptr)
{
printf("ngx_palloc 128 bytes fail...");
return -1;
}
stData* p2 = (stData*)mempool.ngx_palloc(512); // 从大块内存池分配的
if (p2 == nullptr)
{
printf("ngx_palloc 512 bytes fail...");
return -1;
}
p2->ptr = (char *)malloc(12);
strcpy(p2->ptr, "hello world");
p2->pfile = fopen("data.txt", "w");
ngx_pool_cleanup_s* c1 = mempool.ngx_pool_cleanup_add(sizeof(char*));
c1->handler = func1;
c1->data = p2->ptr;
ngx_pool_cleanup_s* c2 = mempool.ngx_pool_cleanup_add(sizeof(FILE*));
c2->handler = func2;
c2->data = p2->pfile;
mempool.ngx_destroy_pool(); // 1.调用所有的预置的清理函数 2.释放大块内存 3.释放小块内存池所有内存
return 0;
}
执行结果
遇到的问题
背景
死循环执行自定义内存清理函数 ngx_pool_cleanup_s::handler
分析：
发现设置的两个清理对象的地址相同
可能是分配对象空间时没有在新位置吗， 猜测可能是ngx_palloc的问题，跟踪之后发现在 ngx_palloc_small函数中内存池起始可用空间设置为p->current
m = (u_char*)p->d.last; // 正确代码
// m = (u_char*)p->current; // 错误的代码
导致了每次分配清理操作对象ngx_pool_cleanup_s内存都在同一个位置开始，产生了覆盖