diff -ur nginx-1.0.11/src/core/nginx.h nginx-1.0.11-patched/src/core/nginx.h --- nginx-1.0.11/src/core/nginx.h 2011-08-29 17:30:22.000000000 +0800 +++ nginx-1.0.11-patched/src/core/nginx.h 2011-09-13 12:11:03.135622101 +0800 @@ -10,7 +10,7 @@ #define nginx_version 1000011 #define NGINX_VERSION "1.0.11" -#define NGINX_VER "ngx_openresty/" NGINX_VERSION ".unknown" +#define NGINX_VER "ngx_openresty/" NGINX_VERSION ".unknown (no pool)" #define NGINX_VAR "NGINX" diff -ur nginx-1.0.11/src/core/ngx_array.c nginx-1.0.11-patched/src/core/ngx_array.c --- nginx-1.0.11/src/core/ngx_array.c 2008-06-17 23:00:30.000000000 +0800 +++ nginx-1.0.11-patched/src/core/ngx_array.c 2011-09-14 12:02:56.263128538 +0800 @@ -39,13 +39,7 @@ p = a->pool; - if ((u_char *) a->elts + a->size * a->nalloc == p->d.last) { - p->d.last -= a->size * a->nalloc; - } - - if ((u_char *) a + sizeof(ngx_array_t) == p->d.last) { - p->d.last = (u_char *) a; - } + ngx_pfree(p, a); } @@ -64,29 +58,17 @@ p = a->pool; - if ((u_char *) a->elts + size == p->d.last - && p->d.last + a->size <= p->d.end) - { - /* - * the array allocation is the last in the pool - * and there is space for new allocation - */ - - p->d.last += a->size; - a->nalloc++; - - } else { - /* allocate a new array */ - - new = ngx_palloc(p, 2 * size); - if (new == NULL) { - return NULL; - } - - ngx_memcpy(new, a->elts, size); - a->elts = new; - a->nalloc *= 2; + /* allocate a new array */ + + new = ngx_palloc(p, 2 * size); + if (new == NULL) { + return NULL; } + + ngx_memcpy(new, a->elts, size); + a->elts = new; + a->nalloc *= 2; + } elt = (u_char *) a->elts + a->size * a->nelts; @@ -100,43 +82,25 @@ ngx_array_push_n(ngx_array_t *a, ngx_uint_t n) { void *elt, *new; - size_t size; ngx_uint_t nalloc; ngx_pool_t *p; - size = n * a->size; - if (a->nelts + n > a->nalloc) { /* the array is full */ p = a->pool; - if ((u_char *) a->elts + a->size * a->nalloc == p->d.last - && p->d.last + size <= p->d.end) - { - /* - * the array allocation is the last in the pool - * and there is space for new allocation - */ - - p->d.last += size; - a->nalloc += n; - - } else { - /* allocate a new array */ - - nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc); - - new = ngx_palloc(p, nalloc * a->size); - if (new == NULL) { - return NULL; - } - - ngx_memcpy(new, a->elts, a->nelts * a->size); - a->elts = new; - a->nalloc = nalloc; + nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc); + + new = ngx_palloc(p, nalloc * a->size); + if (new == NULL) { + return NULL; } + + ngx_memcpy(new, a->elts, a->nelts * a->size); + a->elts = new; + a->nalloc = nalloc; } elt = (u_char *) a->elts + a->size * a->nelts; diff -ur nginx-1.0.11/src/core/ngx_palloc.c nginx-1.0.11-patched/src/core/ngx_palloc.c --- nginx-1.0.11/src/core/ngx_palloc.c 2009-12-17 20:25:46.000000000 +0800 +++ nginx-1.0.11-patched/src/core/ngx_palloc.c 2011-09-14 12:03:41.663126519 +0800 @@ -8,24 +8,31 @@ #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); ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log) { - ngx_pool_t *p; + ngx_pool_t *p; + ngx_pool_data_t *d; - p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log); + size = sizeof(ngx_pool_t); + p = ngx_alloc(size, log); 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; + d = ngx_alloc(sizeof(ngx_pool_data_t), log); + + if (d == NULL) { + return NULL; + } + + d->next = d; + d->prev = d; + d->alloc = NULL; + p->d = d; size = size - sizeof(ngx_pool_t); p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL; @@ -43,7 +50,7 @@ void ngx_destroy_pool(ngx_pool_t *pool) { - ngx_pool_t *p, *n; + ngx_pool_data_t *d, *n; ngx_pool_large_t *l; ngx_pool_cleanup_t *c; @@ -55,7 +62,7 @@ } } - for (l = pool->large; l; l = l->next) { + for (l = pool->large; l ; l = l->next) { ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc); @@ -71,34 +78,45 @@ * so we can not use this log while the free()ing the pool */ - for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) { + for (d = pool->d, n = d->next; ; d = n, n = n->next) { ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0, - "free: %p, unused: %uz", p, p->d.end - p->d.last); + "free: %p", d); - if (n == NULL) { + if (n == pool->d) { break; } } #endif + if (pool->d->next == pool->d) { + ngx_free(pool->d); + } else { + for (d = pool->d, n = d->next; ; d = n, n = n->next) { + if (d->alloc) { + ngx_free(d->alloc); + } + ngx_free(d); - for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) { - ngx_free(p); - - if (n == NULL) { - break; + if (n == pool->d) { + break; + } } } + + ngx_free(pool); } void ngx_reset_pool(ngx_pool_t *pool) { - ngx_pool_t *p; - ngx_pool_large_t *l; + ngx_pool_data_t *p, *tmp; + ngx_pool_large_t *l; + + for (l = pool->large; l ; l = l->next) { + + ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc); - for (l = pool->large; l; l = l->next) { if (l->alloc) { ngx_free(l->alloc); } @@ -106,109 +124,65 @@ pool->large = NULL; - for (p = pool; p; p = p->d.next) { - p->d.last = (u_char *) p + sizeof(ngx_pool_t); + p = pool->d->next; + while (p != pool->d) { + tmp = p; + ngx_free(p->alloc); + p->prev->next = p->next; + p->next->prev = p->prev; + p = p->next; + ngx_free(tmp); } -} + ngx_free(pool->d->alloc); + pool->d->alloc = NULL; + +} void * -ngx_palloc(ngx_pool_t *pool, size_t size) +ngx_malloc(ngx_pool_t *pool, size_t size) { - u_char *m; - ngx_pool_t *p; - - if (size <= pool->max) { + ngx_pool_data_t *new; + void *m; - p = pool->current; - - do { - m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT); - - if ((size_t) (p->d.end - m) >= size) { - p->d.last = m + size; - - return m; - } - - p = p->d.next; - - } while (p); + m = ngx_alloc(size, pool->log); + if (m == NULL) { + return NULL; + } - return ngx_palloc_block(pool, size); + new = ngx_alloc(sizeof(ngx_pool_data_t), pool->log); + if (new == NULL){ + ngx_free(m); + return NULL; } - return ngx_palloc_large(pool, size); + new->alloc = m; + new->next = pool->d; + new->prev = pool->d->prev; + pool->d->prev->next = new; + pool->d->prev = new; + return m; } - void * -ngx_pnalloc(ngx_pool_t *pool, size_t size) +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); + if (size <= 1024) { + return ngx_malloc(pool, size); } return ngx_palloc_large(pool, size); } -static void * -ngx_palloc_block(ngx_pool_t *pool, size_t size) +void * +ngx_pnalloc(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; - - m += sizeof(ngx_pool_data_t); - m = ngx_align_ptr(m, NGX_ALIGNMENT); - new->d.last = m + size; - - current = pool->current; - - for (p = current; p->d.next; p = p->d.next) { - if (p->d.failed++ > 4) { - current = p->d.next; - } + if (size <= 1024) { + return ngx_malloc(pool, size); } - p->d.next = new; - - pool->current = current ? current : new; - - return m; + return ngx_palloc_large(pool, size); } @@ -216,7 +190,6 @@ 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); @@ -224,20 +197,7 @@ 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)); + large = ngx_malloc(pool, sizeof(ngx_pool_large_t)); if (large == NULL) { ngx_free(p); return NULL; @@ -262,7 +222,7 @@ return NULL; } - large = ngx_palloc(pool, sizeof(ngx_pool_large_t)); + large = ngx_malloc(pool, sizeof(ngx_pool_large_t)); if (large == NULL) { ngx_free(p); return NULL; @@ -279,17 +239,41 @@ ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p) { - ngx_pool_large_t *l; + ngx_pool_large_t *l; + ngx_pool_large_t *ll; + ngx_pool_data_t *d, *n; - for (l = pool->large; l; l = l->next) { + for (l = pool->large, ll = l; l; ll = 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; + if (l == pool->large) { + pool->large = NULL; + } + + ll->next = l->next; + p = l; + break; + } + } + for (d = pool->d, n = d->next; ; d = n, n = d->next) { + if (p == d->alloc) { + ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", d->alloc); + if (d->alloc) { + ngx_free(d->alloc); + } + d->alloc = NULL; + d->prev->next = d->next; + d->next->prev = d->prev; + ngx_free(d); return NGX_OK; } + if (d->next == pool->d) { + break; + } } return NGX_DECLINED; diff -ur nginx-1.0.11/src/core/ngx_palloc.h nginx-1.0.11-patched/src/core/ngx_palloc.h --- nginx-1.0.11/src/core/ngx_palloc.h 2009-12-17 20:25:46.000000000 +0800 +++ nginx-1.0.11-patched/src/core/ngx_palloc.h 2011-09-13 12:11:03.155622101 +0800 @@ -38,6 +38,7 @@ typedef struct ngx_pool_large_s ngx_pool_large_t; +typedef struct ngx_pool_data_s ngx_pool_data_t; struct ngx_pool_large_s { ngx_pool_large_t *next; @@ -45,16 +46,15 @@ }; -typedef struct { - u_char *last; - u_char *end; - ngx_pool_t *next; - ngx_uint_t failed; -} ngx_pool_data_t; +struct ngx_pool_data_s{ + ngx_pool_data_t *next; + ngx_pool_data_t *prev; + void *alloc; +}; struct ngx_pool_s { - ngx_pool_data_t d; + ngx_pool_data_t *d; size_t max; ngx_pool_t *current; ngx_chain_t *chain;