nginx源码分析--内存池
内存池是nginx很重要的数据结构，结构图大概如下。
ngx_palloc.h
/*
* Copyright (C) Igor Sysoev
* Copyright (C) Nginx, Inc.
*/
#ifndef _NGX_PALLOC_H_INCLUDED_
#define _NGX_PALLOC_H_INCLUDED_
#include ngx_palloc.c
/*
* Copyright (C) Igor Sysoev
* Copyright (C) Nginx, Inc.
*/
#include <ngx_config.h>
#include <ngx_core.h>
static void *ngx_palloc_block(ngx_pool_t *pool, size_t size);
static void *ngx_palloc_large(ngx_pool_t *pool, size_t size);
/*
创建一个内存池
@param size 内存池大小
@param log 对应的日志结构体指针
@return p 内存池的首地址
*/
ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log)
{
ngx_pool_t *p;
// 内存对齐，提高cpu取数据时的性能
p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
if (p == NULL) {
return NULL;
}
// 内存池已经分配的内存末地址，也是可分配内存的首地址，前面需要存储内存池元数据的结构体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);
// 小于max的内存在ngx_pool_data_t管理的内存块分配，大于max的内存在ngx_pool_large_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;
}
/*
销毁内存池函数
*/
void ngx_destroy_pool(ngx_pool_t *pool)
{
ngx_pool_t *p, *n;
ngx_pool_large_t *l;
ngx_pool_cleanup_t *c;
// 销毁内存池之前逐个调用cleanup链表的节点中的handler函数，并且以data作为参数，见ngx_pool_cleanup_s结构体
for (c = pool->cleanup; c; c = c->next) {
if (c->handler) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
"run cleanup: %p", c);
c->handler(c->data);
}
}
// 释放全部大块内存
for (l = pool->large; l; l = l->next) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc);
if (l->alloc) {
ngx_free(l->alloc);
}
}
// 调试时用
#if (NGX_DEBUG)
/*
* we could allocate the pool->log from this pool
* so we cannot use this log while free()ing the pool
*/
for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
"free: %p, unused: %uz", p, p->d.end - p->d.last);
// 到链表结尾，结束循环
if (n == NULL) {
break;
}
}
#endif
// 释放全部小块内存
for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
ngx_free(p);
if (n == NULL) {
break;
}
}
}
/*
重置内存池状态
*/
void ngx_reset_pool(ngx_pool_t *pool)
{
ngx_pool_t *p;
ngx_pool_large_t *l;
// 释放全部大块内存
for (l = pool->large; l; l = l->next) {
if (l->alloc) {
ngx_free(l->alloc);
}
}
// 把管理大块内存的结构体指针置空
pool->large = NULL;
// 把之前分配出去的内存回收回来，主要是修改last的值即可，因为分配内存是通过last的值去完成的
for (p = pool; p; p = p->d.next) {
p->d.last = (u_char *) p + sizeof(ngx_pool_t);
}
}
/*
在内存池上分配内存
@param pool 用来分配内存的内存池
@param size 分配的大小
@return p 返回分配内存成功后的首地址
*/
void * ngx_palloc(ngx_pool_t *pool, size_t size)
{
u_char *m;
ngx_pool_t *p;
// 是否小于等于小内存的阈值
if (size <= pool->max) {
// 指向当前可用于分配内存节点
p = pool->current;
do {
// 内存对齐处理
m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);
/*
该节点上的内存是否能满足所需，也就是所剩内存大小是否大于等于所需的内存size，
是的话把last往后移动size大小即可
*/
if ((size_t) (p->d.end - m) >= size) {
p->d.last = m + size;
return m;
}
// 如果当前节点的内存不足，到下一个节点上去找，直到都不能满足
p = p->d.next;
} while (p);
// 内存池上的可用内存都小于size大小，分配一块新的内存，并用ngx_pool_s结构管理，然后追加到ngx_pool_data_t链表中
return ngx_palloc_block(pool, size);
}
// 如果所需的内存是大块内存，就在大块内存中分配
return ngx_palloc_large(pool, size);
}
// 不做对齐处理，参考上面的ngx_palloc函数
void * ngx_pnalloc(ngx_pool_t *pool, size_t size)
{
u_char *m;
ngx_pool_t *p;
if (size <= pool->max) {
p = pool->current;
do {
m = p->d.last;
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);
}
return ngx_palloc_large(pool, size);
}
/*
重新分配一块内存，并由ngx_pool_t结构体管理，
然后链到ngx_pool_t结构体链表中，最后在该内存中分配size大小的内存
@return 返回分配了size大小的内存后，分配出去的内存的首地址
*/
static void * ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
u_char *m;
size_t psize;
ngx_pool_t *p, *new, *current;
// 分配一块和之前节点内存大小一样的内存，这个值是创建内存池时就决定了
psize = (size_t) (pool->d.end - (u_char *) pool);
m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
if (m == NULL) {
return NULL;
}
new = (ngx_pool_t *) m;
// 初始化相关数据
new->d.end = m + psize;
new->d.next = NULL;
new->d.failed = 0;
// 可用内存等于end-ngx_pool_data_t结构体的大小，ngx_pool_data_t是描述这块内存的元数据
m += sizeof(ngx_pool_data_t);
m = ngx_align_ptr(m, NGX_ALIGNMENT);
// 分配size大小的内存出去，并修改last指针
new->d.last = m + size;
current = pool->current;
/*
这里把cuurent指针指向最后一个分配内存失败次数大于4的节点的后面一个节点。这里认为，
分配失败次数大于4的内存块，以后分配失败的概率也更大，所以这里做了优化。
修改current指针，该指针是分配内存时，查找的起点。这样会优化查找的性能，
因为这是新开辟的内存，大部分情况下可以满足后面的内存分配，提高查找速度。
但是之所以会新开辟新的一块内存，并不是说之前节点上的内存就被分配完了，
可能只是不能满足这次的内存分配而已，比如前面节点还有1M，但是这次需要2M的内存，那么
就需要创建一个新的内存节点完成分配，那么下次需要分配1M内存的时候，也会从新开辟的节
点上去找，而不会再去旧节点上查找，这样就会导致那块内存的浪费。这里是空间换时间。
*/
for (p = current; p->d.next; p = p->d.next) {
if (p->d.failed++ > 4) {
current = p->d.next;
}
}
// 把新开辟的内存追加到原来的ngx_pool_data_t链表上
p->d.next = new;
pool->current = current ? current : new;
return m;
}
/*
分配大块内存，不做对齐处理
@return 返回size大小的内存的首地址
*/
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, pool->log);
if (p == NULL) {
return NULL;
}
n = 0;
for (large = pool->large; large; large = large->next) {
// 找到一个alloc为空的ngx_pool_large_s结构体，然后把p对应的内存给他管理
if (large->alloc == NULL) {
large->alloc = p;
return p;
}
// 查找三次后都没有找到，则新建一个ngx_pool_large_s结构体来对p对应的内存进行管理
if (n++ > 3) {
break;
}
}
// 申请一个ngx_pool_large_s结构体大小的内存
large = ngx_palloc(pool, sizeof(ngx_pool_large_t));
if (large == NULL) {
// 申请失败的话要把p对应的内存释放掉
ngx_free(p);
return NULL;
}
// 头插法 把larger结构体查到最前面
large->alloc = p;
large->next = pool->large;
pool->large = large;
return p;
}
/*
分配大块内存，做对齐处理，直接插入到ngx_pool_large_t链表中
@return 返回size大小的内存的首地址
*/
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, pool->log);
if (p == NULL) {
return NULL;
}
large = ngx_palloc(pool, sizeof(ngx_pool_large_t));
if (large == NULL) {
ngx_free(p);
return NULL;
}
large->alloc = p;
large->next = pool->large;
pool->large = large;
return p;
}
/*
释放全部大块内存，把alloc指针置空
*/
ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p)
{
ngx_pool_large_t *l;
for (l = pool->large; l; l = l->next) {
if (p == l->alloc) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
"free: %p", l->alloc);
ngx_free(l->alloc);
l->alloc = NULL;
return NGX_OK;
}
}
return NGX_DECLINED;
}
/*
分配size大小的内存，并且用0初始化
*/
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;
}
/*
分配一个ngx_pool_cleanup_t结构体和size大小的空间，然后在ngx_pool_cleanup_t链用头插法插入该节点
@return 返回ngx_pool_cleanup_t节点指针
*/
ngx_pool_cleanup_t * ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
{
ngx_pool_cleanup_t *c;
// 分配一个ngx_pool_cleanup_t结构体空间
c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
if (c == NULL) {
return NULL;
}
// 如果有size则分配size大小的空间供存储数据，否则把data指针置空
if (size) {
c->data = ngx_palloc(p, size);
if (c->data == NULL) {
return NULL;
}
} else {
c->data = NULL;
}
// 初始化handler
c->handler = NULL;
/*
用头插法插入该节点，因为释放内存池时会逐个调用ngx_pool_cleanup_t节点，而ngx_pool_cleanup_t节点
的位置是无关紧要的，所以这里用头插法插入该节点，提高性能，没必要查到链表最后。
*/
c->next = p->cleanup;
p->cleanup = c;
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, p->log, 0, "add cleanup: %p", c);
return c;
}
/*
关闭某个fd对应的文件
@param fd 文件描述符相关的
*/
void ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd)
{
ngx_pool_cleanup_t *c;
ngx_pool_cleanup_file_t *cf;
// 遍历ngx_pool_cleanup_t链表，找到handler等于ngx_pool_cleanup_file函数并且data中的fd等于传入的fd的节点。然后执行handler
for (c = p->cleanup; c; c = c->next) {
if (c->handler == ngx_pool_cleanup_file) {
cf = c->data;
if (cf->fd == fd) {
c->handler(cf);
c->handler = NULL;
return;
}
}
}
}
/*
关闭某个文件
*/
void ngx_pool_cleanup_file(void *data)
{
ngx_pool_cleanup_file_t *c = data;
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, c->log, 0, "file cleanup: fd:%d",
c->fd);
if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
ngx_close_file_n " \"%s\" failed", c->name);
}
}
/*
删除和关闭某个文件
*/
void ngx_pool_delete_file(void *data)
{
ngx_pool_cleanup_file_t *c = data;
ngx_err_t err;
ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, c->log, 0, "file cleanup: fd:%d %s",
c->fd, c->name);
if (ngx_delete_file(c->name) == NGX_FILE_ERROR) {
err = ngx_errno;
if (err != NGX_ENOENT) {
ngx_log_error(NGX_LOG_CRIT, c->log, err,
ngx_delete_file_n " \"%s\" failed", c->name);
}
}
if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
ngx_close_file_n " \"%s\" failed", c->name);
}
}