Nginx内存池源码解析

Nginx是一个高性能、高并发的Web服务器。为了提高其性能和速度，Nginx采用了特殊的内存管理机制，即内存池。

什么是内存池？

内存池是一种高效的内存分配和管理机制。它将一块内存划分成多个大小相等的块，并按需分配给系统。当内存块不再使用时，它并不被立即释放，而是留在内存池中待重复利用。

Nginx内存池结构

Nginx内存池主要由以下结构组成：

• ngx_pool_t：内存池结构体，用于管理内存池中的空闲内存块和已使用的内存块。
• ngx_pool_data_t：内存块结构体，存储内存池中的内存块信息，如大小、位置、指向前后的指针等。

Nginx内存池的使用

Nginx的内存池使用主要分为以下两种情况：

1. 创建内存池

在创建内存池时，会调用ngx_create_pool()函数，并传入创建内存池的大小。该函数返回一个指向ngx_pool_t结构体的指针，即内存池的首地址。

ngx_pool_t *pool;
pool = ngx_create_pool(1024);

2. 分配内存

在需要分配内存时，会调用ngx_palloc()或ngx_pcalloc()函数。两者的区别在于前者不会将内存块初始化为0，而后者会将内存块全部初始化为0。

int *a;
a = ngx_palloc(pool, sizeof(int));
*a = 10;

char *b;
b = ngx_pcalloc(pool, 100);
strcpy(b, "Hello, world");

Nginx内存池源码解析

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->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 = NULL;

    return p;
}

从上述代码中可以看到，ngx_create_pool函数会先调用ngx_memalign函数分配一块长度为size的内存，其中参数NGX_POOL_ALIGNMENT=16表示内存对齐。

初始化结构体ngx_pool_data_t后，将内存池的最大可用大小设为size-ngx_pool_t结构体的大小和NGX_MAX_ALLOC_FROM_POOL中的较小值。

内存池中当前可用大小等于内存池的最大可用大小，初始化时没有被分配任何内存块。

ngx_palloc函数源码

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 = 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);
}

当请求分配size大小的内存时，如果size<=pool->max，则在当前内存块中查找可用内存块，找到则直接返回。

否则，调用ngx_palloc_block函数分配新内存块。

ngx_palloc_block函数源码

static void *ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
    u_char      *m;
    size_t       psize;
    ngx_pool_t  *p, *new;

    psize = (size_t) (pool->d.end - (u_char *) pool);

    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize);
    if (m == NULL) {
        return NULL;
    }

    new = (ngx_pool_t *) m;

    new->d.end = m + psize;
    new->d.next = NULL;
    new->d.failed = 0;

    m += sizeof(ngx_pool_data_t);
    m = ngx_align_ptr(m, NGX_ALIGNMENT);
    new->d.last = m + size;

    p = pool->current;
    while (p->d.next) {
        if (p->d.failed++ > 4) {
            pool->current = p->d.next;
        }
        p = p->d.next;
    }

    p->d.next = new;
    pool->current = new;

    return m;
}

该函数用于在内存池中分配一个新的内存块。首先分配一个大小为size的内存块，初始化成ngx_pool_t结构体，将它加入到内存池中。

示例1

如需分配10个整型变量所需的内存，先创建一个大小为1KB的内存池：

ngx_pool_t *pool;
pool = ngx_create_pool(1024);

然后调用ngx_palloc函数分配内存：

int *a;
a = ngx_palloc(pool, sizeof(int) * 10);
if (a == NULL) {
    ngx_log_error(NGX_LOG_ERR, log, 0, "failed to alloc");
}
else {
    int i;
    for(i = 0; i < 10; i++) {
        a[i] = i;
    }
}

示例2

如需分配一个长度为100的字符串所需的内存，先创建一个大小为1KB的内存池：

ngx_pool_t *pool;
pool = ngx_create_pool(1024);

然后使用ngx_pcalloc函数分配内存，将字符串拷贝到内存块中：

char *str;
str = ngx_pcalloc(pool, 100);
if (str == NULL) {
    ngx_log_error(NGX_LOG_ERR, log, 0, "failed to alloc");
}
else {
    strcpy(str, "hello, world");
    printf("%s\n", str);
}

总结

Nginx内存池是一种高效的内存分配和管理机制，对于高并发的Web服务器尤为重要。本文详细讲解了Nginx内存池的使用和源码实现，采用两个示例说明了内存池的具体使用方式。