diff -ur nginx-1.0.5/src/core/nginx.h nginx-1.0.5-no-pool/src/core/nginx.h
--- nginx-1.0.5/src/core/nginx.h	2011-05-26 15:31:40.000000000 +0800
+++ nginx-1.0.5-no-pool/src/core/nginx.h	2011-06-30 17:00:43.540946999 +0800
@@ -10,7 +10,7 @@
 
 #define nginx_version      1000004
 #define NGINX_VERSION      "1.0.5"
-#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
+#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown (no pool)"
 
 #define NGINX_VAR          "NGINX"
 #define NGX_OLDPID_EXT     ".oldbin"
diff -ur nginx-1.0.5/src/core/ngx_array.c nginx-1.0.5-no-pool/src/core/ngx_array.c
--- nginx-1.0.5/src/core/ngx_array.c	2008-06-17 23:00:30.000000000 +0800
+++ nginx-1.0.5-no-pool/src/core/ngx_array.c	2011-06-30 17:00:43.540946999 +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;
@@ -112,31 +94,16 @@
 
         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.5/src/core/ngx_palloc.c nginx-1.0.5-no-pool/src/core/ngx_palloc.c
--- nginx-1.0.5/src/core/ngx_palloc.c	2009-12-17 20:25:46.000000000 +0800
+++ nginx-1.0.5-no-pool/src/core/ngx_palloc.c	2011-06-30 17:06:36.060946999 +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;
+    if (size <= 1024) {
+        return ngx_malloc(pool, size);
     }
 
-    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;
-        }
-    }
-
-    p->d.next = new;
-
-    pool->current = current ? current : new;
-
-    return m;
+    return ngx_palloc_large(pool, size);
 }
 
 
@@ -226,18 +200,7 @@
 
     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 +225,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 +242,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;
Only in nginx-1.0.5-no-pool/src/core: ngx_palloc.c~
diff -ur nginx-1.0.5/src/core/ngx_palloc.h nginx-1.0.5-no-pool/src/core/ngx_palloc.h
--- nginx-1.0.5/src/core/ngx_palloc.h	2009-12-17 20:25:46.000000000 +0800
+++ nginx-1.0.5-no-pool/src/core/ngx_palloc.h	2011-06-30 17:00:43.540946999 +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;
