ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log){//size_t 它是一个unsigned整型,足以保证存储在内存中对象的大小,本方法用来生成一个空的内存对象ngx_pool_t
ngx_pool_t * p;
p = ngx_alloc(size, log);
if(p == NULL){
return NULL;
}
p->d.last = (u_char *)p + sizeof(ngx_pool_t);//ngx_pool_t结构有一个ngx_pool_data_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;
}
void ngx_destroy_pool(ngx_pool_t *pool){//销毁内存池
ngx_pool_t *p, *n;
ngx_pool_cleanup_t *c;
ngx_pool_large_t *l;
for(c = pool->cleanup; c; c=c->next){
if(c->handler){
c->handler(c->data);
}
}
for(l = pool->large; l ; l = l->next){
if(l->alloc)
ngx_free(l->alloc);
}
#if (NGX_DEBUG)
for(p = pool, n = pool->d.next; ; p = n, n = n->d.next){
if(n == NULL){
break;
}
}
#endif
for(p = pool, n = pool->d.next; ; 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;
for(p = pool; p; p = p->d.next){
p->d.last = (u_char *)p + sizeof(ngx_pool_t);
}
}
void *ngx_palloc(ngx_pool_t *pool, size_t size){//从内存池pool中分配size大小的内存空间,前将内存对齐
ngx_pool_t *p;
u_char *m;
if(size <= pool->max){//是否是小内存
p = pool->current;
do{
m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);//内存对齐
if((size_t)(p->d.end-m) >= size){
d->d.last = m+size;
return m;
}
p = p->d.next;//如果当前内存池不行,则移向下一个内存池
}while(p);
return ngx_palloc_block(pool, size);//pool链表已用完,还没分配好,则给pool链表申请内存
}
return ngx_palloc_large(pool, size);//分配大内存
}
void *ngx_pnalloc(ngx_pool_t *pool, size_t size){//申请一块内存,不对内存对齐
ngx_pool_t *p;
u_char *m;
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.netx;
}while(p);
return ngx_palloc_block(pool, size);//分配大内存
}
return ngx_palloc_large(pool, size);//分配大内存
}
static void *ngx_palloc_block(ngx_pool_t *pool, size_t size){//为pool申请一块size大小的内存
u_char *m
size_t psize;
ngx_pool_t *new, *current, *p;
psize = (size_t)(pool->d.end - (u_char *)pool);//计算pool所占的内存
m = ngx_alloc(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;
m += sizeof(ngx_pool_data_t);//待使用的指针地址
m = ngx_align_ptr(m, NGX_ALIGNMENT);
new->d.last = m+size;//先分配size内存
current = pool->current;
for(p = current; p->d.netx; p = p->d.next){//如果一个内存池链表项多次因分配内存失败,则将当前内存池指针向下移动
if(p->d.failed++ >4){
current = p->d.next;
}
}
p->d.next = new;
pool->current = current ? current : new;
return m;
}
static void *ngx_palloc_large(ngx_pool_t *pool, size_t size){//分配一块大内存地址,size
void *p;
ngx_int_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(pool, sizeof(ngx_pool_large_t) );
if(large == NULL){
return NULL;
}
large->alloc = p;//向链表加入一个元素
large->next = pool->large;
pool->large = large;
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, pool->log);
if(p == NULL){
return NULL;
}
large = ngx_palloc(pool, sizeof(ngx_pool_large_t));
large->alloc = p;
large->next = pool->large;
pool->large = large;
return p;
}
ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p){//把大内存地址 == p的大内存清理掉
ngx_pool_large_t *l;
for(l == pool->large;l ; l = l->next){
if(l->alloc == p){
ngx_free(l->alloc);
l->alloc = NULL;
return NGX_OK;
}
}
return NGX_DECLIEND;
}
void *ngx_pcalloc(ngx_pool_t *pool, size_t size){//从pool里分配一个size的内存并清0
void *p;
p = ngx_palloc(pool, size);
if(p){
p = ngx_memzero(p, size);
}
return p;
}
ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size){//为内存池p新加一个cleanup对象
ngx_pool_cleanup_t *c;
c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
if(c == NULL){
return NULL;
}
if(size){
c->data = ngx_palloc(p, size);
if(c->data == NULL){
return NULL;
}
}else{
c->data = NULL;
}
c->handler = NULL;//
c->next = p->cleanup;//加链表
p->cleanup = c;
return c;
}
void ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd){//如标题,在pool内存池里执行ngx_pool_cleanup_file方法
ngx_pool_cleanup_file_t *cf;
ngx_pool_cleanup_t *c;
for(c=p->cleanup; c; c=c->next){
if(c->handler == ngx_pool_cleanup_file){//c->handler需要满足要求
cf = c->data;
if(cf->fd == fd){//c-data数据也要满足要求
c->handler(cf);
c->handler = NULL;
return;
}
}
}
}
void ngx_pool_cleanup_file(void *data){//其实就是关闭文件句柄
ngx_pool_cleanup_file_t *c = data;
ngx_close_file(c->fd);
}
void ngx_pool_delete_file(void *data){
ngx_pool_cleanup_file_t *c = data;
ngx_delete_file(c->name);
ngx_close_file(c->fd);
}
#if 0//以下待注释,因为cycle还没看
static void *
ngx_get_cached_block(size_t size)
{
void *p;
ngx_cached_block_slot_t *slot;
if (ngx_cycle->cache == NULL) {
return NULL;
}
slot = &ngx_cycle->cache[(size + ngx_pagesize - 1) / ngx_pagesize];
slot->tries++;
if (slot->number) {
p = slot->block;
slot->block = slot->block->next;
slot->number--;
return p;
}
return NULL;
}
#endif
默写nginx并逐句分析 - ngx_palloc.c(部分待分析)
最新推荐文章于 2023-05-17 14:25:11 发布