Nginx Slab内存管理
Slab 内存管理的核心思想是将内存分成多个大小固定的块（称为 "slab"），采用 Best Fit 思想分配给需要内存的对象。这种方式不同于传统的内存管理方法（如直接从操作系统请求内存），Slab 会预先分配一定数量的内存，并根据需要在这些内存块中分配。
一、 操作 slab 共享内存的方法
//初始化新创建的内存
void ngx_slab_init(ngx_slab_pool_t *pool)
//加锁保护的内存分配方式
void *ngx_slab_alloc(ngx_slab_pool_t *pool, size_t size)
//不加锁保护的内存分配方式
void *ngx_slab_alloc_locked(ngx_slab_pool_t *pool, size_t size)
//分配空闲页
static ngx_slab_page_t *ngx_slab_alloc_pages(ngx_slab_pool_t *pool, ngx_unit_t pages)
//加锁分配内存后初始化为 0
void *ngx_slab_calloc(ngx_slab_pool_t *pool, size_t size)
//同上，区别为不加锁
void *ngx_slab_calloc_locked(ngx_slab_pool_t *pool, size_t size)
//加锁保护的内存释放方法
void ngx_slab_free(ngx_slab_pool_t *pool, void *p)
//不加锁保护的内存释放方法
void ngx_slab_free_locked(ngx_slab_pool_t *pool, void *p)
//将空闲页追加到 free 指针后
void ngx_slab_free_pages(ngx_slab_pool_t *pool, ngx_slab_page_t *page, ngx_uint_t pages)
typedef struct {
ngx_shmtx_sh_t lock; //为下面的互斥锁mutex服务，使用原子锁来实现的Nginx互斥锁需要用到本变量；
size_t min_size;//设定的最小内存块的大小
size_t min_shift;//min_size的对应的位偏移
ngx_slab_page_t *pages;//每一页对应一个ngx_slab_page_t，所有的 ngx_slab_page_t 存放在连续的内存中组成数组，pages 就是数组首地址
ngx_slab_page_t *last;//上述描述数组的最后一个元素的下一个元素，即下一个数组元素的首地址
ngx_slab_page_t free;// 空闲的ngx_slab_page_t链表的头结点
ngx_slab_stat_t *stats;
ngx_uint_t pfree;
u_char *start;//所有的实际页面全部连续地放在一起，start 指向这个连续的内存的首地址
u_char *end;// 指向这个连续的内存的尾地址
ngx_shmtx_t mutex;// 互斥锁
u_char *log_ctx;//操作失败时会记录日志，为区别是哪个slab共享内存出错，可以在slab中分配一段内存存放描述的字符串，然后再用log_ctx指向这个字符串；
u_char zero;//实际就是‘\0’，当log_ctx没有赋值时，将直接指向zero，表示空字符串防止出错；
unsigned log_nomem:1;
void *data;//由各个使用slab的模块自由使用，slab管理内存时不会用到它
void *addr;//指向所属的ngx_shm_zone_t里的ngx_shm_t成员的addr成员，一般用于指示一段共享内存块的起始位置
} ngx_slab_pool_t;
struct ngx_slab_page_s {
uintptr_t slab;//多用途，
ngx_slab_page_t *next;//指向双向链表的下一个
uintptr_t prev;//多用途，同时用于指向双向链表的上一页
};
各元素解释：
| ngx_slab_page_t | |||
|---|---|---|---|
| slab | next | prev | |
| 小块内存，小于ngx_slab_exact_size(ngx_pagesize / (8 * sizeof(uintptr_t))) | 表示该页面上存放的等长内存块大小，用位偏移的方式进行表示 | 指向双向链表的下一个元素，如果不存在，为0 | 低两位位 11，如果当前页面内存块使用完，则以NGX_SLAB_SMALL表示当前页面存放的是小块内存，且已经用完，从半满页链表脱离 |
| 中等内存，等于 ngx_slab_exact_size | 作为 bitmap 表示页上的内存块是否已被使用 | 同上 | 低两位为 10，如果当前页面内存块使用完，以 NGX_SLAB_EXACT表示当前页面存放的是中等大小的内存，且已经用完，从半满页链表脱离 |
| 大块内存，大于ngx_slab_exact_size，小于 ngx_slab_max_size | 高 TDC_STORAGE_MAP_MASK位标识 bitmap，低TDC_STORAGE_SHIFT_MASK位表示存放的内存块大小 | 同上 | 低两位为 01，以 NGX_SLAB_BIG表示当前页面存放的是大块内存，且已经用完，从半满页链表脱离 |
| 超大内存，大于等于 ngx_slab_max_size | 超大内存会使用一页或多页，这些页都在一起使用。对于这些页面中的第一页，slab 的前三位会被设置为ngx_slab_page_start,其余位表示紧随其后紧邻的同批页面数；后面没有的话设置为SLAB_PAGE_BUSY | 同上 | 低两位为00,以 NGX_SLAB_PAGE表示当前页面以整页表示，且已经用完，从半满页链表脱离 |
ngx_slab_exact_size = ngx_pagesize / (8 * sizeof(uintptr_t))：slab成员类型为uintptr_t，他有 sizeof(uintptr_t)个字节，每个字节有 8 位，那么按顺序 slab 就能表示 8*sizeof(uintptr_t)个内存块，则ngx_slab_exact_size便是 slab 恰好能以 bitmap 的方式指明页面中所有内存块的使用状态。
ngx_slab_max_size = ngx_pagesize / 2，即 2048KB。
二、 分配内存流程
2.1 共享内存初始化
void ngx_slab_init(ngx_slab_pool_t *pool)
{
u_char *p;
size_t size;
ngx_int_t m;
ngx_uint_t i, n, pages;
ngx_slab_page_t *slots, *page;
// 8
pool->min_size = (size_t)1 << pool->min_shift;
/* ngx_slab_slots 宏实际是将 (pool) + sizeof(ngx_slab_pool_t) 后的起始地址
* 赋给 slots,管理槽大小 */
slots = ngx_slab_slots(pool);
p = (u_char *)slots;
// 计算此块共享内存中除去 pool (即ngx_slab_pool_t结构体)所占的内存后
// 余下的内存大小
size = pool->end - p;
ngx_slab_junk(p, size);
// n=9
n = ngx_pagesize_shift - pool->min_shift;
// 初始化 slots 数组，大小为 9 * sizeof(ngx_slab_page_t)
for (i = 0; i < n; i++)
{
/* only "next" is used in list head */
slots[i].slab = 0;
slots[i].next = &slots[i];
slots[i].prev = 0;
}
// p 指针向前移动，指向slots数组的末尾
p += n * sizeof(ngx_slab_page_t);
// pool->start 指向 slots 数组的末尾
pool->stats = (ngx_slab_stat_t *)p;
// 将 pool->stats[9] 数组置零
ngx_memzero(pool->stats, n * sizeof(ngx_slab_stat_t));
// p 再次向前移动，指向 pool->stats[9] 数组的尾部
p += n * sizeof(ngx_slab_stat_t);
// 计算余下共享内存的大小，此时，共享内存已经用于三块:
// ngx_slab_pool_t + n * (sizeof(ngx_slab_page_t) + sizeof(ngx_slab_stat_t)
size -= n * (sizeof(ngx_slab_page_t) + sizeof(ngx_slab_stat_t));
// 计算余下的共享内存中可以分成多少个 page(每个 page 为 4096 +
// 额外的 sizeof(ngx_slab_page_t) 大小)
// 由前面知，此时 pages = 2544
pages = (ngx_uint_t)(size / (ngx_pagesize + sizeof(ngx_slab_page_t)));
// 将 pool->pages 指向 pool->stats[9] 数组的尾部
pool->pages = (ngx_slab_page_t *)p;
ngx_memzero(pool->pages, pages * sizeof(ngx_slab_page_t));
page = pool->pages;
/* only "next" is used in list head */
pool->free.slab = 0;
pool->free.next = page;
pool->free.prev = 0;
// pages 的大小为余下共享内存中可以划分的页数
// 每页（大小为 4096 + sizeof(ngx_slab_page_t)）
page->slab = pages;
// pool->free 代表当前空闲的页
page->next = &pool->free;
page->prev = (uintptr_t)&pool->free;
// 指向经过对齐后的新地址起始处
pool->start = ngx_align_ptr(p + pages * sizeof(ngx_slab_page_t),
ngx_pagesize);
m = pages - (pool->end - pool->start) / ngx_pagesize;
if (m > 0)
{
pages -= m;
page->slab = pages;
}
pool->last = pool->pages + pages;
pool->pfree = pages;
pool->log_nomem = 1;
pool->log_ctx = &pool->zero;
pool->zero = '\0';
}
初始化后内存布局如下：
空闲页链表如下：
2.2 内存分配
void *
ngx_slab_alloc(ngx_slab_pool_t *pool, size_t size) // 加锁保护的内存分配方法
{
void *p;
ngx_shmtx_lock(&pool->mutex);
p = ngx_slab_alloc_locked(pool, size);
ngx_shmtx_unlock(&pool->mutex);
return p;
}
void *
ngx_slab_alloc_locked(ngx_slab_pool_t *pool, size_t size) // 不加锁保护的内存分配方法
{
size_t s;
uintptr_t p, m, mask, *bitmap;
ngx_uint_t i, n, slot, shift, map;
ngx_slab_page_t *page, *prev, *slots;
// 1）用户申请内存 size 大于ngx_slab_max_size，直接以页的形式分配空间。
if (size > ngx_slab_max_size)
{
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0,
"slab alloc: %uz", size);
// 2)、3）请求页面
page = ngx_slab_alloc_pages(pool, (size >> ngx_pagesize_shift) + ((size % ngx_pagesize) ? 1 : 0));
if (page)
{
// 计算具体的page的位置
p = ngx_slab_page_addr(pool, page);
}
else
{
p = 0;
}
// 返回
goto done;
}
// 请求的size小于等于2048，可用slot满足请求
// 请求的size大于128
if (size > pool->min_size)
{
shift = 1;
// 6）计算满足 size 字节的内存偏移量 shift
for (s = size - 1; s >>= 1; shift++)
{ /* void */
}
// 7）计算该页划分的 slot 块的大小(该 slot 大小对应的移位值)
slot = shift - pool->min_shift;
}
else
{
// 请求的size小于等于128，从 slot[0]开始分配
shift = pool->min_shift;
slot = 0;
}
// 设置该 slot 的引用计数加1
pool->stats[slot].reqs++;
ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0,
"slab alloc: %uz slot: %ui", size, slot);
// 7）取得分级数组的起始位置
slots = ngx_slab_slots(pool);
// 获取对应的slot的用于取chunk的页
page = slots[slot].next;
// 最开始的时候，即还没有开始分配页时，page->next 等于 page。存在用于切割chunk的页
if (page->next != page)
{
// case 2.1:请求的大小小于可exact切割的chunk大小，即128,需要占用page中前面的chunk来作为chunk使用状况的位图
if (shift < ngx_slab_exact_shift)
{
// 得到bitmap起始存放的位置，即要分配的半满页的实际页面首地址
bitmap = (uintptr_t *)ngx_slab_page_addr(pool, page);
// 计算2^shift大小内存块的对应bitmap的个数
map = (ngx_pagesize >> shift) / (8 * sizeof(uintptr_t));
for (n = 0; n < map; n++)
{
// 8）查找未使用的chunk：通过将bitmap的每一位与0xfffffffffff做比较，快速查找未使用的chunk，一块就行
if (bitmap[n] != NGX_SLAB_BUSY)
{
// 依次检查bitmap的各位，以得到未使用的chunk.
for (m = 1, i = 0; m; m <<= 1, i++)
{
if (bitmap[n] & m)
{
continue;
}
// 10）置使用标记
bitmap[n] |= m;
// 计算找到的chunk的偏移位置。
i = (n * 8 * sizeof(uintptr_t) + i) << shift;
p = (uintptr_t)bitmap + i;
pool->stats[slot].used++;
// 11）当每个bitmap标示的chunk刚好使用完时，都会去检查是否还有chunk未使用
// 若chunk全部使用完，则将当前的page脱离下来。
if (bitmap[n] == NGX_SLAB_BUSY)
{
for (n = n + 1; n < map; n++)
{
if (bitmap[n] != NGX_SLAB_BUSY)
{
goto done;
}
}
prev = ngx_slab_page_prev(page);
prev->next = page->next;
page->next->prev = page->prev;
page->next = NULL;
// 置chunk的类型为small
page->prev = NGX_SLAB_SMALL;
}
goto done;
}
}
}
}
else if (shift == ngx_slab_exact_shift)
{
// 请求的大小刚好为exact的大小，即128,这时slab仅做bitmap使用
// 直接比较slab看有空的chunk不
for (m = 1, i = 0; m; m <<= 1, i++)
{
if (page->slab & m)
{
continue;
}
// 置使用标记
page->slab |= m;
// 当每个bitmap标示的chunk刚好使用完时，都会去检查是否还有chunk未使用
// 若chunk全部使用完，则将当前的page脱离下来。
if (page->slab == NGX_SLAB_BUSY)
{
prev = ngx_slab_page_prev(page);
prev->next = page->next;
page->next->prev = page->prev;
page->next = NULL;
page->prev = NGX_SLAB_EXACT;
}
p = ngx_slab_page_addr(pool, page) + (i << shift);
pool->stats[slot].used++;
goto done;
}
}
else
{ /* shift > ngx_slab_exact_shift */
// case 2.3:申请的size大小128，但小于等于2048时。
// 此时的slab同时存储bitmap及表示chunk大小的shift,高位为bitmap.
// 获取bitmap的高位mask.
mask = ((uintptr_t)1 << (ngx_pagesize >> shift)) - 1;
mask <<= NGX_SLAB_MAP_SHIFT;
// 逐位查找空的chunk.
for (m = (uintptr_t)1 << NGX_SLAB_MAP_SHIFT, i = 0;
m & mask;
m <<= 1, i++)
{
if (page->slab & m)
{
continue;
}
page->slab |= m;
if ((page->slab & NGX_SLAB_MAP_MASK) == mask)
{
prev = ngx_slab_page_prev(page);
prev->next = page->next;
page->next->prev = page->prev;
page->next = NULL;
page->prev = NGX_SLAB_BIG;
}
p = ngx_slab_page_addr(pool, page) + (i << shift);
pool->stats[slot].used++;
goto done;
}
}
ngx_slab_error(pool, NGX_LOG_ALERT, "ngx_slab_alloc(): page is busy");
ngx_debug_point();
}
// 从空闲页链表中申请 1 页
page = ngx_slab_alloc_pages(pool, 1);
// 申请页成功
if (page)
{
// 申请的内存小于 ngx_slab_exact_size 的情况
// 假设按 8 字节划分，则 1 个 4KB 的 page 页将被划分为 512 块,
// 表示各个 slot 块状态的位图也就需要 512 个 bit 位，一个 slab
// 字段明显不足，所以需要为位图另找存储空间，而 slab 字段仅用于
// 存储 slot 块大小（仅存其对应的移位数）.
if (shift < ngx_slab_exact_shift)
{
bitmap = (uintptr_t *)ngx_slab_page_addr(pool, page);
// n 表示多少内存块才能放下 bitmap
n = (ngx_pagesize >> shift) / ((1 << shift) * 8);
if (n == 0)
{
n = 1;
}
// 因为前面内存块需设置为 bitmap，估设置为NGX_SLAB_BUSY
/* "n" elements for bitmap, plus one requested */
for (i = 0; i < (n + 1) / (8 * sizeof(uintptr_t)); i++)
{
bitmap[i] = NGX_SLAB_BUSY;
}
m = ((uintptr_t)1 << ((n + 1) % (8 * sizeof(uintptr_t)))) - 1;
bitmap[i] = m;
map = (ngx_pagesize >> shift) / (8 * sizeof(uintptr_t));
for (i = i + 1; i < map; i++)
{
bitmap[i] = 0;
}
// slab 仅用于存储 slot 块大小（仅存其对应的移位数）
page->slab = shift;
page->next = &slots[slot];
page->prev = (uintptr_t)&slots[slot] | NGX_SLAB_SMALL;
slots[slot].next = page;
pool->stats[slot].total += (ngx_pagesize >> shift) - n;
p = ngx_slab_page_addr(pool, page) + (n << shift);
pool->stats[slot].used++;
goto done;
}
else if (shift == ngx_slab_exact_shift)
{
page->slab = 1;
page->next = &slots[slot];
page->prev = (uintptr_t)&slots[slot] | NGX_SLAB_EXACT;
slots[slot].next = page;
pool->stats[slot].total += 8 * sizeof(uintptr_t);
p = ngx_slab_page_addr(pool, page);
pool->stats[slot].used++;
goto done;
}
else
{ /* shift > ngx_slab_exact_shift */
// 当划分的每个 slot 块比 ngx_slab_exact_size 还大，意味着一个
// 一个 page 页划分的 slot 块数更少，此时同样使用 ngx_slab_page_t
// 结构体的 slab 字段作为位图。由于比 ngx_slab_exact_size 大的
// 划分可以有很多种，因此需要把其具体的大小记录下来，这个值同样
// 记录在 slab 字段里。如下，slab 字段的高端 bit 用作位图，低端
// bit 用于存储 slot 块的大小（仅存其对应的移位数）
page->slab = ((uintptr_t)1 << NGX_SLAB_MAP_SHIFT) | shift;
page->next = &slots[slot];
page->prev = (uintptr_t)&slots[slot] | NGX_SLAB_BIG;
slots[slot].next = page;
pool->stats[slot].total += ngx_pagesize >> shift;
p = ngx_slab_page_addr(pool, page);
pool->stats[slot].used++;
goto done;
}
}
p = 0;
pool->stats[slot].fails++;
done:
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0,
"slab alloc: %p", (void *)p);
return (void *)p;
}
static ngx_slab_page_t *
ngx_slab_alloc_pages(ngx_slab_pool_t *pool, ngx_uint_t pages)
{
ngx_slab_page_t *page, *p;
// 在slab page的管理页中查找，找到slab管理块中能够一次满足要求的slab,这和slab page的管理时不合并有关
for (page = pool->free.next; page != &pool->free; page = page->next)
{
if (page->slab >= pages)
{
if (page->slab > pages)
{
page[page->slab - 1].prev = (uintptr_t)&page[pages];
page[pages].slab = page->slab - pages;
page[pages].next = page->next;
page[pages].prev = page->prev;
p = (ngx_slab_page_t *)page->prev;
p->next = &page[pages];
page->next->prev = (uintptr_t)&page[pages];
}
else
{
p = (ngx_slab_page_t *)page->prev;
p->next = page->next;
page->next->prev = page->prev;
}
page->slab = pages | NGX_SLAB_PAGE_START;
page->next = NULL;
page->prev = NGX_SLAB_PAGE;
pool->pfree -= pages;
if (--pages == 0)
{
return page;
}
for (p = page + 1; pages; pages--)
{
p->slab = NGX_SLAB_PAGE_BUSY;
p->next = NULL;
p->prev = NGX_SLAB_PAGE;
p++;
}
return page;
}
}
if (pool->log_nomem)
{
ngx_slab_error(pool, NGX_LOG_CRIT,
"ngx_slab_alloc() failed: no memory");
}
return NULL;
}
2.3 释放内存流程
void ngx_slab_free(ngx_slab_pool_t *pool, void *p)
{
ngx_shmtx_lock(&pool->mutex);
ngx_slab_free_locked(pool, p);
ngx_shmtx_unlock(&pool->mutex);
}
void ngx_slab_free_locked(ngx_slab_pool_t *pool, void *p) // 不加锁保护的内存释放方法
{
size_t size;
uintptr_t slab, m, *bitmap;
ngx_uint_t i, n, type, slot, shift, map;
ngx_slab_page_t *slots, *page;
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0, "slab free: %p", p);
if ((u_char *)p < pool->start || (u_char *)p > pool->end)
{
ngx_slab_error(pool, NGX_LOG_ALERT, "ngx_slab_free(): outside of pool");
goto fail;
}
// n 为 P 所在页面的序号
n = ((u_char *)p - pool->start) >> ngx_pagesize_shift;
page = &pool->pages[n];
slab = page->slab;
type = ngx_slab_page_type(page);
switch (type)
{
case NGX_SLAB_SMALL:
// 低NGX_SLAB_SHIFT_MASK位存储了位大小
shift = slab & NGX_SLAB_SHIFT_MASK;
size = (size_t)1 << shift;
if ((uintptr_t)p & (size - 1))
{
goto wrong_chunk;
}
// 计算内存块在页面的序号
n = ((uintptr_t)p & (ngx_pagesize - 1)) >> shift;
// m 为 p 所在内存块对应 bitmap 第 bit 位
m = (uintptr_t)1 << (n % (8 * sizeof(uintptr_t)));
// 计算出 p 所在内存块在 bitmap 中的位置
n /= 8 * sizeof(uintptr_t);
// 计算出 p 对应bitmap 所在页面的起始地址
bitmap = (uintptr_t *)((uintptr_t)p & ~((uintptr_t)ngx_pagesize - 1));
// 如果在使用中
if (bitmap[n] & m)
{
slot = shift - pool->min_shift;
if (page->next == NULL)
{
slots = ngx_slab_slots(pool);
page->next = slots[slot].next;
slots[slot].next = page;
page->prev = (uintptr_t)&slots[slot] | NGX_SLAB_SMALL;
page->next->prev = (uintptr_t)page | NGX_SLAB_SMALL;
}
// 置 0
bitmap[n] &= ~m;
// 检查当前页面是否完全没有已使用内存块，如果没有则需要回收该内存块
n = (ngx_pagesize >> shift) / ((1 << shift) * 8);
if (n == 0)
{
n = 1;
}
i = n / (8 * sizeof(uintptr_t));
m = ((uintptr_t)1 << (n % (8 * sizeof(uintptr_t)))) - 1;
if (bitmap[i] & ~m)
{
goto done;
}
map = (ngx_pagesize >> shift) / (8 * sizeof(uintptr_t));
for (i = i + 1; i < map; i++)
{
if (bitmap[i])
{
goto done;
}
}
ngx_slab_free_pages(pool, page, 1);
pool->stats[slot].total -= (ngx_pagesize >> shift) - n;
goto done;
}
goto chunk_already_free;
case NGX_SLAB_EXACT:
m = (uintptr_t)1 << (((uintptr_t)p & (ngx_pagesize - 1)) >> ngx_slab_exact_shift);
size = ngx_slab_exact_size;
if ((uintptr_t)p & (size - 1))
{
goto wrong_chunk;
}
if (slab & m)
{
slot = ngx_slab_exact_shift - pool->min_shift;
if (slab == NGX_SLAB_BUSY)
{
slots = ngx_slab_slots(pool);
page->next = slots[slot].next;
slots[slot].next = page;
page->prev = (uintptr_t)&slots[slot] | NGX_SLAB_EXACT;
page->next->prev = (uintptr_t)page | NGX_SLAB_EXACT;
}
page->slab &= ~m;
if (page->slab)
{
goto done;
}
ngx_slab_free_pages(pool, page, 1);
pool->stats[slot].total -= 8 * sizeof(uintptr_t);
goto done;
}
goto chunk_already_free;
case NGX_SLAB_BIG:
shift = slab & NGX_SLAB_SHIFT_MASK;
size = (size_t)1 << shift;
if ((uintptr_t)p & (size - 1))
{
goto wrong_chunk;
}
m = (uintptr_t)1 << ((((uintptr_t)p & (ngx_pagesize - 1)) >> shift) + NGX_SLAB_MAP_SHIFT);
if (slab & m)
{
slot = shift - pool->min_shift;
if (page->next == NULL)
{
slots = ngx_slab_slots(pool);
page->next = slots[slot].next;
slots[slot].next = page;
page->prev = (uintptr_t)&slots[slot] | NGX_SLAB_BIG;
page->next->prev = (uintptr_t)page | NGX_SLAB_BIG;
}
page->slab &= ~m;
if (page->slab & NGX_SLAB_MAP_MASK)
{
goto done;
}
ngx_slab_free_pages(pool, page, 1);
pool->stats[slot].total -= ngx_pagesize >> shift;
goto done;
}
goto chunk_already_free;
case NGX_SLAB_PAGE:
if ((uintptr_t)p & (ngx_pagesize - 1))
{
goto wrong_chunk;
}
if (!(slab & NGX_SLAB_PAGE_START))
{
ngx_slab_error(pool, NGX_LOG_ALERT,
"ngx_slab_free(): page is already free");
goto fail;
}
if (slab == NGX_SLAB_PAGE_BUSY)
{
ngx_slab_error(pool, NGX_LOG_ALERT,
"ngx_slab_free(): pointer to wrong page");
goto fail;
}
size = slab & ~NGX_SLAB_PAGE_START;
ngx_slab_free_pages(pool, page, size);
ngx_slab_junk(p, size << ngx_pagesize_shift);
return;
}
/* not reached */
return;
done:
pool->stats[slot].used--;
ngx_slab_junk(p, size);
return;
wrong_chunk:
ngx_slab_error(pool, NGX_LOG_ALERT,
"ngx_slab_free(): pointer to wrong chunk");
goto fail;
chunk_already_free:
ngx_slab_error(pool, NGX_LOG_ALERT,
"ngx_slab_free(): chunk is already free");
fail:
return;
}
三、总结
Nginx 的 slab 内存管理是一种内存分配机制，旨在通过减少内存碎片，提高性能，尤其是在高并发的场景下。它的基本思路是将内存分成大小固定的块，然后分配这些块而不是每次都从系统中请求内存。下面是 slab 内存管理的优劣势分析。
优势：
- 减少内存碎片： Slab 分配机制通过将内存划分为大小固定的块，能够减少内存碎片问题。每次申请的内存大小都是预先定义的，从而避免了常见的动态分配（例如
malloc）中的碎片问题，特别是在长时间运行的高并发场景中。 - 高效的内存重用： Slab 分配器会保持一个内存池，当内存块被释放后，它不会立即释放到系统，而是保持在一个自由链表中，等待下次分配。这样，相同大小的内存块可以快速复用，减少了内存申请和释放的开销。
- 避免频繁的系统调用： 由于 Slab 内存池是预先分配的，它减少了操作系统的内存管理压力，并且避免了频繁的内存分配和释放操作，这有助于提升系统的整体性能。
- 快速分配和释放： Slab 分配器通过内部的链表和缓存机制，可以在极短的时间内完成内存分配和释放。Nginx 在处理大量请求时，每次内存分配都非常迅速，极大提升了请求的处理效率。
- 内存池的灵活性： 不同大小的内存池（slab caches）可以根据需要动态调整。对于一些频繁使用的小对象，可以分配较小的 slab；对于大对象，使用更大的 slab。这样可以实现更精细的内存管理。
劣势：
- 内存浪费： 由于每个内存块大小固定，如果应用程序请求的内存大小与 slab 块不完全匹配，可能会导致一定程度的内存浪费。例如，一个请求需要 10 KB 的内存，而 slab 块是 16 KB，那么将有 6 KB 的内存未被使用，造成空间浪费。
- 实现复杂性： Slab 分配机制比一般的内存分配方式更复杂，需要管理多个内存池以及块的分配、回收等操作。Nginx 中的 slab 分配器虽然提供了高效的性能，但它的实现也相对复杂，维护起来较为困难。
- 内存池的最大值限制： 每个 slab 内存池有一个最大容量限制，如果内存池中的块用完且没有及时回收，就可能出现内存分配失败的情况，尤其在高并发、高负载的情况下，需要合理配置内存池大小。
- 不可动态调整块大小： Slab 分配器的内存块大小是静态的，一旦初始化，内存块的大小就不能动态改变。如果应用程序需要更灵活的内存管理，可能会受到 slab 的局限，尤其是在请求的内存大小高度不一致的情况下。
