Nginx 内存池刨析

实例源码刨析

#define BLOCK_SIZE  16   //每次分配内存块大小#define MEM_POOL_SIZE (1024 * 4) //内存池每块大小

	int i = 0, k = 0;int use_free = 0;ngx_pagesize = getpagesize();//获取系统的页大小//printf("pagesize: %zu\n",ngx_pagesize);char * ptr = NULL;for(k = 0; k< 1024 * 500; k++){ngx_pool_t * mem_pool = ngx_create_pool(MEM_POOL_SIZE);//创建池for(i = 0; i < 1024 ; i++){ptr = ngx_palloc(mem_pool,BLOCK_SIZE);if(!ptr) fprintf(stderr,"ngx_palloc failed. \n");else {*ptr = '\0';*(ptr + BLOCK_SIZE -1) = '\0';}}ngx_destroy_pool(mem_pool);}

一些函数和宏定义

#define NGX_ALIGNMENT   sizeof(unsigned long)    /* platform word 平台字节长*/
#define ngx_align(d, a)     (((d) + (a - 1)) & ~(a - 1)) /* b对齐为a的倍数*/
#define ngx_align_ptr(p, a)                                                   \(u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))/*用于将指针 p 对齐到指定的对齐字节数 a*/
#define ngx_memzero(buf, n)       (void) memset(buf, 0, n)

ngx_create_pool

创建线程池

ngx_pool_t * ngx_create_pool(size_t size)
{ngx_pool_t  *p;p = ngx_memalign(NGX_POOL_ALIGNMENT, size);if (p == NULL) {return NULL;}//它将 p 指针向后偏移 sizeof(ngx_pool_t) 字节，这样 p->d.last 就指向了内存块中除去 ngx_pool_t 结构体大小后的位置，即可用于分配的起始位置。//将 p 指向的内存块的 last 成员设置为指向当前内存块后面的一段内存的起始地址。//这段内存的大小为 sizeof(ngx_pool_t)，即 ngx_pool_t 结构体的大小。//这样做是为了在这块内存中分配其他数据时，可以从这段内存的末尾开始分配，确保内存块的内存布局是连续的。p->d.last = (u_char *) p + sizeof(ngx_pool_t);//指向这块内存已使用区域的最后部分。//指向未使用区域的尾部p->d.end = (u_char *) p + size;//下一块内存块的地址p->d.next = NULL;//内存分配的失败次数p->d.failed = 0;//这行代码确定了内存池中可用于分配的最大内存大小。为了确保内存分配不会超出预先设定的阈值， size = size - sizeof(ngx_pool_t);p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;// 当前正在使用的数据块的指针p->current = p;//p->chain = NULL;p->large = NULL;//p->cleanup = NULL;//p->log = log;return p;
}

ngx_memalign

void * ngx_memalign(size_t alignment, size_t size)
{void  *p;int    err;err = posix_memalign(&p, alignment, size);//按照指定的对齐要求和大小分配内存块。if (err) {fprintf(stderr,"posix_memalign(%zu, %zu) failed", alignment, size);p = NULL;}if(debug) fprintf(stderr,"posix_memalign: %p:%zu @%zu", p, size, alignment);return p;
}

​

ngx_palloc分配内存

void *ngx_palloc(ngx_pool_t *pool, size_t size)
{//判断是分配内存池的内存还是单独分配一块内存位于大储存块区。
#if !(NGX_DEBUG_PALLOC)if (size <= pool->max) {return ngx_palloc_small(pool, size, 1);}
#endifreturn ngx_palloc_large(pool, size);
}

static inline void *ngx_palloc_small(ngx_pool_t *pool, size_t size, ngx_uint_t align)
{u_char      *m;ngx_pool_t  *p;p = pool->current;do {m = p->d.last;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(pool, size);
}

1. 定义一个指向内存池结构的指针p。
2. 将当前内存池的指针赋值给p。
3. 使用一个do-while循环来遍历内存池链表。
4. 获取当前内存池的最后一个内存块的指针m。
5. 如果align为真，则将m对齐到NGX_ALIGNMENT字节边界。
6. 检查当前内存池中是否有足够的空间来分配size大小的内存块。如果有足够的空间，将内存块的指针m设置为分配内存块的起始地址，并将内存池的最后一个内存块的指针更新为m+size。然后返回m。
7. 如果内存池中没有足够的空间，则将p指向下一个内存池，继续遍历内存池链表。
8. 如果遍历完内存池链表仍然没有找到足够的空间，则调用ngx_palloc_block函数分配一个新的内存块，并将新分配的内存块的指针返回。

ngx_palloc_large

---

static void *ngx_palloc_large(ngx_pool_t *pool, size_t size)
{void              *p;ngx_uint_t         n;ngx_pool_large_t  *large;p = ngx_alloc(size);if (p == NULL) {return NULL;}n = 0;for (large = pool->large; large; large = large->next) {if (large->alloc == NULL) {large->alloc = p;return p;}if (n++ > 3) {break;}}large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);if (large == NULL) {ngx_free(p);return NULL;}large->alloc = p;large->next = pool->large;pool->large = large;return p;
}

1. 首先，尝试使用ngx_alloc函数分配一块大小为size的内存。如果分配成功，则将该内存块的指针赋值给p。
2. 然后，遍历内存池中的large链表，查找一个alloc字段为NULL的节点。如果找到，则将分配的内存块的指针赋值给该节点的alloc字段，并返回该内存块的指针。
3. 如果遍历了large链表3次仍然没有找到合适的节点，则跳出循环。
4. 分配一个新的ngx_pool_large_t结构体，将其alloc字段赋值为分配的内存块的指针，并将该结构体添加到内存池的large链表中。
5. 返回分配的内存块的指针。

函数ngx_palloc_large的用途是在Nginx的内存池中分配大块内存。在Nginx中，大块内存通常用于存储文件句柄、连接池等。

注意事项：

1. 在使用ngx_palloc_large分配内存后，需要确保在适当的时候释放内存，以避免内存泄漏。
2. 在使用ngx_palloc_large分配内存时，如果内存池中的large链表已经很长，可能会导致内存分配效率降低。因此，在分配大块内存时，可以考虑使用其他内存分配机制，如ngx_palloc函数。

---

void * ngx_alloc(size_t size)
{void  *p;p = malloc(size);if (p == NULL) {fprintf(stderr,"malloc(%zu) failed", size);}if(debug) fprintf(stderr, "malloc: %p:%zu", p, size);return p;
}

---

void *ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)
{void              *p;ngx_pool_large_t  *large;p = ngx_memalign(alignment, size);if (p == NULL) {return NULL;}large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);if (large == NULL) {ngx_free(p);return NULL;}large->alloc = p;large->next = pool->large;pool->large = large;return p;
}

1. 使用ngx_memalign函数尝试分配一块大小为size且对齐为alignment的内存。如果分配失败，直接返回NULL。
2. 使用ngx_palloc_small函数在内存池中分配一个ngx_pool_large_t结构体的空间，用于存储分配的内存块信息。如果分配失败，释放之前分配的内存，并返回NULL。
3. 将分配的内存块的指针存入ngx_pool_large_t结构体的alloc字段，并将该结构体添加到内存池的large链表中。
4. 返回分配的内存块的指针。

---

void * ngx_pcalloc(ngx_pool_t *pool, size_t size)
{void *p;p = ngx_palloc(pool, size);if (p) {ngx_memzero(p, size);}return p;
}

1. 首先，通过ngx_palloc函数尝试在内存池中分配一块大小为size的内存。如果分配成功，则将返回的指针赋值给p。
2. 如果p不为空，使用ngx_memzero函数将p指向的内存块初始化为全零。ngx_memzero函数的作用是将一块内存块的所有字节设置为零，这在初始化内存时非常有用，可以确保内存中的所有字节都被初始化为零，从而避免未初始化的内存导致的错误。
3. 最后，返回p，即分配的内存块的指针。