nginx内存管理

进程内内存管理：内存池

频繁进行malloc、free（向操作系统申请内存、把内存交还给操作系统）会拖慢速度，使用内存池可以批量申请与释放。

内存池结构

struct ngx_pool_s {
    ngx_pool_data_t       d;
    size_t                max;
    ngx_pool_t           *current;
    ngx_chain_t          *chain;
    ngx_pool_large_t     *large;
    ngx_pool_cleanup_t   *cleanup;
    ngx_log_t            *log;
};

typedef struct {
    u_char               *last;
    u_char               *end;
    ngx_pool_t           *next;
    ngx_uint_t            failed;
} ngx_pool_data_t;

struct ngx_pool_large_s {
    ngx_pool_large_t     *next;
    void                 *alloc;
};

单块内存池是一个树型结构，由ngx_pool_t作为根节点，注意其包含一个ngx_pool_data_t d而非*d，自带一个小内存分配区，之后分配的data挂载到小内存分配区链表后，即data的next字段。创建内存池时不创建大内存分配区。

申请内存

申请内存共封装了3个api：

• ngx_palloc：基本的api，申请内存的首地址对齐（首地址是4或8的整数倍），获取后不初始化
• ngx_pcalloc：在palloc的基础上初始化
• ngx_pnalloc：首地址不对齐

void *
ngx_palloc(ngx_pool_t *pool, size_t size){
    if (size <= pool->max) {
        return ngx_palloc_small(pool, size, 1);	//调用palloc small
    }
    return ngx_palloc_large(pool, 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) {
        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;
}

static ngx_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;

      	// align 使…成一直线,校准
      	// 对齐内存
        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);	//空闲空间不够，调用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;

   // pool->d.end - (u_char *) pool为当前ngx_pool_t包含的第一个ngx_pool_data_t的所有空间大小，即分配了一整个ngx_pool_data_t，而非仅仅是size大小的内存。
    psize = (size_t) (pool->d.end - (u_char *) pool);

    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);	//调用memalign分配空间
    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;	// 已分配区指针向后移动size个位置

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

    p->d.next = new;

    return m;
}

#define ngx_memalign(alignment, size, log)  ngx_alloc(size, log)

void *
ngx_alloc(size_t size, ngx_log_t *log)
{
    void  *p;

    p = malloc(size);	//最终由这一行向操作系统要空间
    if (p == NULL) {
        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
                      "malloc(%uz) failed", size);
    }

    ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, log, 0, "malloc: %p:%uz", p, size);

    return p;
}

可以看到分配内存被分化为分配小内存和分配大内存：

• 分配小内存时首先检查pool_t的所有poll_data_t内是否还有空间，如果有直接分配，否则调用palloc_block再申请一块ngx_pool_data_t，然后再分配。
• 分配大内存直接向操作系统申请，并且用于管理这块内存的ngx_pool_large_t所占用的空间是由palloc_small分配的，然后挂在pool_large_t链表后。

释放内存

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

#define ngx_free          free

• 小内存无需手动释放，释放整个内存池时自动释放就可以。
• 大内存释放时先找到要释放的那一块，然后直接调用free还给操作系统

销毁内存池

void
ngx_destroy_pool(ngx_pool_t *pool)
{
    ngx_pool_t          *p, *n;
    ngx_pool_large_t    *l;
    ngx_pool_cleanup_t  *c;

  	// 逐一调用清理函数
    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);
        }
    }

  	// 释放所有large
    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            ngx_free(l->alloc);
        }
    }
		
  	// 释放pool_t、所有pool_data_t
    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
        ngx_free(p);

        if (n == NULL) {
            break;
        }
    }
}

进程间内存管理：共享内存

进程的内存是虚拟内存，由os分配物理内存，并维护映射表，实现虚拟到物理的映射；共享内存是让多个进程的虚拟内存映射到同一块物理内存，因此多个进程都可以读写这块内存，实现进程间通信。使用mmap、munmap申请和释放共享内存。

nginx共享内存由master进程创建，并记录共享内存地址，fork子进程时，子进程继承记录共享内存地址的变量，进而访问共享内存。

共享内存结构

共享内存结构ngx_shm_t:

typedef struct {
    u_char      *addr;
    size_t       size;
    ngx_str_t    name;
    ngx_log_t   *log;
    ngx_uint_t   exists;   /* unsigned  exists:1;  */
} ngx_shm_t;

共享内存创建、销毁

ngx_int_t ngx_shm_alloc(ngx_shm_t *shm);	// 创建
void ngx_shm_free(ngx_shm_t *shm);				// 销毁

根据操作系统支持情况不同，采用不同方法（mmap或shmget)创建。linux支持的mmap：

ngx_int_t
ngx_shm_alloc(ngx_shm_t *shm)
{
    shm->addr = (u_char *) mmap(NULL, shm->size,
                                PROT_READ|PROT_WRITE,
                                MAP_ANON|MAP_SHARED, -1, 0);

    if (shm->addr == MAP_FAILED) {
        ngx_log_error(NGX_LOG_ALERT, shm->log, ngx_errno,
                      "mmap(MAP_ANON|MAP_SHARED, %uz) failed", shm->size);
        return NGX_ERROR;
    }

    return NGX_OK;
}

void
ngx_shm_free(ngx_shm_t *shm)
{
    if (munmap((void *) shm->addr, shm->size) == -1) {
        ngx_log_error(NGX_LOG_ALERT, shm->log, ngx_errno,
                      "munmap(%p, %uz) failed", shm->addr, shm->size);
    }
}

互斥锁

共享内存通过原子变量标识一个锁，每个进程须先获取到锁才能访问其中的共享变量。每个进程内有一个ngx_shmtx_t结构体进行加锁、释放锁等操作。

• 共享内存锁变量：存储在共享内存块中

typedef struct {
    ngx_atomic_t   lock;
} ngx_shmtx_sh_t;

• 进程锁变量

typedef struct {
    ngx_atomic_t  *lock;	// 指向共享内存锁变量的lock字段
    ngx_uint_t     spin;	// 控制自旋次数
} ngx_shmtx_t;

• 一些锁操作api

ngx_int_t ngx_shmtx_create(ngx_shmtx_t *mtx, ngx_shmtx_sh_t *addr, u_char *name);

void ngx_shmtx_destroy(ngx_shmtx_t *mtx);

ngx_uint_t ngx_shmtx_trylock(ngx_shmtx_t *mtx);

void ngx_shmtx_lock(ngx_shmtx_t *mtx);

void ngx_shmtx_unlock(ngx_shmtx_t *mtx);

ngx_uint_t ngx_shmtx_force_unlock(ngx_shmtx_t *mtx, ngx_pid_t pid);

共享内存池

通过共享内存池可以高效申请和释放共享内存。

• 每块共享内存有一个共享内存池，管理整个共享内存池的结构体是ngx_slab_pool_t，位于共享内存块头部：

typedef struct {
    ngx_shmtx_sh_t    lock;

    size_t            min_size;
    size_t            min_shift;

    ngx_slab_page_t  *pages;
    ngx_slab_page_t  *last;
    ngx_slab_page_t   free;

    ngx_slab_stat_t  *stats;
    ngx_uint_t        pfree;

    u_char           *start;
    u_char           *end;

    ngx_shmtx_t       mutex;

    u_char           *log_ctx;
    u_char            zero;

    unsigned          log_nomem:1;

    void             *data;
    void             *addr;
} ngx_slab_pool_t;

• ngx_slab_page_t用于管理内存页，有9种规格

struct ngx_slab_page_s {
    uintptr_t         slab;
    ngx_slab_page_t  *next;
    uintptr_t         prev;
};

• ngx_slab_stat_t用于统计信息，也有9种规格，配合page_t统计情况

typedef struct {
    ngx_uint_t        total;
    ngx_uint_t        used;

    ngx_uint_t        reqs;
    ngx_uint_t        fails;
} ngx_slab_stat_t;

共享内存的使用

• 使用ngx_shm_alloc创建共享内存块，自行创建锁、自行管理，无需创建池

主要用于简单场景如计数。

• 使用ngx_shared_memory_add创建共享内存块，使用ngx_slab_pool_t管理共享内存

struct ngx_shm_zone_s {
    void                     *data;
    ngx_shm_t                 shm;		// 记录共享内存块的相关信息
    ngx_shm_zone_init_pt      init;		// 共享内存初始化后的回调
    void                     *tag;
    void                     *sync;
    ngx_uint_t                noreuse;  /* unsigned  noreuse:1; */
};

master进程fork子进程时，子进程继承ngx_cycle_t，这样就获得了shared_memory。

struct ngx_cycle_s {
		...
    ngx_list_t                shared_memory;
	  ...
};