Using new memory pool implementation.

70 files changed, 345 insertions, 1317 deletions

diff --git a/src/nxt_application.c b/src/nxt_application.c
index a07a9038..f3d014cb 100644
--- a/src/nxt_application.c
+++ b/src/nxt_application.c
@@ -71,7 +71,7 @@ static nxt_buf_t                 *nxt_app_buf_free;
 static nxt_buf_t                 *nxt_app_buf_done;
 
 static nxt_event_engine_t        *nxt_app_engine;
-static nxt_mem_pool_t            *nxt_app_mem_pool;
+static nxt_mp_t                  *nxt_app_mem_pool;
 
 static nxt_uint_t                nxt_app_buf_current_number;
 static nxt_uint_t                nxt_app_buf_max_number = 16;
@@ -167,7 +167,7 @@ nxt_app_thread(void *ctx)
     link = nxt_queue_first(&rt->engines);
     nxt_app_engine = nxt_queue_link_data(link, nxt_event_engine_t, link);
 
-    nxt_app_mem_pool = nxt_mem_pool_create(512);
+    nxt_app_mem_pool = nxt_mp_create(1024, 128, 256, 32);
     if (nxt_slow_path(nxt_app_mem_pool == NULL)) {
         return;
     }
@@ -225,13 +225,13 @@ nxt_app_thread(void *ctx)
 
         if (nxt_app_http_parse_request(r, buf, n) != NXT_OK) {
             nxt_log_debug(thr->log, "nxt_app_http_parse_request() failed");
-            nxt_mem_pool_destroy(r->mem_pool);
+            nxt_mp_destroy(r->mem_pool);
             goto fail;
         }
 
         if (nxt_app_http_process_headers(r) != NXT_OK) {
             nxt_log_debug(thr->log, "nxt_app_http_process_headers() failed");
-            nxt_mem_pool_destroy(r->mem_pool);
+            nxt_mp_destroy(r->mem_pool);
             goto fail;
         }
 
@@ -256,21 +256,21 @@ nxt_app_thread(void *ctx)
 static nxt_app_request_t *
 nxt_app_request_create(nxt_socket_t s, nxt_log_t *log)
 {
+    nxt_mp_t           *mp;
     nxt_conn_t         *c;
-    nxt_mem_pool_t     *mp;
     nxt_app_request_t  *r;
 
-    mp = nxt_mem_pool_create(1024);
+    mp = nxt_mp_create(1024, 128, 256, 32);
     if (nxt_slow_path(mp == NULL)) {
         return NULL;
     }
 
-    r = nxt_mem_zalloc(mp, sizeof(nxt_app_request_t));
+    r = nxt_mp_zalloc(mp, sizeof(nxt_app_request_t));
     if (nxt_slow_path(r == NULL)) {
         return NULL;
     }
 
-    c = nxt_mem_zalloc(mp, sizeof(nxt_conn_t));
+    c = nxt_mp_zalloc(mp, sizeof(nxt_conn_t));
     if (nxt_slow_path(c == NULL)) {
         return NULL;
     }
@@ -785,9 +785,9 @@ nxt_app_buf_send(nxt_conn_t *c, nxt_buf_t *out)
 static void
 nxt_app_delivery_handler(nxt_task_t *task, void *obj, void *data)
 {
-    nxt_buf_t       *b;
-    nxt_conn_t      *c;
-    nxt_mem_pool_t  *mp;
+    nxt_mp_t    *mp;
+    nxt_buf_t   *b;
+    nxt_conn_t  *c;
 
     c = obj;
     b = data;
@@ -800,7 +800,7 @@ nxt_app_delivery_handler(nxt_task_t *task, void *obj, void *data)
     }
 
     if (c->mem_pool == NULL) {
-        mp = nxt_mem_pool_create(256);
+        mp = nxt_mp_create(1024, 128, 256, 32);
         if (nxt_slow_path(mp == NULL)) {
             close(c->socket.fd);
             return;
@@ -990,6 +990,6 @@ nxt_app_close_request(nxt_task_t *task, void *obj, void *data)
 
     r = c->socket.data;
 
-    nxt_mem_pool_destroy(c->mem_pool);
-    nxt_mem_pool_destroy(r->mem_pool);
+    nxt_mp_destroy(c->mem_pool);
+    nxt_mp_destroy(r->mem_pool);
 }
diff --git a/src/nxt_application.h b/src/nxt_application.h
index 5fd49667..7995ec0d 100644
--- a/src/nxt_application.h
+++ b/src/nxt_application.h
@@ -28,7 +28,7 @@ typedef struct {
 
 typedef struct {
     nxt_event_engine_t         *engine;
-    nxt_mem_pool_t             *mem_pool;
+    nxt_mp_t                   *mem_pool;
     nxt_conn_t                 *event_conn;
     nxt_log_t                  *log;
 
diff --git a/src/nxt_array.c b/src/nxt_array.c
index 69e59c67..d7bc28bd 100644
--- a/src/nxt_array.c
+++ b/src/nxt_array.c
@@ -8,11 +8,11 @@
 
 
 nxt_array_t *
-nxt_array_create(nxt_mem_pool_t *mp, nxt_uint_t n, size_t size)
+nxt_array_create(nxt_mp_t *mp, nxt_uint_t n, size_t size)
 {
     nxt_array_t  *array;
 
-    array = nxt_mem_alloc(mp, sizeof(nxt_array_t) + n * size);
+    array = nxt_mp_alloc(mp, sizeof(nxt_array_t) + n * size);
 
     if (nxt_slow_path(array == NULL)) {
         return NULL;
@@ -47,7 +47,7 @@ nxt_array_add(nxt_array_t *array)
             new_alloc = nalloc + nalloc / 2;
         }
 
-        p = nxt_mem_alloc(array->mem_pool, array->size * new_alloc);
+        p = nxt_mp_alloc(array->mem_pool, array->size * new_alloc);
 
         if (nxt_slow_path(p == NULL)) {
             return NULL;
@@ -55,6 +55,8 @@ nxt_array_add(nxt_array_t *array)
 
         nxt_memcpy(p, array->elts, array->size * nalloc);
 
+        nxt_mp_free(array->mem_pool, array->elts);
+
         array->elts = p;
         array->nalloc = new_alloc;
     }
diff --git a/src/nxt_array.h b/src/nxt_array.h
index 491572da..33e9807a 100644
--- a/src/nxt_array.h
+++ b/src/nxt_array.h
@@ -9,16 +9,16 @@
 
 
 typedef struct {
-    void            *elts;
+    void      *elts;
     /* nelts has uint32_t type because it is used most often. */
-    uint32_t        nelts;
-    uint16_t        size;
-    uint16_t        nalloc;
-    nxt_mem_pool_t  *mem_pool;
+    uint32_t  nelts;
+    uint16_t  size;
+    uint16_t  nalloc;
+    nxt_mp_t  *mem_pool;
 } nxt_array_t;
 
 
-NXT_EXPORT nxt_array_t *nxt_array_create(nxt_mem_pool_t *mp, nxt_uint_t n,
+NXT_EXPORT nxt_array_t *nxt_array_create(nxt_mp_t *mp, nxt_uint_t n,
     size_t size);
 NXT_EXPORT void *nxt_array_add(nxt_array_t *array);
 NXT_EXPORT void *nxt_array_zero_add(nxt_array_t *array);
diff --git a/src/nxt_buf.c b/src/nxt_buf.c
index cee1392e..e07326ef 100644
--- a/src/nxt_buf.c
+++ b/src/nxt_buf.c
@@ -23,11 +23,11 @@ nxt_buf_mem_init(nxt_buf_t *b, void *start, size_t size)
 
 
 nxt_buf_t *
-nxt_buf_mem_alloc(nxt_mem_pool_t *mp, size_t size, nxt_uint_t flags)
+nxt_buf_mem_alloc(nxt_mp_t *mp, size_t size, nxt_uint_t flags)
 {
     nxt_buf_t  *b;
 
-    b = nxt_mem_cache_zalloc0(mp, NXT_BUF_MEM_SIZE);
+    b = nxt_mp_zalloc(mp, NXT_BUF_MEM_SIZE);
     if (nxt_slow_path(b == NULL)) {
         return NULL;
     }
@@ -37,7 +37,7 @@ nxt_buf_mem_alloc(nxt_mem_pool_t *mp, size_t size, nxt_uint_t flags)
     b->size = NXT_BUF_MEM_SIZE;
 
     if (size != 0) {
-        b->mem.start = nxt_mem_buf(mp, &size, flags);
+        b->mem.start = nxt_mp_alloc(mp, size);
         if (nxt_slow_path(b->mem.start == NULL)) {
             return NULL;
         }
@@ -52,11 +52,11 @@ nxt_buf_mem_alloc(nxt_mem_pool_t *mp, size_t size, nxt_uint_t flags)
 
 
 nxt_buf_t *
-nxt_buf_file_alloc(nxt_mem_pool_t *mp, size_t size, nxt_uint_t flags)
+nxt_buf_file_alloc(nxt_mp_t *mp, size_t size, nxt_uint_t flags)
 {
     nxt_buf_t  *b;
 
-    b = nxt_mem_cache_zalloc0(mp, NXT_BUF_FILE_SIZE);
+    b = nxt_mp_zalloc(mp, NXT_BUF_FILE_SIZE);
     if (nxt_slow_path(b == NULL)) {
         return NULL;
     }
@@ -67,7 +67,7 @@ nxt_buf_file_alloc(nxt_mem_pool_t *mp, size_t size, nxt_uint_t flags)
     nxt_buf_set_file(b);
 
     if (size != 0) {
-        b->mem.start = nxt_mem_buf(mp, &size, flags);
+        b->mem.start = nxt_mp_alloc(mp, size);
         if (nxt_slow_path(b->mem.start == NULL)) {
             return NULL;
         }
@@ -82,11 +82,11 @@ nxt_buf_file_alloc(nxt_mem_pool_t *mp, size_t size, nxt_uint_t flags)
 
 
 nxt_buf_t *
-nxt_buf_mmap_alloc(nxt_mem_pool_t *mp, size_t size)
+nxt_buf_mmap_alloc(nxt_mp_t *mp, size_t size)
 {
     nxt_buf_t  *b;
 
-    b = nxt_mem_cache_zalloc0(mp, NXT_BUF_MMAP_SIZE);
+    b = nxt_mp_zalloc(mp, NXT_BUF_MMAP_SIZE);
 
     if (nxt_fast_path(b != NULL)) {
         b->data = mp;
@@ -103,11 +103,11 @@ nxt_buf_mmap_alloc(nxt_mem_pool_t *mp, size_t size)
 
 
 nxt_buf_t *
-nxt_buf_sync_alloc(nxt_mem_pool_t *mp, nxt_uint_t flags)
+nxt_buf_sync_alloc(nxt_mp_t *mp, nxt_uint_t flags)
 {
     nxt_buf_t  *b;
 
-    b = nxt_mem_cache_zalloc0(mp, NXT_BUF_SYNC_SIZE);
+    b = nxt_mp_zalloc(mp, NXT_BUF_SYNC_SIZE);
 
     if (nxt_fast_path(b != NULL)) {
         b->data = mp;
@@ -158,8 +158,8 @@ nxt_buf_chain_length(nxt_buf_t *b)
 static void
 nxt_buf_completion(nxt_task_t *task, void *obj, void *data)
 {
-    nxt_buf_t       *b, *parent;
-    nxt_mem_pool_t  *mp;
+    nxt_mp_t   *mp;
+    nxt_buf_t  *b, *parent;
 
     b = obj;
     parent = data;
diff --git a/src/nxt_buf.h b/src/nxt_buf.h
index c5ac5c20..43c0c453 100644
--- a/src/nxt_buf.h
+++ b/src/nxt_buf.h
@@ -243,17 +243,17 @@ nxt_buf_used_size(b)                                                          \
 
 
 NXT_EXPORT void nxt_buf_mem_init(nxt_buf_t *b, void *start, size_t size);
-NXT_EXPORT nxt_buf_t *nxt_buf_mem_alloc(nxt_mem_pool_t *mp, size_t size,
+NXT_EXPORT nxt_buf_t *nxt_buf_mem_alloc(nxt_mp_t *mp, size_t size,
     nxt_uint_t flags);
-NXT_EXPORT nxt_buf_t *nxt_buf_file_alloc(nxt_mem_pool_t *mp, size_t size,
+NXT_EXPORT nxt_buf_t *nxt_buf_file_alloc(nxt_mp_t *mp, size_t size,
     nxt_uint_t flags);
-NXT_EXPORT nxt_buf_t *nxt_buf_mmap_alloc(nxt_mem_pool_t *mp, size_t size);
-NXT_EXPORT nxt_buf_t *nxt_buf_sync_alloc(nxt_mem_pool_t *mp, nxt_uint_t flags);
+NXT_EXPORT nxt_buf_t *nxt_buf_mmap_alloc(nxt_mp_t *mp, size_t size);
+NXT_EXPORT nxt_buf_t *nxt_buf_sync_alloc(nxt_mp_t *mp, nxt_uint_t flags);
 
 
 #define                                                                       \
 nxt_buf_free(mp, b)                                                           \
-    nxt_mem_cache_free0((mp), (b), (b)->size)
+    nxt_mp_free((mp), (b))
 
 
 NXT_EXPORT void nxt_buf_chain_add(nxt_buf_t **head, nxt_buf_t *in);
diff --git a/src/nxt_buf_filter.c b/src/nxt_buf_filter.c
index fff11f96..83e5baa9 100644
--- a/src/nxt_buf_filter.c
+++ b/src/nxt_buf_filter.c
@@ -415,7 +415,7 @@ nxt_buf_filter_buf_completion(nxt_task_t *task, void *obj, void *data)
 
     fb = ctx->buf;
 
-    nxt_mem_cache_free0(f->mem_pool, ctx, sizeof(nxt_buf_filter_ctx_t));
+    nxt_mp_free(f->mem_pool, ctx);
     nxt_buf_pool_free(&f->filter_file->buffers, b);
 
     if (fb->file_pos < fb->file_end) {
diff --git a/src/nxt_buf_filter.h b/src/nxt_buf_filter.h
index b1015455..27487baa 100644
--- a/src/nxt_buf_filter.h
+++ b/src/nxt_buf_filter.h
@@ -94,7 +94,7 @@ struct nxt_buf_filter_s {
     nxt_work_queue_t             *work_queue;
     nxt_buf_filter_file_t        *filter_file;
     void                         *data;
-    nxt_mem_pool_t               *mem_pool;
+    nxt_mp_t                     *mem_pool;
 
     const nxt_buf_filter_ops_t   *run;
 
diff --git a/src/nxt_buf_pool.c b/src/nxt_buf_pool.c
index 092cf58d..7ef9def5 100644
--- a/src/nxt_buf_pool.c
+++ b/src/nxt_buf_pool.c
@@ -148,7 +148,7 @@ nxt_buf_pool_free(nxt_buf_pool_t *bp, nxt_buf_t *b)
         }
 
         if (!bp->mmap) {
-            nxt_mem_free(bp->mem_pool, b->mem.start);
+            nxt_mp_free(bp->mem_pool, b->mem.start);
         }
 
         nxt_buf_free(bp->mem_pool, b);
@@ -184,7 +184,7 @@ nxt_buf_pool_destroy(nxt_buf_pool_t *bp)
     for (b = bp->free; b != NULL; b = b->next) {
         p = b->mem.start;
         nxt_buf_free(bp->mem_pool, b);
-        nxt_mem_free(bp->mem_pool, p);
+        nxt_mp_free(bp->mem_pool, p);
     }
 
     bp->free = b; /* NULL */
diff --git a/src/nxt_buf_pool.h b/src/nxt_buf_pool.h
index 59609b26..6a04fd7e 100644
--- a/src/nxt_buf_pool.h
+++ b/src/nxt_buf_pool.h
@@ -20,7 +20,7 @@
 typedef struct {
     nxt_buf_t       *current;
     nxt_buf_t       *free;
-    nxt_mem_pool_t  *mem_pool;
+    nxt_mp_t        *mem_pool;
 
     uint16_t        num;
     uint16_t        max;
diff --git a/src/nxt_conf.h b/src/nxt_conf.h
index 214f52d9..38fc77bd 100644
--- a/src/nxt_conf.h
+++ b/src/nxt_conf.h
@@ -26,12 +26,12 @@ nxt_conf_json_value_t *nxt_conf_json_object_get_member(
 
 nxt_int_t nxt_conf_json_op_compile(nxt_conf_json_value_t *object,
     nxt_conf_json_value_t *value, nxt_conf_json_op_t **ops, nxt_str_t *path,
-    nxt_mem_pool_t *pool);
+    nxt_mp_t *pool);
 nxt_conf_json_value_t *nxt_conf_json_clone_value(nxt_conf_json_value_t *value,
-    nxt_conf_json_op_t *op, nxt_mem_pool_t *pool);
+    nxt_conf_json_op_t *op, nxt_mp_t *pool);
 
 nxt_conf_json_value_t *nxt_conf_json_parse(u_char *pos, size_t length,
-    nxt_mem_pool_t *pool);
+    nxt_mp_t *pool);
 
 uintptr_t nxt_conf_json_print_value(u_char *pos, nxt_conf_json_value_t *value,
     nxt_conf_json_pretty_t *pretty);
diff --git a/src/nxt_conf_json.c b/src/nxt_conf_json.c
index 64cf977f..7e482eda 100644
--- a/src/nxt_conf_json.c
+++ b/src/nxt_conf_json.c
@@ -83,24 +83,26 @@ struct nxt_conf_json_op_s {
 
 static u_char *nxt_conf_json_skip_space(u_char *pos, u_char *end);
 static u_char *nxt_conf_json_parse_value(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool);
+    nxt_conf_json_value_t *value, nxt_mp_t *pool);
 static u_char *nxt_conf_json_parse_object(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool);
+    nxt_conf_json_value_t *value, nxt_mp_t *pool);
 static nxt_int_t nxt_conf_json_object_hash_add(nxt_lvlhsh_t *lvlhsh,
-    nxt_conf_json_obj_member_t *member, nxt_mem_pool_t *pool);
+    nxt_conf_json_obj_member_t *member, nxt_mp_t *pool);
 static nxt_int_t nxt_conf_json_object_hash_test(nxt_lvlhsh_query_t *lhq,
     void *data);
+static void *nxt_conf_json_object_hash_alloc(void *data, size_t size);
+static void nxt_conf_json_object_hash_free(void *data, void *p);
 static u_char *nxt_conf_json_parse_array(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool);
+    nxt_conf_json_value_t *value, nxt_mp_t *pool);
 static u_char *nxt_conf_json_parse_string(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool);
+    nxt_conf_json_value_t *value, nxt_mp_t *pool);
 static u_char *nxt_conf_json_parse_number(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool);
+    nxt_conf_json_value_t *value, nxt_mp_t *pool);
 
 static nxt_int_t nxt_conf_json_copy_value(nxt_conf_json_value_t *dst,
-    nxt_conf_json_value_t *src, nxt_conf_json_op_t *op, nxt_mem_pool_t *pool);
+    nxt_conf_json_value_t *src, nxt_conf_json_op_t *op, nxt_mp_t *pool);
 static nxt_int_t nxt_conf_json_copy_object(nxt_conf_json_value_t *dst,
-    nxt_conf_json_value_t *src, nxt_conf_json_op_t *op, nxt_mem_pool_t *pool);
+    nxt_conf_json_value_t *src, nxt_conf_json_op_t *op, nxt_mp_t *pool);
 
 static uintptr_t nxt_conf_json_print_integer(u_char *pos,
     nxt_conf_json_value_t *value);
@@ -239,7 +241,7 @@ nxt_conf_json_object_get_member(nxt_conf_json_value_t *value, nxt_str_t *name,
 nxt_int_t
 nxt_conf_json_op_compile(nxt_conf_json_value_t *object,
     nxt_conf_json_value_t *value, nxt_conf_json_op_t **ops, nxt_str_t *path,
-    nxt_mem_pool_t *pool)
+    nxt_mp_t *pool)
 {
     nxt_str_t                   token;
     nxt_conf_json_op_t          *op, **parent;
@@ -253,7 +255,7 @@ nxt_conf_json_op_compile(nxt_conf_json_value_t *object,
     parent = ops;
 
     for ( ;; ) {
-        op = nxt_mem_zalloc(pool, sizeof(nxt_conf_json_op_t));
+        op = nxt_mp_zget(pool, sizeof(nxt_conf_json_op_t));
         if (nxt_slow_path(op == NULL)) {
             return NXT_ERROR;
         }
@@ -289,14 +291,14 @@ nxt_conf_json_op_compile(nxt_conf_json_value_t *object,
 
     if (object == NULL) {
 
-        member = nxt_mem_zalloc(pool, sizeof(nxt_conf_json_obj_member_t));
+        member = nxt_mp_zget(pool, sizeof(nxt_conf_json_obj_member_t));
         if (nxt_slow_path(member == NULL)) {
             return NXT_ERROR;
         }
 
         if (token.length > NXT_CONF_JSON_STR_SIZE) {
 
-            member->name.u.string = nxt_mem_alloc(pool, sizeof(nxt_str_t));
+            member->name.u.string = nxt_mp_get(pool, sizeof(nxt_str_t));
             if (nxt_slow_path(member->name.u.string == NULL)) {
                 return NXT_ERROR;
             }
@@ -327,11 +329,11 @@ nxt_conf_json_op_compile(nxt_conf_json_value_t *object,
 
 nxt_conf_json_value_t *
 nxt_conf_json_clone_value(nxt_conf_json_value_t *value, nxt_conf_json_op_t *op,
-    nxt_mem_pool_t *pool)
+    nxt_mp_t *pool)
 {
     nxt_conf_json_value_t  *copy;
 
-    copy = nxt_mem_alloc(pool, sizeof(nxt_conf_json_value_t));
+    copy = nxt_mp_get(pool, sizeof(nxt_conf_json_value_t));
     if (nxt_slow_path(copy == NULL)) {
         return NULL;
     }
@@ -348,7 +350,7 @@ nxt_conf_json_clone_value(nxt_conf_json_value_t *value, nxt_conf_json_op_t *op,
 
 static nxt_int_t
 nxt_conf_json_copy_value(nxt_conf_json_value_t *dst, nxt_conf_json_value_t *src,
-    nxt_conf_json_op_t *op, nxt_mem_pool_t *pool)
+    nxt_conf_json_op_t *op, nxt_mp_t *pool)
 {
     size_t      size;
     nxt_int_t   rc;
@@ -377,7 +379,7 @@ nxt_conf_json_copy_value(nxt_conf_json_value_t *dst, nxt_conf_json_value_t *src,
         size = sizeof(nxt_conf_json_array_t)
                + src->u.array->count * sizeof(nxt_conf_json_value_t);
 
-        dst->u.array = nxt_mem_alloc(pool, size);
+        dst->u.array = nxt_mp_get(pool, size);
         if (nxt_slow_path(dst->u.array == NULL)) {
             return NXT_ERROR;
         }
@@ -409,7 +411,7 @@ nxt_conf_json_copy_value(nxt_conf_json_value_t *dst, nxt_conf_json_value_t *src,
 
 static nxt_int_t
 nxt_conf_json_copy_object(nxt_conf_json_value_t *dst,
-    nxt_conf_json_value_t *src, nxt_conf_json_op_t *op, nxt_mem_pool_t *pool)
+    nxt_conf_json_value_t *src, nxt_conf_json_op_t *op, nxt_mp_t *pool)
 {
     size_t                      size;
     nxt_int_t                   rc;
@@ -432,7 +434,7 @@ nxt_conf_json_copy_object(nxt_conf_json_value_t *dst,
     size = sizeof(nxt_conf_json_object_t)
             + count * sizeof(nxt_conf_json_obj_member_t);
 
-    dst->u.object = nxt_mem_alloc(pool, size);
+    dst->u.object = nxt_mp_get(pool, size);
     if (nxt_slow_path(dst->u.object == NULL)) {
         return NXT_ERROR;
     }
@@ -532,12 +534,12 @@ nxt_conf_json_copy_object(nxt_conf_json_value_t *dst,
 
 
 nxt_conf_json_value_t *
-nxt_conf_json_parse(u_char *pos, size_t length, nxt_mem_pool_t *pool)
+nxt_conf_json_parse(u_char *pos, size_t length, nxt_mp_t *pool)
 {
     u_char                 *end;
     nxt_conf_json_value_t  *value;
 
-    value = nxt_mem_alloc(pool, sizeof(nxt_conf_json_value_t));
+    value = nxt_mp_get(pool, sizeof(nxt_conf_json_value_t));
     if (nxt_slow_path(value == NULL)) {
         return NULL;
     }
@@ -588,7 +590,7 @@ nxt_conf_json_skip_space(u_char *pos, u_char *end)
 
 static u_char *
 nxt_conf_json_parse_value(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool)
+    nxt_conf_json_value_t *value, nxt_mp_t *pool)
 {
     u_char  ch;
 
@@ -651,21 +653,20 @@ static const nxt_lvlhsh_proto_t  nxt_conf_json_object_hash_proto
     nxt_aligned(64) =
 {
     NXT_LVLHSH_DEFAULT,
-    0,
     nxt_conf_json_object_hash_test,
-    nxt_lvlhsh_pool_alloc,
-    nxt_lvlhsh_pool_free,
+    nxt_conf_json_object_hash_alloc,
+    nxt_conf_json_object_hash_free,
 };
 
 
 static u_char *
 nxt_conf_json_parse_object(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool)
+    nxt_conf_json_value_t *value, nxt_mp_t *pool)
 {
+    nxt_mp_t                    *temp_pool;
     nxt_int_t                   rc;
     nxt_uint_t                  count;
     nxt_lvlhsh_t                hash;
-    nxt_mem_pool_t              *temp_pool;
     nxt_lvlhsh_each_t           lhe;
     nxt_conf_json_object_t      *object;
     nxt_conf_json_obj_member_t  *member, *element;
@@ -676,7 +677,7 @@ nxt_conf_json_parse_object(u_char *pos, u_char *end,
         return NULL;
     }
 
-    temp_pool = nxt_mem_pool_create(256);
+    temp_pool = nxt_mp_create(1024, 128, 256, 32);
     if (nxt_slow_path(temp_pool == NULL)) {
         return NULL;
     }
@@ -694,8 +695,7 @@ nxt_conf_json_parse_object(u_char *pos, u_char *end,
                 goto error;
             }
 
-            member = nxt_mem_alloc(temp_pool,
-                                   sizeof(nxt_conf_json_obj_member_t));
+            member = nxt_mp_get(temp_pool, sizeof(nxt_conf_json_obj_member_t));
             if (nxt_slow_path(member == NULL)) {
                 goto error;
             }
@@ -752,8 +752,8 @@ nxt_conf_json_parse_object(u_char *pos, u_char *end,
         }
     }
 
-    object = nxt_mem_alloc(pool, sizeof(nxt_conf_json_object_t)
-                                 + count * sizeof(nxt_conf_json_obj_member_t));
+    object = nxt_mp_get(pool, sizeof(nxt_conf_json_object_t)
+                              + count * sizeof(nxt_conf_json_obj_member_t));
     if (nxt_slow_path(object == NULL)) {
         goto error;
     }
@@ -777,20 +777,20 @@ nxt_conf_json_parse_object(u_char *pos, u_char *end,
         *member++ = *element;
     }
 
-    nxt_mem_pool_destroy(temp_pool);
+    nxt_mp_destroy(temp_pool);
 
     return pos + 1;
 
 error:
 
-    nxt_mem_pool_destroy(temp_pool);
+    nxt_mp_destroy(temp_pool);
     return NULL;
 }
 
 
 static nxt_int_t
 nxt_conf_json_object_hash_add(nxt_lvlhsh_t *lvlhsh,
-    nxt_conf_json_obj_member_t *member, nxt_mem_pool_t *pool)
+    nxt_conf_json_obj_member_t *member, nxt_mp_t *pool)
 {
     nxt_lvlhsh_query_t     lhq;
     nxt_conf_json_value_t  *name;
@@ -839,13 +839,27 @@ nxt_conf_json_object_hash_test(nxt_lvlhsh_query_t *lhq, void *data)
 }
 
 
+static void *
+nxt_conf_json_object_hash_alloc(void *data, size_t size)
+{
+    return nxt_mp_align(data, size, size);
+}
+
+
+static void
+nxt_conf_json_object_hash_free(void *data, void *p)
+{
+    return nxt_mp_free(data, p);
+}
+
+
 static u_char *
 nxt_conf_json_parse_array(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool)
+    nxt_conf_json_value_t *value, nxt_mp_t *pool)
 {
+    nxt_mp_t               *temp_pool;
     nxt_uint_t             count;
     nxt_list_t             *list;
-    nxt_mem_pool_t         *temp_pool;
     nxt_conf_json_array_t  *array;
     nxt_conf_json_value_t  *element;
 
@@ -855,7 +869,7 @@ nxt_conf_json_parse_array(u_char *pos, u_char *end,
         return NULL;
     }
 
-    temp_pool = nxt_mem_pool_create(256);
+    temp_pool = nxt_mp_create(1024, 128, 256, 32);
     if (nxt_slow_path(temp_pool == NULL)) {
         return NULL;
     }
@@ -905,8 +919,8 @@ nxt_conf_json_parse_array(u_char *pos, u_char *end,
         }
     }
 
-    array = nxt_mem_alloc(pool, sizeof(nxt_conf_json_array_t)
-                                + count * sizeof(nxt_conf_json_value_t));
+    array = nxt_mp_get(pool, sizeof(nxt_conf_json_array_t)
+                             + count * sizeof(nxt_conf_json_value_t));
     if (nxt_slow_path(array == NULL)) {
         goto error;
     }
@@ -921,20 +935,20 @@ nxt_conf_json_parse_array(u_char *pos, u_char *end,
         *element++ = *value;
     } nxt_list_loop;
 
-    nxt_mem_pool_destroy(temp_pool);
+    nxt_mp_destroy(temp_pool);
 
     return pos + 1;
 
 error:
 
-    nxt_mem_pool_destroy(temp_pool);
+    nxt_mp_destroy(temp_pool);
     return NULL;
 }
 
 
 static u_char *
 nxt_conf_json_parse_string(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool)
+    nxt_conf_json_value_t *value, nxt_mp_t *pool)
 {
     u_char      ch, *last, *s;
     size_t      size, surplus;
@@ -1146,7 +1160,7 @@ nxt_conf_json_parse_string(u_char *pos, u_char *end,
 
 static u_char *
 nxt_conf_json_parse_number(u_char *pos, u_char *end,
-    nxt_conf_json_value_t *value, nxt_mem_pool_t *pool)
+    nxt_conf_json_value_t *value, nxt_mp_t *pool)
 {
     u_char     ch, *p;
     uint64_t   integer;
diff --git a/src/nxt_conn.c b/src/nxt_conn.c
index 3f21747e..bba2bfd1 100644
--- a/src/nxt_conn.c
+++ b/src/nxt_conn.c
@@ -42,12 +42,12 @@ nxt_conn_io_t  nxt_unix_conn_io = {
 
 
 nxt_conn_t *
-nxt_conn_create(nxt_mem_pool_t *mp, nxt_task_t *task)
+nxt_conn_create(nxt_mp_t *mp, nxt_task_t *task)
 {
     nxt_conn_t    *c;
     nxt_thread_t  *thr;
 
-    c = nxt_mem_zalloc(mp, sizeof(nxt_conn_t));
+    c = nxt_mp_zget(mp, sizeof(nxt_conn_t));
     if (nxt_slow_path(c == NULL)) {
         return NULL;
     }
diff --git a/src/nxt_conn.h b/src/nxt_conn.h
index 491531b0..479450bb 100644
--- a/src/nxt_conn.h
+++ b/src/nxt_conn.h
@@ -155,7 +155,7 @@ struct nxt_conn_s {
 
 #endif
 
-    nxt_mem_pool_t                *mem_pool;
+    nxt_mp_t                      *mem_pool;
 
     nxt_task_t                    task;
     nxt_log_t                     log;
@@ -226,7 +226,7 @@ struct nxt_conn_s {
 #endif
 
 
-NXT_EXPORT nxt_conn_t *nxt_conn_create(nxt_mem_pool_t *mp, nxt_task_t *task);
+NXT_EXPORT nxt_conn_t *nxt_conn_create(nxt_mp_t *mp, nxt_task_t *task);
 void nxt_conn_io_shutdown(nxt_task_t *task, void *obj, void *data);
 NXT_EXPORT void nxt_conn_close(nxt_event_engine_t *engine, nxt_conn_t *c);
 
diff --git a/src/nxt_conn_accept.c b/src/nxt_conn_accept.c
index eb0172f4..4fcd530d 100644
--- a/src/nxt_conn_accept.c
+++ b/src/nxt_conn_accept.c
@@ -82,9 +82,9 @@ nxt_listen_event(nxt_task_t *task, nxt_listen_socket_t *ls)
 static nxt_conn_t *
 nxt_conn_accept_alloc(nxt_task_t *task, nxt_listen_event_t *lev)
 {
+    nxt_mp_t             *mp;
     nxt_conn_t           *c;
     nxt_sockaddr_t       *sa, *remote;
-    nxt_mem_pool_t       *mp;
     nxt_event_engine_t   *engine;
     nxt_listen_socket_t  *ls;
 
@@ -92,11 +92,13 @@ nxt_conn_accept_alloc(nxt_task_t *task, nxt_listen_event_t *lev)
 
     if (engine->connections < engine->max_connections) {
 
-        mp = nxt_mem_pool_create(lev->listen->mem_pool_size);
+        mp = nxt_mp_create(1024, 128, 256, 32);
 
         if (nxt_fast_path(mp != NULL)) {
-            /* This allocation cannot fail. */
             c = nxt_conn_create(mp, lev->socket.task);
+            if (nxt_slow_path(c == NULL)) {
+                goto fail;
+            }
 
             lev->next = c;
             c->socket.read_work_queue = lev->socket.read_work_queue;
@@ -104,8 +106,12 @@ nxt_conn_accept_alloc(nxt_task_t *task, nxt_listen_event_t *lev)
             c->listen = lev;
 
             ls = lev->listen;
-            /* This allocation cannot fail. */
+
             remote = nxt_sockaddr_alloc(mp, ls->socklen, ls->address_length);
+            if (nxt_slow_path(remote == NULL)) {
+                goto fail;
+            }
+
             c->remote = remote;
 
             sa = ls->sockaddr;
@@ -118,6 +124,10 @@ nxt_conn_accept_alloc(nxt_task_t *task, nxt_listen_event_t *lev)
 
             return c;
         }
+
+    fail:
+
+        nxt_mp_destroy(mp);
     }
 
     return NULL;
diff --git a/src/nxt_conn_proxy.c b/src/nxt_conn_proxy.c
index dec23684..63a41c39 100644
--- a/src/nxt_conn_proxy.c
+++ b/src/nxt_conn_proxy.c
@@ -63,7 +63,7 @@ nxt_conn_proxy_create(nxt_conn_t *client)
     nxt_thread_t      *thr;
     nxt_conn_proxy_t  *p;
 
-    p = nxt_mem_zalloc(client->mem_pool, sizeof(nxt_conn_proxy_t));
+    p = nxt_mp_zget(client->mem_pool, sizeof(nxt_conn_proxy_t));
     if (nxt_slow_path(p == NULL)) {
         return NULL;
     }
@@ -152,9 +152,7 @@ nxt_conn_proxy_client_buffer_alloc(nxt_task_t *task, void *obj, void *data)
 
     nxt_debug(task, "conn proxy client first read fd:%d", client->socket.fd);
 
-    b = nxt_buf_mem_alloc(client->mem_pool, p->client_buffer_size,
-                          NXT_MEM_BUF_CUTBACK | NXT_MEM_BUF_USABLE);
-
+    b = nxt_buf_mem_alloc(client->mem_pool, p->client_buffer_size, 0);
     if (nxt_slow_path(b == NULL)) {
         /* An error completion. */
         nxt_conn_proxy_complete(task, p);
@@ -303,9 +301,7 @@ nxt_conn_proxy_peer_read(nxt_task_t *task, void *obj, void *data)
 
     nxt_debug(task, "conn proxy peer read fd:%d", peer->socket.fd);
 
-    b = nxt_buf_mem_alloc(peer->mem_pool, p->peer_buffer_size,
-                          NXT_MEM_BUF_CUTBACK | NXT_MEM_BUF_USABLE);
-
+    b = nxt_buf_mem_alloc(peer->mem_pool, p->peer_buffer_size, 0);
     if (nxt_slow_path(b == NULL)) {
         /* An error completion. */
         nxt_conn_proxy_complete(task, p);
@@ -894,7 +890,7 @@ nxt_conn_proxy_shutdown(nxt_task_t *task, nxt_conn_proxy_t *p,
 
     /* Free the direction's buffer. */
     b = (source == p->client) ? p->client_buffer : p->peer_buffer;
-    nxt_mem_free(source->mem_pool, b);
+    nxt_mp_free(source->mem_pool, b);
 }
 
 
@@ -990,8 +986,8 @@ nxt_conn_proxy_completion(nxt_task_t *task, void *obj, void *data)
     p->retain--;
 
     if (p->retain == 0) {
-        nxt_mem_free(p->client->mem_pool, p->client_buffer);
-        nxt_mem_free(p->client->mem_pool, p->peer_buffer);
+        nxt_mp_free(p->client->mem_pool, p->client_buffer);
+        nxt_mp_free(p->client->mem_pool, p->peer_buffer);
 
         p->completion_handler(task, p, NULL);
     }
diff --git a/src/nxt_controller.c b/src/nxt_controller.c
index 6ec4c744..b098d581 100644
--- a/src/nxt_controller.c
+++ b/src/nxt_controller.c
@@ -13,7 +13,7 @@
 
 typedef struct {
     nxt_conf_json_value_t  *root;
-    nxt_mem_pool_t         *pool;
+    nxt_mp_t               *pool;
 } nxt_controller_conf_t;
 
 
@@ -58,7 +58,7 @@ static void nxt_controller_process_request(nxt_task_t *task,
 static nxt_int_t nxt_controller_response(nxt_task_t *task, nxt_conn_t *c,
     nxt_controller_response_t *resp);
 static nxt_buf_t *nxt_controller_response_body(nxt_controller_response_t *resp,
-    nxt_mem_pool_t *pool);
+    nxt_mp_t *pool);
 
 
 static nxt_http_fields_hash_entry_t  nxt_controller_request_fields[] = {
@@ -83,7 +83,7 @@ static const nxt_event_conn_state_t  nxt_controller_conn_close_state;
 nxt_int_t
 nxt_controller_start(nxt_task_t *task, nxt_runtime_t *rt)
 {
-    nxt_mem_pool_t          *mp;
+    nxt_mp_t                *mp;
     nxt_conf_json_value_t   *conf;
     nxt_http_fields_hash_t  *hash;
 
@@ -102,7 +102,7 @@ nxt_controller_start(nxt_task_t *task, nxt_runtime_t *rt)
         return NXT_ERROR;
     }
 
-    mp = nxt_mem_pool_create(256);
+    mp = nxt_mp_create(1024, 128, 256, 32);
 
     if (nxt_slow_path(mp == NULL)) {
         return NXT_ERROR;
@@ -145,7 +145,7 @@ nxt_runtime_controller_socket(nxt_task_t *task, nxt_runtime_t *rt)
         rt->controller_listen = sa;
     }
 
-    ls = nxt_mem_alloc(rt->mem_pool, sizeof(nxt_listen_socket_t));
+    ls = nxt_mp_alloc(rt->mem_pool, sizeof(nxt_listen_socket_t));
     if (ls == NULL) {
         return NXT_ERROR;
     }
@@ -167,7 +167,7 @@ nxt_runtime_controller_socket(nxt_task_t *task, nxt_runtime_t *rt)
 
 #if 0
     /* STUB */
-    wq = nxt_mem_zalloc(cf->mem_pool, sizeof(nxt_work_queue_t));
+    wq = nxt_mp_zget(cf->mem_pool, sizeof(nxt_work_queue_t));
     if (wq == NULL) {
         return NXT_ERROR;
     }
@@ -178,15 +178,6 @@ nxt_runtime_controller_socket(nxt_task_t *task, nxt_runtime_t *rt)
 #endif
     ls->handler = nxt_controller_conn_init;
 
-    /*
-     * Connection memory pool chunk size is tunned to
-     * allocate the most data in one mem_pool chunk.
-     */
-    ls->mem_pool_size = nxt_listen_socket_pool_min_size(ls)
-                        + sizeof(nxt_event_conn_proxy_t)
-                        + sizeof(nxt_conn_t)
-                        + 4 * sizeof(nxt_buf_t);
-
     if (nxt_listen_socket_create(task, ls, 0) != NXT_OK) {
         return NXT_ERROR;
     }
@@ -209,7 +200,7 @@ nxt_controller_conn_init(nxt_task_t *task, void *obj, void *data)
 
     nxt_debug(task, "controller conn init fd:%d", c->socket.fd);
 
-    r = nxt_mem_zalloc(c->mem_pool, sizeof(nxt_controller_request_t));
+    r = nxt_mp_zget(c->mem_pool, sizeof(nxt_controller_request_t));
     if (nxt_slow_path(r == NULL)) {
         nxt_controller_conn_free(task, c, NULL);
         return;
@@ -513,7 +504,7 @@ nxt_controller_conn_free(nxt_task_t *task, void *obj, void *data)
 
     nxt_debug(task, "controller conn free");
 
-    nxt_mem_pool_destroy(c->mem_pool);
+    nxt_mp_destroy(c->mem_pool);
 
     //nxt_free(c);
 }
@@ -547,11 +538,11 @@ static void
 nxt_controller_process_request(nxt_task_t *task, nxt_conn_t *c,
     nxt_controller_request_t *req)
 {
+    nxt_mp_t                   *mp;
     nxt_int_t                  rc;
     nxt_str_t                  path;
     nxt_uint_t                 status;
     nxt_buf_mem_t              *mbuf;
-    nxt_mem_pool_t             *mp;
     nxt_conf_json_op_t         *ops;
     nxt_conf_json_value_t      *value;
     nxt_controller_response_t  resp;
@@ -590,7 +581,7 @@ nxt_controller_process_request(nxt_task_t *task, nxt_conn_t *c,
 
     if (nxt_str_eq(&req->parser.method, "PUT", 3)) {
 
-        mp = nxt_mem_pool_create(512);
+        mp = nxt_mp_create(1024, 128, 256, 32);
 
         if (nxt_slow_path(mp == NULL)) {
             status = 500;
@@ -602,7 +593,7 @@ nxt_controller_process_request(nxt_task_t *task, nxt_conn_t *c,
         value = nxt_conf_json_parse(mbuf->pos, mbuf->free - mbuf->pos, mp);
 
         if (value == NULL) {
-            nxt_mem_pool_destroy(mp);
+            nxt_mp_destroy(mp);
             status = 400;
             goto done;
         }
@@ -625,13 +616,13 @@ nxt_controller_process_request(nxt_task_t *task, nxt_conn_t *c,
                                               ops, mp);
 
             if (nxt_slow_path(value == NULL)) {
-                nxt_mem_pool_destroy(mp);
+                nxt_mp_destroy(mp);
                 status = 500;
                 goto done;
             }
         }
 
-        nxt_mem_pool_destroy(nxt_controller_conf.pool);
+        nxt_mp_destroy(nxt_controller_conf.pool);
 
         nxt_controller_conf.root = value;
         nxt_controller_conf.pool = mp;
@@ -645,7 +636,7 @@ nxt_controller_process_request(nxt_task_t *task, nxt_conn_t *c,
     if (nxt_str_eq(&req->parser.method, "DELETE", 6)) {
 
         if (path.length == 1) {
-            mp = nxt_mem_pool_create(128);
+            mp = nxt_mp_create(1024, 128, 256, 32);
 
             if (nxt_slow_path(mp == NULL)) {
                 status = 500;
@@ -668,7 +659,7 @@ nxt_controller_process_request(nxt_task_t *task, nxt_conn_t *c,
                 goto done;
             }
 
-            mp = nxt_mem_pool_create(512);
+            mp = nxt_mp_create(1024, 128, 256, 32);
 
             if (nxt_slow_path(mp == NULL)) {
                 status = 500;
@@ -680,12 +671,12 @@ nxt_controller_process_request(nxt_task_t *task, nxt_conn_t *c,
         }
 
         if (nxt_slow_path(value == NULL)) {
-            nxt_mem_pool_destroy(mp);
+            nxt_mp_destroy(mp);
             status = 500;
             goto done;
         }
 
-        nxt_mem_pool_destroy(nxt_controller_conf.pool);
+        nxt_mp_destroy(nxt_controller_conf.pool);
 
         nxt_controller_conf.root = value;
         nxt_controller_conf.pool = mp;
@@ -772,8 +763,7 @@ nxt_controller_response(nxt_task_t *task, nxt_conn_t *c,
 
 
 static nxt_buf_t *
-nxt_controller_response_body(nxt_controller_response_t *resp,
-    nxt_mem_pool_t *pool)
+nxt_controller_response_body(nxt_controller_response_t *resp, nxt_mp_t *pool)
 {
     size_t                  size;
     nxt_buf_t               *b;
diff --git a/src/nxt_cyassl.c b/src/nxt_cyassl.c
index 404b89fe..3d487183 100644
--- a/src/nxt_cyassl.c
+++ b/src/nxt_cyassl.c
@@ -182,7 +182,7 @@ nxt_cyassl_conn_init(nxt_thread_t *thr, nxt_ssltls_conf_t *conf,
 
     nxt_log_debug(c->socket.log, "cyassl conn init");
 
-    ssltls = nxt_mem_zalloc(c->mem_pool, sizeof(nxt_cyassl_conn_t));
+    ssltls = nxt_mp_zget(c->mem_pool, sizeof(nxt_cyassl_conn_t));
     if (ssltls == NULL) {
         goto fail;
     }
diff --git a/src/nxt_fastcgi_source.c b/src/nxt_fastcgi_source.c
index d655fca8..f81f7059 100644
--- a/src/nxt_fastcgi_source.c
+++ b/src/nxt_fastcgi_source.c
@@ -125,7 +125,7 @@ nxt_fastcgi_source_handler(nxt_task_t *task, nxt_upstream_source_t *us,
     nxt_stream_source_t   *stream;
     nxt_fastcgi_source_t  *fs;
 
-    fs = nxt_mem_zalloc(us->buffers.mem_pool, sizeof(nxt_fastcgi_source_t));
+    fs = nxt_mp_zget(us->buffers.mem_pool, sizeof(nxt_fastcgi_source_t));
     if (nxt_slow_path(fs == NULL)) {
         goto fail;
     }
@@ -145,8 +145,7 @@ nxt_fastcgi_source_handler(nxt_task_t *task, nxt_upstream_source_t *us,
     stream = us->stream;
 
     if (stream == NULL) {
-        stream = nxt_mem_zalloc(us->buffers.mem_pool,
-                                sizeof(nxt_stream_source_t));
+        stream = nxt_mp_zget(us->buffers.mem_pool, sizeof(nxt_stream_source_t));
         if (nxt_slow_path(stream == NULL)) {
             goto fail;
         }
@@ -605,7 +604,7 @@ static const nxt_upstream_name_value_t  nxt_fastcgi_source_headers[]
 
 
 nxt_int_t
-nxt_fastcgi_source_hash_create(nxt_mem_pool_t *mp, nxt_lvlhsh_t *lh)
+nxt_fastcgi_source_hash_create(nxt_mp_t *mp, nxt_lvlhsh_t *lh)
 {
     return nxt_upstream_header_hash_add(mp, lh, nxt_fastcgi_source_headers,
                                         nxt_nitems(nxt_fastcgi_source_headers));
diff --git a/src/nxt_fastcgi_source.h b/src/nxt_fastcgi_source.h
index 293cb704..979e962b 100644
--- a/src/nxt_fastcgi_source.h
+++ b/src/nxt_fastcgi_source.h
@@ -37,7 +37,7 @@ struct nxt_fastcgi_parse_s {
 
     nxt_buf_t                            *(*last_buf)(nxt_fastcgi_parse_t *fp);
     void                                 *data;
-    nxt_mem_pool_t                       *mem_pool;
+    nxt_mp_t                             *mem_pool;
 };
 
 
@@ -84,7 +84,7 @@ struct nxt_fastcgi_source_s {
 NXT_EXPORT void nxt_fastcgi_source_handler(nxt_task_t *task,
     nxt_upstream_source_t *us,
     nxt_fastcgi_source_request_create_t request_create);
-NXT_EXPORT nxt_int_t nxt_fastcgi_source_hash_create(nxt_mem_pool_t *mp,
+NXT_EXPORT nxt_int_t nxt_fastcgi_source_hash_create(nxt_mp_t *mp,
     nxt_lvlhsh_t *lh);
 void nxt_fastcgi_record_parse(nxt_task_t *task, nxt_fastcgi_parse_t *fp,
     nxt_buf_t *in);
diff --git a/src/nxt_fd_event.c b/src/nxt_fd_event.c
index 98144203..11515852 100644
--- a/src/nxt_fd_event.c
+++ b/src/nxt_fd_event.c
@@ -14,7 +14,6 @@ static void nxt_fd_event_hash_error(nxt_task_t *task, nxt_fd_t fd);
 static const nxt_lvlhsh_proto_t  nxt_event_set_fd_hash_proto  nxt_aligned(64) =
 {
     NXT_LVLHSH_LARGE_MEMALIGN,
-    0,
     nxt_fd_event_hash_test,
     nxt_lvlhsh_alloc,
     nxt_lvlhsh_free,
diff --git a/src/nxt_file.h b/src/nxt_file.h
index 66220127..4b8e5684 100644
--- a/src/nxt_file.h
+++ b/src/nxt_file.h
@@ -34,7 +34,7 @@ nxt_file_name_str_set(file_name, mem_pool, name)                              \
 
 #define                                                                       \
 nxt_file_name_alloc(mem_pool, len)                                            \
-    nxt_mem_nalloc(mem_pool, len)
+    nxt_mp_nget(mem_pool, len)
 
 
 #define                                                                       \
diff --git a/src/nxt_file_name.c b/src/nxt_file_name.c
index c8d8cad1..935479ea 100644
--- a/src/nxt_file_name.c
+++ b/src/nxt_file_name.c
@@ -17,7 +17,7 @@
  */
 
 nxt_int_t
-nxt_file_name_create(nxt_mem_pool_t *mp, nxt_file_name_str_t *file_name,
+nxt_file_name_create(nxt_mp_t *mp, nxt_file_name_str_t *file_name,
     const char *format, ...)
 {
     u_char           ch, *p;
diff --git a/src/nxt_file_name.h b/src/nxt_file_name.h
index a0c00406..f8e7a3ba 100644
--- a/src/nxt_file_name.h
+++ b/src/nxt_file_name.h
@@ -8,7 +8,7 @@
 #define _NXT_FILE_NAME_H_INCLUDED_
 
 
-NXT_EXPORT nxt_int_t nxt_file_name_create(nxt_mem_pool_t *mp,
+NXT_EXPORT nxt_int_t nxt_file_name_create(nxt_mp_t *mp,
     nxt_file_name_str_t *fn, const char *format, ...);
 
 
diff --git a/src/nxt_gnutls.c b/src/nxt_gnutls.c
index 15db7fc8..2db43d4a 100644
--- a/src/nxt_gnutls.c
+++ b/src/nxt_gnutls.c
@@ -262,7 +262,7 @@ nxt_gnutls_conn_init(nxt_thread_t *thr, nxt_ssltls_conf_t *conf,
 
     nxt_log_debug(c->socket.log, "gnutls conn init");
 
-    ssltls = nxt_mem_zalloc(c->mem_pool, sizeof(nxt_gnutls_conn_t));
+    ssltls = nxt_mp_zget(c->mem_pool, sizeof(nxt_gnutls_conn_t));
     if (ssltls == NULL) {
         goto fail;
     }
diff --git a/src/nxt_http_parse.c b/src/nxt_http_parse.c
index 3e74461b..d5a43bd0 100644
--- a/src/nxt_http_parse.c
+++ b/src/nxt_http_parse.c
@@ -658,7 +658,7 @@ nxt_http_parse_field_end(nxt_http_request_parse_t *rp, u_char **pos,
 
 nxt_http_fields_hash_t *
 nxt_http_fields_hash_create(nxt_http_fields_hash_entry_t *entries,
-    nxt_mem_pool_t *mp)
+    nxt_mp_t *mp)
 {
     size_t                      min_length, max_length, length, size;
     nxt_uint_t                  i, j, n;
@@ -687,7 +687,7 @@ nxt_http_fields_hash_create(nxt_http_fields_hash_entry_t *entries,
                 * sizeof(nxt_http_fields_hash_elt_t *);
     }
 
-    hash = nxt_mem_zalloc(mp, size);
+    hash = nxt_mp_zget(mp, size);
     if (nxt_slow_path(hash == NULL)) {
         return NULL;
     }
@@ -713,8 +713,7 @@ nxt_http_fields_hash_create(nxt_http_fields_hash_entry_t *entries,
 
         size = sizeof(nxt_http_fields_hash_elt_t) + nxt_align_size(length, 8);
 
-        elt = nxt_mem_zalloc(mp, n * size
-                                 + sizeof(nxt_http_fields_hash_elt_t));
+        elt = nxt_mp_zget(mp, n * size + sizeof(nxt_http_fields_hash_elt_t));
 
         if (nxt_slow_path(elt == NULL)) {
             return NULL;
diff --git a/src/nxt_http_parse.h b/src/nxt_http_parse.h
index 4cf3dc3c..590101be 100644
--- a/src/nxt_http_parse.h
+++ b/src/nxt_http_parse.h
@@ -71,7 +71,7 @@ typedef struct {
 
 
 nxt_inline nxt_int_t
-nxt_http_parse_request_init(nxt_http_request_parse_t *rp, nxt_mem_pool_t *mp)
+nxt_http_parse_request_init(nxt_http_request_parse_t *rp, nxt_mp_t *mp)
 {
     rp->fields = nxt_list_create(mp, 8, sizeof(nxt_http_field_t));
     if (nxt_slow_path(rp->fields == NULL)){
@@ -86,7 +86,7 @@ nxt_int_t nxt_http_parse_request(nxt_http_request_parse_t *rp,
     nxt_buf_mem_t *b);
 
 nxt_http_fields_hash_t *nxt_http_fields_hash_create(
-    nxt_http_fields_hash_entry_t *entries, nxt_mem_pool_t *mp);
+    nxt_http_fields_hash_entry_t *entries, nxt_mp_t *mp);
 nxt_http_fields_hash_entry_t *nxt_http_fields_hash_lookup(
     nxt_http_fields_hash_t *hash, nxt_http_field_t *field);
 
diff --git a/src/nxt_http_source.c b/src/nxt_http_source.c
index 10c5527b..889dcd08 100644
--- a/src/nxt_http_source.c
+++ b/src/nxt_http_source.c
@@ -50,7 +50,7 @@ nxt_http_source_handler(nxt_task_t *task, nxt_upstream_source_t *us,
     nxt_http_source_t    *hs;
     nxt_stream_source_t  *stream;
 
-    hs = nxt_mem_zalloc(us->buffers.mem_pool, sizeof(nxt_http_source_t));
+    hs = nxt_mp_zget(us->buffers.mem_pool, sizeof(nxt_http_source_t));
     if (nxt_slow_path(hs == NULL)) {
         goto fail;
     }
@@ -70,8 +70,7 @@ nxt_http_source_handler(nxt_task_t *task, nxt_upstream_source_t *us,
     stream = us->stream;
 
     if (stream == NULL) {
-        stream = nxt_mem_zalloc(us->buffers.mem_pool,
-                                sizeof(nxt_stream_source_t));
+        stream = nxt_mp_zget(us->buffers.mem_pool, sizeof(nxt_stream_source_t));
         if (nxt_slow_path(stream == NULL)) {
             goto fail;
         }
@@ -382,7 +381,7 @@ static const nxt_upstream_name_value_t  nxt_http_source_headers[]
 
 
 nxt_int_t
-nxt_http_source_hash_create(nxt_mem_pool_t *mp, nxt_lvlhsh_t *lh)
+nxt_http_source_hash_create(nxt_mp_t *mp, nxt_lvlhsh_t *lh)
 {
     return nxt_upstream_header_hash_add(mp, lh, nxt_http_source_headers,
                                         nxt_nitems(nxt_http_source_headers));
@@ -444,8 +443,8 @@ nxt_http_source_header_ready(nxt_task_t *task, nxt_http_source_t *hs,
     if (nxt_fast_path(nxt_buf_pool_available(&us->buffers))) {
 
         if (hs->chunked) {
-            hsc = nxt_mem_zalloc(hs->upstream->buffers.mem_pool,
-                                 sizeof(nxt_http_source_chunk_t));
+            hsc = nxt_mp_zalloc(hs->upstream->buffers.mem_pool,
+                                sizeof(nxt_http_source_chunk_t));
             if (nxt_slow_path(hsc == NULL)) {
                 goto fail;
             }
diff --git a/src/nxt_http_source.h b/src/nxt_http_source.h
index 3844f569..7cf2876b 100644
--- a/src/nxt_http_source.h
+++ b/src/nxt_http_source.h
@@ -40,7 +40,7 @@ struct nxt_http_source_s {
 
 NXT_EXPORT void nxt_http_source_handler(nxt_task_t *task,
     nxt_upstream_source_t *us, nxt_http_source_request_create_t request_create);
-NXT_EXPORT nxt_int_t nxt_http_source_hash_create(nxt_mem_pool_t *mp,
+NXT_EXPORT nxt_int_t nxt_http_source_hash_create(nxt_mp_t *mp,
     nxt_lvlhsh_t *lh);
 
 
diff --git a/src/nxt_job.c b/src/nxt_job.c
index 68ced550..1e08cc26 100644
--- a/src/nxt_job.c
+++ b/src/nxt_job.c
@@ -15,23 +15,22 @@ static void nxt_job_thread_return_handler(nxt_task_t *task, void *obj,
 
 
 void *
-nxt_job_create(nxt_mem_pool_t *mp, size_t size)
+nxt_job_create(nxt_mp_t *mp, size_t size)
 {
     size_t     cache_size;
     nxt_job_t  *job;
 
     if (mp == NULL) {
-        mp = nxt_mem_pool_create(256);
-
+        mp = nxt_mp_create(1024, 128, 256, 32);
         if (nxt_slow_path(mp == NULL)) {
             return NULL;
         }
 
-        job = nxt_mem_zalloc(mp, size);
+        job = nxt_mp_zget(mp, size);
         cache_size = 0;
 
     } else {
-        job = nxt_mem_cache_zalloc0(mp, size);
+        job = nxt_mp_zalloc(mp, size);
         cache_size = size;
     }
 
@@ -71,17 +70,19 @@ nxt_job_destroy(nxt_task_t *task, void *data)
     if (job->cache_size == 0) {
 
         if (job->mem_pool != NULL) {
-            nxt_mem_pool_destroy(job->mem_pool);
+            nxt_mp_destroy(job->mem_pool);
         }
 
     } else {
-        nxt_mem_cache_free0(job->mem_pool, job, job->cache_size);
+        nxt_mp_free(job->mem_pool, job);
     }
 }
 
 
+#if 0
+
 nxt_int_t
-nxt_job_cleanup_add(nxt_mem_pool_t *mp, nxt_job_t *job)
+nxt_job_cleanup_add(nxt_mp_t *mp, nxt_job_t *job)
 {
     nxt_mem_pool_cleanup_t  *mpcl;
 
@@ -96,6 +97,8 @@ nxt_job_cleanup_add(nxt_mem_pool_t *mp, nxt_job_t *job)
     return NXT_ERROR;
 }
 
+#endif
+
 
 /*
  * The (void *) casts in nxt_thread_pool_post() and nxt_event_engine_post()
diff --git a/src/nxt_job.h b/src/nxt_job.h
index 9d004d0a..9445f17d 100644
--- a/src/nxt_job.h
+++ b/src/nxt_job.h
@@ -40,7 +40,7 @@ typedef struct {
     uint16_t            cache_size;
     uint8_t             cancel;          /* 1 bit */
 
-    nxt_mem_pool_t      *mem_pool;
+    nxt_mp_t            *mem_pool;
     nxt_queue_link_t    link;
 
 #if (NXT_THREADS)
@@ -58,10 +58,10 @@ typedef struct {
 } nxt_job_t;
 
 
-NXT_EXPORT void *nxt_job_create(nxt_mem_pool_t *mp, size_t size);
+NXT_EXPORT void *nxt_job_create(nxt_mp_t *mp, size_t size);
 NXT_EXPORT void nxt_job_init(nxt_job_t *job, size_t size);
 NXT_EXPORT void nxt_job_destroy(nxt_task_t *task, void *data);
-NXT_EXPORT nxt_int_t nxt_job_cleanup_add(nxt_mem_pool_t *mp, nxt_job_t *job);
+NXT_EXPORT nxt_int_t nxt_job_cleanup_add(nxt_mp_t *mp, nxt_job_t *job);
 
 NXT_EXPORT void nxt_job_start(nxt_task_t *task, nxt_job_t *job,
     nxt_work_handler_t handler);
diff --git a/src/nxt_job_cache_file.c b/src/nxt_job_cache_file.c
index 786691f6..13f01a45 100644
--- a/src/nxt_job_cache_file.c
+++ b/src/nxt_job_cache_file.c
@@ -9,7 +9,7 @@
 
 
 nxt_job_cache_file_t *
-nxt_job_cache_file_create(nxt_mem_pool_t *mp)
+nxt_job_cache_file_create(nxt_mp_t *mp)
 {
     nxt_job_cache_file_t  *jbc;
 
diff --git a/src/nxt_job_file.c b/src/nxt_job_file.c
index 34f7ce08..eab13367 100644
--- a/src/nxt_job_file.c
+++ b/src/nxt_job_file.c
@@ -17,7 +17,7 @@ static nxt_int_t nxt_job_file_read_required(nxt_job_file_t *jbf);
 
 
 nxt_job_file_t *
-nxt_job_file_create(nxt_mem_pool_t *mp)
+nxt_job_file_create(nxt_mp_t *mp)
 {
     nxt_job_file_t  *jbf;
 
diff --git a/src/nxt_job_file.h b/src/nxt_job_file.h
index a1ccef06..93c6393c 100644
--- a/src/nxt_job_file.h
+++ b/src/nxt_job_file.h
@@ -66,7 +66,7 @@ struct nxt_job_file_s {
 };
 
 
-NXT_EXPORT nxt_job_file_t *nxt_job_file_create(nxt_mem_pool_t *mp);
+NXT_EXPORT nxt_job_file_t *nxt_job_file_create(nxt_mp_t *mp);
 NXT_EXPORT void nxt_job_file_init(nxt_job_file_t *jbf);
 NXT_EXPORT void nxt_job_file_read(nxt_task_t *task, nxt_job_t *job);
 
diff --git a/src/nxt_job_resolve.c b/src/nxt_job_resolve.c
index dc508ec3..a1317756 100644
--- a/src/nxt_job_resolve.c
+++ b/src/nxt_job_resolve.c
@@ -13,8 +13,8 @@ nxt_job_resolve(nxt_job_resolve_t *jbr)
     int                 err;
     u_char              *host;
     size_t              length;
+    nxt_mp_t            *mp;
     nxt_uint_t          n;
-    nxt_mem_pool_t      *mp;
     nxt_sockaddr_t      *sa;
     struct addrinfo     hint, *res, *r;
     nxt_work_handler_t  handler;
@@ -31,7 +31,7 @@ nxt_job_resolve(nxt_job_resolve_t *jbr)
         host = buf;
 
     } else {
-        host = nxt_mem_alloc(jbr->job.mem_pool, length);
+        host = nxt_mp_alloc(jbr->job.mem_pool, length);
         if (nxt_slow_path(host == NULL)) {
             goto fail;
         }
@@ -70,7 +70,7 @@ nxt_job_resolve(nxt_job_resolve_t *jbr)
     jbr->count = n;
     mp = jbr->job.mem_pool;
 
-    jbr->sockaddrs = nxt_mem_alloc(mp, n * sizeof(nxt_sockaddr_t *));
+    jbr->sockaddrs = nxt_mp_alloc(mp, n * sizeof(nxt_sockaddr_t *));
     if (nxt_slow_path(jbr->sockaddrs == NULL)) {
         goto fail;
     }
@@ -124,5 +124,9 @@ fail:
         freeaddrinfo(res);
     }
 
+    if (host != buf) {
+        nxt_mp_free(jbr->job.mem_pool, host);
+    }
+
     nxt_job_return(jbr->job.task, &jbr->job, handler);
 }
diff --git a/src/nxt_list.c b/src/nxt_list.c
index 6ba7c9fa..9a44ce9a 100644
--- a/src/nxt_list.c
+++ b/src/nxt_list.c
@@ -8,11 +8,11 @@
 
 
 nxt_list_t *
-nxt_list_create(nxt_mem_pool_t *mp, nxt_uint_t n, size_t size)
+nxt_list_create(nxt_mp_t *mp, nxt_uint_t n, size_t size)
 {
     nxt_list_t  *list;
 
-    list = nxt_mem_alloc(mp, sizeof(nxt_list_t) + n * size);
+    list = nxt_mp_get(mp, sizeof(nxt_list_t) + n * size);
 
     if (nxt_fast_path(list != NULL)) {
         list->last = &list->part;
@@ -39,8 +39,8 @@ nxt_list_add(nxt_list_t *list)
 
         /* The last list part is filled up, allocating a new list part. */
 
-        last = nxt_mem_alloc(list->mem_pool,
-                       sizeof(nxt_list_part_t) + list->nalloc * list->size);
+        last = nxt_mp_get(list->mem_pool,
+                          sizeof(nxt_list_part_t) + list->nalloc * list->size);
 
         if (nxt_slow_path(last == NULL)) {
             return NULL;
diff --git a/src/nxt_list.h b/src/nxt_list.h
index 4b314360..39ad2742 100644
--- a/src/nxt_list.h
+++ b/src/nxt_list.h
@@ -25,7 +25,7 @@ typedef struct {
     uint16_t                    size;
     uint16_t                    nalloc;
 #endif
-    nxt_mem_pool_t              *mem_pool;
+    nxt_mp_t                    *mem_pool;
     nxt_list_part_t             part;
 } nxt_list_t;
 
@@ -94,8 +94,7 @@ nxt_list_elt(nxt_list_t *list, nxt_uint_t n)
     } while (0)
 
 
-NXT_EXPORT nxt_list_t *nxt_list_create(nxt_mem_pool_t *mp, nxt_uint_t n,
-    size_t size);
+NXT_EXPORT nxt_list_t *nxt_list_create(nxt_mp_t *mp, nxt_uint_t n, size_t size);
 NXT_EXPORT void *nxt_list_add(nxt_list_t *list);
 NXT_EXPORT void *nxt_list_zero_add(nxt_list_t *list);
 
diff --git a/src/nxt_listen_socket.c b/src/nxt_listen_socket.c
index 7a0e3a7c..56bff6ea 100644
--- a/src/nxt_listen_socket.c
+++ b/src/nxt_listen_socket.c
@@ -240,7 +240,7 @@ nxt_listen_socket_pool_min_size(nxt_listen_socket_t *ls)
 
 #endif
 
-    return size + sizeof(nxt_mem_pool_t)
+    return size // + sizeof(nxt_mem_pool_t)
                 + sizeof(nxt_conn_t)
                 + sizeof(nxt_log_t);
 }
diff --git a/src/nxt_listen_socket.h b/src/nxt_listen_socket.h
index ce7a8aeb..907c3a6e 100644
--- a/src/nxt_listen_socket.h
+++ b/src/nxt_listen_socket.h
@@ -32,7 +32,6 @@ typedef struct {
     uint8_t                   address_length;
 
     uint32_t                  count;
-    uint32_t                  mem_pool_size;
 } nxt_listen_socket_t;
 
 
diff --git a/src/nxt_lvlhsh.c b/src/nxt_lvlhsh.c
index fc3c372b..21fda895 100644
--- a/src/nxt_lvlhsh.c
+++ b/src/nxt_lvlhsh.c
@@ -302,8 +302,7 @@ nxt_lvlhsh_new_bucket(nxt_lvlhsh_query_t *lhq, void **slot)
 {
     uint32_t  *bucket;
 
-    bucket = lhq->proto->alloc(lhq->pool, nxt_lvlhsh_bucket_size(lhq->proto),
-                               lhq->proto->nalloc);
+    bucket = lhq->proto->alloc(lhq->pool, nxt_lvlhsh_bucket_size(lhq->proto));
 
     if (nxt_fast_path(bucket != NULL)) {
 
@@ -476,7 +475,7 @@ nxt_lvlhsh_convert_bucket_to_level(nxt_lvlhsh_query_t *lhq, void **slot,
     proto = lhq->proto;
     size = nxt_lvlhsh_level_size(proto, nlvl);
 
-    lvl = proto->alloc(lhq->pool, size * (sizeof(void *)), proto->nalloc);
+    lvl = proto->alloc(lhq->pool, size * (sizeof(void *)));
 
     if (nxt_slow_path(lvl == NULL)) {
         return NXT_ERROR;
@@ -516,7 +515,7 @@ nxt_lvlhsh_convert_bucket_to_level(nxt_lvlhsh_query_t *lhq, void **slot,
 
     *slot = lvl;
 
-    proto->free(lhq->pool, bucket, nxt_lvlhsh_bucket_size(proto));
+    proto->free(lhq->pool, bucket);
 
     return NXT_OK;
 }
@@ -615,12 +614,10 @@ nxt_lvlhsh_bucket_convertion_insert(nxt_lvlhsh_query_t *lhq, void **slot,
 static nxt_int_t
 nxt_lvlhsh_free_level(nxt_lvlhsh_query_t *lhq, void **level, nxt_uint_t size)
 {
-    size_t                    bsize;
     nxt_uint_t                i;
     const nxt_lvlhsh_proto_t  *proto;
 
     proto = lhq->proto;
-    bsize = nxt_lvlhsh_bucket_size(proto);
 
     for (i = 0; i < size; i++) {
 
@@ -630,11 +627,11 @@ nxt_lvlhsh_free_level(nxt_lvlhsh_query_t *lhq, void **level, nxt_uint_t size)
              * in the worst case one bucket cannot be converted
              * in two chained buckets but remains the same bucket.
              */
-            proto->free(lhq->pool, nxt_lvlhsh_bucket(proto, level[i]), bsize);
+            proto->free(lhq->pool, nxt_lvlhsh_bucket(proto, level[i]));
         }
     }
 
-    proto->free(lhq->pool, level, size * (sizeof(void *)));
+    proto->free(lhq->pool, level);
 
     return NXT_ERROR;
 }
@@ -660,7 +657,6 @@ static nxt_int_t
 nxt_lvlhsh_level_delete(nxt_lvlhsh_query_t *lhq, void **parent, uint32_t key,
     nxt_uint_t nlvl)
 {
-    size_t      size;
     void        **slot, **lvl;
     uintptr_t   mask;
     nxt_int_t   ret;
@@ -687,8 +683,7 @@ nxt_lvlhsh_level_delete(nxt_lvlhsh_query_t *lhq, void **parent, uint32_t key,
 
             if (nxt_lvlhsh_level_entries(*parent, mask) == 0) {
                 *parent = NULL;
-                size = nxt_lvlhsh_level_size(lhq->proto, nlvl);
-                lhq->proto->free(lhq->pool, lvl, size * sizeof(void *));
+                lhq->proto->free(lhq->pool, lvl);
             }
         }
 
@@ -703,7 +698,6 @@ static nxt_int_t
 nxt_lvlhsh_bucket_delete(nxt_lvlhsh_query_t *lhq, void **bkt)
 {
     void                      *value;
-    size_t                    size;
     uint32_t                  *bucket, *e;
     uintptr_t                 n;
     const nxt_lvlhsh_proto_t  *proto;
@@ -726,8 +720,7 @@ nxt_lvlhsh_bucket_delete(nxt_lvlhsh_query_t *lhq, void **bkt)
 
                         if (nxt_lvlhsh_bucket_entries(proto, *bkt) == 1) {
                             *bkt = *nxt_lvlhsh_next_bucket(proto, bucket);
-                            size = nxt_lvlhsh_bucket_size(proto);
-                            proto->free(lhq->pool, bucket, size);
+                            proto->free(lhq->pool, bucket);
 
                         } else {
                             nxt_lvlhsh_count_dec(*bkt);
@@ -877,14 +870,14 @@ nxt_lvlhsh_bucket_each(nxt_lvlhsh_each_t *lhe)
 
 
 void *
-nxt_lvlhsh_alloc(void *data, size_t size, nxt_uint_t nalloc)
+nxt_lvlhsh_alloc(void *data, size_t size)
 {
     return nxt_memalign(size, size);
 }
 
 
 void
-nxt_lvlhsh_free(void *data, void *p, size_t size)
+nxt_lvlhsh_free(void *data, void *p)
 {
     nxt_free(p);
 }
diff --git a/src/nxt_lvlhsh.h b/src/nxt_lvlhsh.h
index f1ddf53d..01014124 100644
--- a/src/nxt_lvlhsh.h
+++ b/src/nxt_lvlhsh.h
@@ -11,8 +11,8 @@
 typedef struct nxt_lvlhsh_query_s  nxt_lvlhsh_query_t;
 
 typedef nxt_int_t (*nxt_lvlhsh_test_t)(nxt_lvlhsh_query_t *lhq, void *data);
-typedef void *(*nxt_lvlhsh_alloc_t)(void *ctx, size_t size, nxt_uint_t nalloc);
-typedef void (*nxt_lvlhsh_free_t)(void *ctx, void *p, size_t size);
+typedef void *(*nxt_lvlhsh_alloc_t)(void *ctx, size_t size);
+typedef void (*nxt_lvlhsh_free_t)(void *ctx, void *p);
 
 
 #if (NXT_64BIT)
@@ -73,7 +73,6 @@ typedef struct {
     uint32_t                  bucket_size;
     uint32_t                  bucket_mask;
     uint8_t                   shift[8];
-    uint32_t                  nalloc;
 
     nxt_lvlhsh_test_t         test;
     nxt_lvlhsh_alloc_t        alloc;
@@ -166,12 +165,8 @@ typedef struct {
 NXT_EXPORT void *nxt_lvlhsh_each(nxt_lvlhsh_t *lh, nxt_lvlhsh_each_t *le);
 
 
-NXT_EXPORT void *nxt_lvlhsh_alloc(void *data, size_t size, nxt_uint_t nalloc);
-NXT_EXPORT void nxt_lvlhsh_free(void *data, void *p, size_t size);
-
-NXT_EXPORT void *nxt_lvlhsh_pool_alloc(void *ctx, size_t size,
-    nxt_uint_t nalloc);
-NXT_EXPORT void nxt_lvlhsh_pool_free(void *ctx, void *p, size_t size);
+NXT_EXPORT void *nxt_lvlhsh_alloc(void *data, size_t size);
+NXT_EXPORT void nxt_lvlhsh_free(void *data, void *p);
 
 
 #endif /* _NXT_LEVEL_HASH_H_INCLUDED_ */
diff --git a/src/nxt_lvlhsh_pool.c b/src/nxt_lvlhsh_pool.c
deleted file mode 100644
index 5de319f9..00000000
--- a/src/nxt_lvlhsh_pool.c
+++ /dev/null
@@ -1,153 +0,0 @@
-
-/*
- * Copyright (C) Igor Sysoev
- * Copyright (C) NGINX, Inc.
- */
-
-#include <nxt_main.h>
-
-
-typedef struct nxt_lvlhsh_pool_cache_s  nxt_lvlhsh_pool_cache_t;
-
-struct nxt_lvlhsh_pool_cache_s {
-    uint32_t                 size;
-    uint32_t                 nalloc;
-    void                     *free;
-    nxt_lvlhsh_pool_cache_t  *next;
-};
-
-
-typedef struct {
-    nxt_mem_pool_t           *mem_pool;
-    void                     *free;
-    nxt_lvlhsh_pool_cache_t  *next;
-} nxt_lvlhsh_pool_t;
-
-
-/*
- * lvlhsh requires allocations aligned to a size of the allocations.
- * This is not issue for slab-like allocators, but glibc allocator may
- * waste memory on such aligned allocations.  So nxt_lvlhsh_pool_alloc()
- * allocates memory in chunks specified by the "nalloc" parameter
- * except the first allocation.  The first lvlhsh allocation is a bucket
- * allocation and it is enough for a small hash or for early stage of
- * a large hash.  By default lvlhsh uses 128-bytes or 64-bytes buckets
- * and levels on 64-bit and 32-bit platforms respectively.
- * This allows to search up to 10 entries in one memory access and
- * up to 160 entries in two memory accesses on 64-bit platform.
- * And on 32-bit platform up to 7 entries and up to 112 entries
- * respectively.
- *
- * After the bucket has been filled up with 10 64-bit entries
- * or 7 32-bit entries, lvlhsh expands it to a level and spreads
- * content of the first bucket to the level's new buckets.
- * Number of the new allocations may be up to 11 on 64-bit or
- * 8 on 32-bit platforms.  It's better to allocate them together
- * to eliminate wasting memory and CPU time.
- *
- * The "nalloc" should be 16.
- */
-
-
-static void *nxt_lvlhsh_pool_alloc_chunk(nxt_mem_pool_cache_t *cache,
-    size_t size, nxt_uint_t nalloc);
-
-
-/* Allocation of lvlhsh level or bucket with specified size. */
-
-void *
-nxt_lvlhsh_pool_alloc(void *ctx, size_t size, nxt_uint_t nalloc)
-{
-    void                  *p, **pp;
-    nxt_mem_pool_t        *mp;
-    nxt_mem_pool_cache_t  *cache;
-
-    mp = ctx;
-
-    for (cache = mp->cache; cache != NULL; cache = cache->next) {
-
-        if (cache->size == size && cache->nalloc != 0) {
-
-            if (cache->free != NULL) {
-                pp = cache->free;
-                cache->free = *pp;
-                return pp;
-            }
-
-            return nxt_lvlhsh_pool_alloc_chunk(cache, size, nalloc);
-        }
-    }
-
-    cache = nxt_mem_alloc(mp, sizeof(nxt_mem_pool_cache_t));
-
-    if (nxt_fast_path(cache != NULL)) {
-
-        p = nxt_memalign(size, size);
-
-        if (nxt_fast_path(p != NULL)) {
-            cache->size = size;
-            cache->nalloc = nalloc;
-            cache->free = NULL;
-            cache->next = mp->cache;
-            mp->cache = cache;
-            return p;
-        }
-    }
-
-    return NULL;
-}
-
-
-static void *
-nxt_lvlhsh_pool_alloc_chunk(nxt_mem_pool_cache_t *cache, size_t size,
-    nxt_uint_t nalloc)
-{
-    char    *m, *p, *end;
-    void    **pp;
-    size_t  n;
-
-    n = (nalloc == 0) ? 1 : nalloc;
-    n *= size;
-
-    m = nxt_memalign(size, n);
-
-    if (nxt_fast_path(m != NULL)) {
-
-        pp = &cache->free;
-        end = m + n;
-
-        for (p = m + size; p < end; p = p + size) {
-            *pp = p;
-            pp = (void **) p;
-        }
-
-        *pp = NULL;
-    }
-
-    return m;
-}
-
-
-
-/* Deallocation of lvlhsh level or bucket with specified size. */
-
-void
-nxt_lvlhsh_pool_free(void *ctx, void *p, size_t size)
-{
-    void                  **pp;
-    nxt_mem_pool_t        *mp;
-    nxt_mem_pool_cache_t  *cache;
-
-    mp = ctx;
-
-    pp = p;
-
-    for (cache = mp->cache; cache != NULL; cache = cache->next) {
-
-        if (cache->size == size && cache->nalloc != 0) {
-            *pp = cache->free;
-            cache->free = p;
-            return;
-        }
-    }
-}
diff --git a/src/nxt_main.h b/src/nxt_main.h
index a7fa2355..d1230f71 100644
--- a/src/nxt_main.h
+++ b/src/nxt_main.h
@@ -14,8 +14,7 @@
 #include <nxt_clang.h>
 #include <nxt_types.h>
 #include <nxt_time.h>
-
-typedef struct nxt_mem_pool_s        nxt_mem_pool_t;
+#include <nxt_mp.h>
 #include <nxt_array.h>
 
 typedef struct nxt_port_s            nxt_port_t;
@@ -32,8 +31,6 @@ typedef uint16_t                     nxt_port_id_t;
 typedef struct nxt_thread_s          nxt_thread_t;
 #include <nxt_thread_id.h>
 
-#include <nxt_mem_pool.h>
-
 #include <nxt_errno.h>
 #include <nxt_file.h>
 
@@ -76,9 +73,7 @@ typedef struct {
 } nxt_mem_proto_t;
 
 
-#include <nxt_mp.h>
 #include <nxt_mem_zone.h>
-#include <nxt_mem_pool_cleanup.h>
 #include <nxt_thread_time.h>
 
 typedef struct nxt_event_engine_s    nxt_event_engine_t;
diff --git a/src/nxt_master_process.c b/src/nxt_master_process.c
index ed39130b..218aff5e 100644
--- a/src/nxt_master_process.c
+++ b/src/nxt_master_process.c
@@ -137,7 +137,7 @@ nxt_master_start_controller_process(nxt_task_t *task, nxt_runtime_t *rt)
 {
     nxt_process_init_t  *init;
 
-    init = nxt_mem_alloc(rt->mem_pool, sizeof(nxt_process_init_t));
+    init = nxt_mp_get(rt->mem_pool, sizeof(nxt_process_init_t));
     if (nxt_slow_path(init == NULL)) {
         return NXT_ERROR;
     }
@@ -158,7 +158,7 @@ nxt_master_start_router_process(nxt_task_t *task, nxt_runtime_t *rt)
 {
     nxt_process_init_t  *init;
 
-    init = nxt_mem_alloc(rt->mem_pool, sizeof(nxt_process_init_t));
+    init = nxt_mp_get(rt->mem_pool, sizeof(nxt_process_init_t));
     if (nxt_slow_path(init == NULL)) {
         return NXT_ERROR;
     }
@@ -181,7 +181,7 @@ nxt_master_start_worker_processes(nxt_task_t *task, nxt_runtime_t *rt)
     nxt_uint_t          n;
     nxt_process_init_t  *init;
 
-    init = nxt_mem_alloc(rt->mem_pool, sizeof(nxt_process_init_t));
+    init = nxt_mp_get(rt->mem_pool, sizeof(nxt_process_init_t));
     if (nxt_slow_path(init == NULL)) {
         return NXT_ERROR;
     }
@@ -331,17 +331,17 @@ nxt_master_process_sigquit_handler(nxt_task_t *task, void *obj, void *data)
 static void
 nxt_master_process_sigusr1_handler(nxt_task_t *task, void *obj, void *data)
 {
+    nxt_mp_t        *mp;
     nxt_int_t       ret;
     nxt_uint_t      n;
     nxt_file_t      *file, *new_file;
     nxt_runtime_t   *rt;
     nxt_array_t     *new_files;
-    nxt_mem_pool_t  *mp;
 
     nxt_log(task, NXT_LOG_NOTICE, "signal %d (%s) recevied, %s",
             (int) (uintptr_t) obj, data, "log files rotation");
 
-    mp = nxt_mem_pool_create(1024);
+    mp = nxt_mp_create(1024, 128, 256, 32);
     if (mp == NULL) {
         return;
     }
@@ -352,7 +352,7 @@ nxt_master_process_sigusr1_handler(nxt_task_t *task, void *obj, void *data)
 
     new_files = nxt_array_create(mp, n, sizeof(nxt_file_t));
     if (new_files == NULL) {
-        nxt_mem_pool_destroy(mp);
+        nxt_mp_destroy(mp);
         return;
     }
 
@@ -396,7 +396,7 @@ nxt_master_process_sigusr1_handler(nxt_task_t *task, void *obj, void *data)
 
         } nxt_list_loop;
 
-        nxt_mem_pool_destroy(mp);
+        nxt_mp_destroy(mp);
         return;
    }
 
@@ -414,7 +414,7 @@ fail:
         n--;
     }
 
-    nxt_mem_pool_destroy(mp);
+    nxt_mp_destroy(mp);
 }
 
 
diff --git a/src/nxt_mem_pool.c b/src/nxt_mem_pool.c
deleted file mode 100644
index 7817bac7..00000000
--- a/src/nxt_mem_pool.c
+++ /dev/null
@@ -1,644 +0,0 @@
-
-/*
- * Copyright (C) Igor Sysoev
- * Copyright (C) NGINX, Inc.
- */
-
-#include <nxt_main.h>
-
-
-/*
- * The pool allocator provides cheap allocation of small objects.
- * The objects are allocated from larger preallocated chunks.
- *
- *   aligned and non-aligned allocations,
- *   cache of reusable objects, lvlhsh-specific cache
- *   eliminating align padding
- *   data locality
- *   freeing on pool destruction
- *   freeing large allocations
- */
-
-
-static void *nxt_mem_pool_align(nxt_mem_pool_t *mp, size_t alignment,
-    size_t size);
-static void *nxt_mem_pool_ext(nxt_mem_pool_t *mp, size_t size);
-static nxt_mem_pool_chunk_t *nxt_mem_pool_next_chunk(nxt_mem_pool_t *mp,
-    nxt_mem_pool_chunk_t *chunk);
-static nxt_mem_pool_chunk_t *nxt_mem_pool_chunk(nxt_mem_pool_t *mp);
-static void *nxt_mem_lvlhsh_alloc_chunk(nxt_mem_pool_cache_t *cache,
-    size_t size, nxt_uint_t nalloc);
-
-
-#if (NXT_DEBUG)
-
-static nxt_bool_t
-nxt_mem_pool_thread_is_invalid(nxt_mem_pool_t *mp)
-{
-    nxt_tid_t     tid;
-    nxt_thread_t  *thr;
-
-    thr = nxt_thread();
-    tid = nxt_thread_tid(thr);
-
-    if (nxt_slow_path(mp->tid != tid)) {
-
-        if (mp->pid == nxt_pid) {
-            nxt_log_alert(thr->log, "mem_pool locked by thread %PT", mp->tid);
-            nxt_abort();
-            return 1;
-        }
-
-        mp->pid = nxt_pid;
-        mp->tid = tid;
-    }
-
-    return 0;
-}
-
-
-/* SunC does not support C99 variadic macro with empty __VA_ARGS__. */
-
-#define                                                                       \
-nxt_mem_pool_thread_assert(mp)                                                \
-    if (nxt_mem_pool_thread_is_invalid(mp))                                   \
-        return
-
-
-#define                                                                       \
-nxt_mem_pool_thread_assert_return(mp, ret)                                    \
-    if (nxt_mem_pool_thread_is_invalid(mp))                                   \
-        return ret
-
-
-#else /* !(NXT_DEBUG) */
-
-#define                                                                       \
-nxt_mem_pool_thread_assert(mp)
-
-#define                                                                       \
-nxt_mem_pool_thread_assert_return(mp, ret)
-
-#endif
-
-
-nxt_mem_pool_t *
-nxt_mem_pool_create(size_t size)
-{
-    u_char          *p;
-    size_t          min_ext_size;
-    nxt_mem_pool_t  *mp;
-
-    mp = nxt_malloc(size);
-
-    if (nxt_fast_path(mp != NULL)) {
-
-        mp->chunk_size = (uint32_t) size;
-
-        min_ext_size = size - sizeof(nxt_mem_pool_t) + 1;
-        mp->min_ext_size = (uint32_t) nxt_min(min_ext_size,
-                                              NXT_MEM_POOL_MIN_EXT_SIZE);
-
-        nxt_malloc_usable_size(mp, size);
-
-        p = (u_char *) mp;
-
-        mp->chunk.free = p + sizeof(nxt_mem_pool_t);
-        mp->chunk.end = p + size;
-        mp->chunk.next = NULL;
-        mp->chunk.fails = 0;
-
-        mp->current = &mp->chunk;
-        mp->ext = NULL;
-        mp->cleanup = NULL;
-        mp->cache = NULL;
-
-        nxt_thread_log_debug("mem pool chunk size:%uz avail:%uz",
-                             size, mp->chunk.end - mp->chunk.free);
-
-        nxt_mem_pool_debug_lock(mp, nxt_thread_tid(NULL));
-    }
-
-    return mp;
-}
-
-
-void
-nxt_mem_pool_destroy(nxt_mem_pool_t *mp)
-{
-    nxt_task_t              *task;
-    nxt_mem_pool_ext_t      *ext;
-    nxt_mem_pool_chunk_t    *chunk, *next;
-    nxt_mem_pool_cleanup_t  *mpcl;
-
-    task = NULL;
-
-    nxt_mem_pool_thread_assert(mp);
-
-    for (mpcl = mp->cleanup; mpcl != NULL; mpcl = mpcl->next) {
-        if (mpcl->handler != NULL) {
-            nxt_thread_log_debug("mem pool cleanup: %p", mpcl);
-            mpcl->handler(task, mpcl->data);
-        }
-    }
-
-    for (ext = mp->ext; ext != NULL; ext = ext->next) {
-        if (ext->data != NULL) {
-            nxt_free(ext->data);
-        }
-    }
-
-    chunk = &mp->chunk;
-
-    do {
-        nxt_thread_log_debug("mem pool chunk fails:%uD unused:%uz",
-                             chunk->fails, chunk->end - chunk->free);
-        next = chunk->next;
-        nxt_free(chunk);
-        chunk = next;
-
-    } while (chunk != NULL);
-}
-
-
-void *
-nxt_mem_align(nxt_mem_pool_t *mp, size_t alignment, size_t size)
-{
-    nxt_mem_pool_thread_assert_return(mp, NULL);
-
-    if (nxt_fast_path(size < mp->min_ext_size)) {
-        return nxt_mem_pool_align(mp, alignment, size);
-    }
-
-    return nxt_mem_pool_ext(mp, size);
-}
-
-
-void *
-nxt_mem_zalign(nxt_mem_pool_t *mp, size_t alignment, size_t size)
-{
-    void  *p;
-
-    p = nxt_mem_align(mp, alignment, size);
-
-    if (nxt_fast_path(p != NULL)) {
-        nxt_memzero(p, size);
-    }
-
-    return p;
-}
-
-
-/*
- * Zero-filled aligned allocation, suitable for struct
- * allocation without long double and SIMD values.
- */
-
-void *
-nxt_mem_zalloc(nxt_mem_pool_t *mp, size_t size)
-{
-    void  *p;
-
-    p = nxt_mem_alloc(mp, size);
-
-    if (nxt_fast_path(p != NULL)) {
-        nxt_memzero(p, size);
-    }
-
-    return p;
-}
-
-
-void *
-nxt_mem_buf(nxt_mem_pool_t *mp, size_t *sizep, nxt_uint_t flags)
-{
-    u_char  *p;
-    size_t  size;
-
-    nxt_mem_pool_thread_assert_return(mp, NULL);
-
-    size = *sizep;
-
-    if (nxt_fast_path(size >= mp->min_ext_size)) {
-
-        nxt_malloc_cutback(flags & NXT_MEM_BUF_CUTBACK, size);
-
-        /* Windows only: try to minimize number of allocated pages. */
-        p = nxt_mem_pool_ext(mp, size);
-        if (p != NULL) {
-
-            if (flags & NXT_MEM_BUF_USABLE) {
-                nxt_malloc_usable_size(p, size);
-            }
-
-            *sizep = size;
-        }
-
-        return p;
-    }
-
-    return nxt_mem_pool_align(mp, NXT_ALIGNMENT, size);
-}
-
-
-/* Non-aligned allocation, suitable for string allocation. */
-
-void *
-nxt_mem_nalloc(nxt_mem_pool_t *mp, size_t size)
-{
-    u_char                *p;
-    nxt_mem_pool_chunk_t  *chunk;
-
-    nxt_mem_pool_thread_assert_return(mp, NULL);
-
-    if (nxt_slow_path(size >= mp->min_ext_size)) {
-        return nxt_mem_pool_ext(mp, size);
-    }
-
-    chunk = mp->current;
-
-    for ( ;; ) {
-        p = chunk->end - size;
-
-        if (nxt_fast_path(p >= chunk->free)) {
-            chunk->end = p;
-            return p;
-        }
-
-        chunk = nxt_mem_pool_next_chunk(mp, chunk);
-
-        if (nxt_slow_path(chunk == NULL)) {
-            return NULL;
-        }
-    }
-}
-
-
-/* An attempt to deallocate a large allocation outside pool. */
-
-nxt_int_t
-nxt_mem_free(nxt_mem_pool_t *mp, void *p)
-{
-    nxt_mem_pool_ext_t  *ext;
-
-    nxt_mem_pool_thread_assert_return(mp, NXT_DECLINED);
-
-    for (ext = mp->ext; ext != NULL; ext = ext->next) {
-
-        if (p == ext->data) {
-            nxt_free(ext->data);
-            ext->data = NULL;
-
-            return NXT_OK;
-        }
-    }
-
-    return NXT_DECLINED;
-}
-
-
-static void *
-nxt_mem_pool_ext(nxt_mem_pool_t *mp, size_t size)
-{
-    void                *p;
-    nxt_mem_pool_ext_t  *ext;
-
-    ext = nxt_mem_pool_align(mp, sizeof(void *), sizeof(nxt_mem_pool_ext_t));
-
-    if (nxt_fast_path(ext != NULL)) {
-        p = nxt_malloc(size);
-
-        if (nxt_fast_path(p != NULL)) {
-            ext->data = p;
-            ext->next = mp->ext;
-            mp->ext = ext;
-
-            return p;
-        }
-    }
-
-    return NULL;
-}
-
-
-static void *
-nxt_mem_pool_align(nxt_mem_pool_t *mp, size_t alignment, size_t size)
-{
-    u_char                *p, *f;
-    nxt_mem_pool_chunk_t  *chunk;
-
-    chunk = mp->current;
-
-    for ( ;; ) {
-
-        p = nxt_align_ptr(chunk->free, alignment);
-        f = p + size;
-
-        if (nxt_fast_path(f <= chunk->end)) {
-            chunk->free = f;
-            return p;
-        }
-
-        chunk = nxt_mem_pool_next_chunk(mp, chunk);
-
-        if (nxt_slow_path(chunk == NULL)) {
-            return NULL;
-        }
-    }
-}
-
-
-static nxt_mem_pool_chunk_t *
-nxt_mem_pool_next_chunk(nxt_mem_pool_t *mp, nxt_mem_pool_chunk_t *chunk)
-{
-    nxt_bool_t  full;
-
-    full = (chunk->free == chunk->end || chunk->fails++ > 10);
-
-    chunk = chunk->next;
-
-    if (chunk == NULL) {
-        chunk = nxt_mem_pool_chunk(mp);
-
-        if (nxt_slow_path(chunk == NULL)) {
-            return NULL;
-        }
-    }
-
-    if (full) {
-        mp->current = chunk;
-    }
-
-    return chunk;
-}
-
-
-static nxt_mem_pool_chunk_t *
-nxt_mem_pool_chunk(nxt_mem_pool_t *mp)
-{
-    u_char                *p;
-    size_t                size;
-    nxt_mem_pool_chunk_t  *ch, *chunk;
-
-    size = mp->chunk_size;
-
-    chunk = nxt_malloc(size);
-
-    if (nxt_fast_path(chunk != NULL)) {
-
-        nxt_malloc_usable_size(chunk, size);
-
-        p = (u_char *) chunk;
-
-        chunk->free = p + sizeof(nxt_mem_pool_chunk_t);
-        chunk->end = p + size;
-        chunk->next = NULL;
-        chunk->fails = 0;
-
-        for (ch = mp->current; ch->next; ch = ch->next) { /* void */ }
-
-        ch->next = chunk;
-    }
-
-    return chunk;
-}
-
-
-nxt_mem_pool_cleanup_t *
-nxt_mem_pool_cleanup(nxt_mem_pool_t *mp, size_t size)
-{
-    nxt_mem_pool_cleanup_t  *mpcl;
-
-    nxt_mem_pool_thread_assert_return(mp, NULL);
-
-    mpcl = nxt_mem_pool_align(mp, sizeof(void *),
-                              sizeof(nxt_mem_pool_cleanup_t));
-    if (nxt_fast_path(mpcl != NULL)) {
-
-        mpcl->handler = NULL;
-        mpcl->data = NULL;
-
-        if (size != 0) {
-            mpcl->data = nxt_mem_alloc(mp, size);
-            if (nxt_slow_path(mpcl->data == NULL)) {
-                return NULL;
-            }
-        }
-
-        mpcl->next = mp->cleanup;
-        mp->cleanup = mpcl;
-
-        nxt_thread_log_debug("mem pool cleanup add: %p", mpcl);
-    }
-
-    return mpcl;
-}
-
-
-/* Allocation of reusable object with specified size. */
-
-void *
-nxt_mem_cache_alloc0(nxt_mem_pool_t *mp, size_t size)
-{
-    void                  **pp;
-    nxt_mem_pool_cache_t  *cache;
-
-    nxt_mem_pool_thread_assert_return(mp, NULL);
-
-    for (cache = mp->cache; cache != NULL; cache = cache->next) {
-
-        if (cache->size == size && cache->nalloc == 0) {
-
-            if (cache->free != NULL) {
-                pp = cache->free;
-                cache->free = *pp;
-                return pp;
-            }
-
-            break;
-        }
-    }
-
-    return nxt_mem_alloc(mp, size);
-}
-
-
-void *
-nxt_mem_cache_zalloc0(nxt_mem_pool_t *mp, size_t size)
-{
-    void  *p;
-
-    p = nxt_mem_cache_alloc0(mp, size);
-
-    if (nxt_fast_path(p != NULL)) {
-        nxt_memzero(p, size);
-    }
-
-    return p;
-}
-
-
-/* Deallocation of reusable object with specified size. */
-
-void
-nxt_mem_cache_free0(nxt_mem_pool_t *mp, void *p, size_t size)
-{
-    void                  **pp;
-    nxt_mem_pool_cache_t  *cache, **pcache;
-
-    nxt_mem_pool_thread_assert(mp);
-
-    pp = p;
-
-    pcache = &mp->cache;
-    for (cache = mp->cache; cache != NULL; cache = cache->next) {
-
-        if (cache->size == size && cache->nalloc == 0) {
-            *pp = cache->free;
-            cache->free = p;
-            return;
-        }
-
-        pcache = &cache->next;
-    }
-
-    /* Non-lvlhash caches are created only on return. */
-
-    cache = nxt_mem_pool_align(mp, sizeof(void *),
-                               sizeof(nxt_mem_pool_cache_t));
-    if (nxt_fast_path(cache != NULL)) {
-        *pp = NULL;
-        cache->size = (uint32_t) size;
-        cache->nalloc = 0;
-        cache->free = p;
-        cache->next = NULL;
-        *pcache = cache;
-    }
-}
-
-
-/*
- * lvlhsh requires allocations aligned to a size of the allocations.
- * This is not issue for slab-like allocators, but glibc allocator may
- * waste memory on such aligned allocations.  So nxt_mem_lvlhsh_alloc()
- * allocates memory in chunks specified by the "nalloc" parameter
- * except the first allocation.  The first lvlhsh allocation is a bucket
- * allocation and it is enough for small hashes and for early stage
- * of a hash.  By default lvlhsh uses 128-bytes buckets and levels.
- * This allows to search up to 10 entries in one memory access and
- * up to 160 entries in two memory accesses on 64-bit platform.
- * And on 32-bit platform up to 15 entries and up to 480 entries
- * respectively.
- *
- * After the bucket will be filled up with 10 64-bit entries or 15
- * 32-bit entries, lvlhsh will expand it to a level and content
- * of the first bucket will spread to the level's new buckets.
- * Number of the new buckets may be up to 11 on 64-bit or 16 on 32-bit
- * platforms.  It's better to allocate them together to eliminate
- * wasting memory and CPU time.
- *
- * The "nalloc" should be 16 if bucket size is 128 bytes.
- */
-
-
-/* Allocation of lvlhsh level or bucket with specified size. */
-
-void *
-nxt_mem_lvlhsh_alloc(void *ctx, size_t size, nxt_uint_t nalloc)
-{
-    void                  *p, **pp;
-    nxt_mem_pool_t        *mp;
-    nxt_mem_pool_cache_t  *cache;
-
-    mp = ctx;
-
-    nxt_mem_pool_thread_assert_return(mp, NULL);
-
-    for (cache = mp->cache; cache != NULL; cache = cache->next) {
-
-        if (cache->size == size && cache->nalloc != 0) {
-
-            if (cache->free != NULL) {
-                pp = cache->free;
-                cache->free = *pp;
-                return pp;
-            }
-
-            return nxt_mem_lvlhsh_alloc_chunk(cache, size, nalloc);
-        }
-    }
-
-    cache = nxt_mem_pool_align(mp, sizeof(void *),
-                               sizeof(nxt_mem_pool_cache_t));
-    if (nxt_fast_path(cache != NULL)) {
-
-        p = nxt_memalign(size, size);
-
-        if (nxt_fast_path(p != NULL)) {
-            cache->size = (uint32_t) size;
-            cache->nalloc = nalloc;
-            cache->free = NULL;
-            cache->next = mp->cache;
-            mp->cache = cache;
-            return p;
-        }
-    }
-
-    return NULL;
-}
-
-
-static void *
-nxt_mem_lvlhsh_alloc_chunk(nxt_mem_pool_cache_t *cache, size_t size,
-    nxt_uint_t nalloc)
-{
-    char    *m, *p, *end;
-    void    **pp;
-    size_t  n;
-
-    n = (nalloc == 0) ? 1 : nalloc;
-    n *= size;
-
-    m = nxt_memalign(size, n);
-
-    if (nxt_fast_path(m != NULL)) {
-
-        pp = &cache->free;
-        end = m + n;
-
-        for (p = m + size; p < end; p = p + size) {
-            *pp = p;
-            pp = (void **) p;
-        }
-
-        *pp = NULL;
-    }
-
-    return m;
-}
-
-
-/* Deallocation of lvlhsh level or bucket with specified size. */
-
-void
-nxt_mem_lvlhsh_free(void *ctx, void *p, size_t size)
-{
-    void                  **pp;
-    nxt_mem_pool_t        *mp;
-    nxt_mem_pool_cache_t  *cache;
-
-    mp = ctx;
-
-    nxt_mem_pool_thread_assert(mp);
-
-    pp = p;
-
-    for (cache = mp->cache; cache != NULL; cache = cache->next) {
-
-        if (cache->size == size && cache->nalloc != 0) {
-            *pp = cache->free;
-            cache->free = p;
-            return;
-        }
-    }
-}
diff --git a/src/nxt_mem_pool.h b/src/nxt_mem_pool.h
deleted file mode 100644
index a896956c..00000000
--- a/src/nxt_mem_pool.h
+++ /dev/null
@@ -1,150 +0,0 @@
-
-/*
- * Copyright (C) Igor Sysoev
- * Copyright (C) NGINX, Inc.
- */
-
-#ifndef _NXT_MEM_POOL_H_INCLUDED_
-#define _NXT_MEM_POOL_H_INCLUDED_
-
-
-#define NXT_MEM_POOL_MIN_EXT_SIZE      nxt_pagesize
-
-
-typedef void (*nxt_mem_pool_cleanup_handler_t)(nxt_task_t *task, void *data);
-typedef struct nxt_mem_pool_cleanup_s  nxt_mem_pool_cleanup_t;
-typedef struct nxt_mem_pool_cache_s    nxt_mem_pool_cache_t;
-typedef struct nxt_mem_pool_chunk_s    nxt_mem_pool_chunk_t;
-typedef struct nxt_mem_pool_ext_s      nxt_mem_pool_ext_t;
-
-
-struct nxt_mem_pool_cleanup_s {
-    nxt_mem_pool_cleanup_handler_t     handler;
-    void                               *data;
-    nxt_mem_pool_cleanup_t             *next;
-};
-
-
-struct nxt_mem_pool_ext_s {
-    void                               *data;
-    nxt_mem_pool_ext_t                 *next;
-};
-
-
-struct nxt_mem_pool_chunk_s {
-    u_char                             *free;
-    u_char                             *end;
-    nxt_mem_pool_chunk_t               *next;
-    uint32_t                           fails;  /* 8 bits */
-};
-
-
-struct nxt_mem_pool_cache_s {
-    uint32_t                           size;
-    uint32_t                           nalloc;
-    void                               *free;
-    nxt_mem_pool_cache_t               *next;
-};
-
-
-struct nxt_mem_pool_s {
-    nxt_mem_pool_chunk_t               chunk;
-    uint32_t                           min_ext_size;
-    uint32_t                           chunk_size;
-    nxt_mem_pool_chunk_t               *current;
-    nxt_mem_pool_ext_t                 *ext;
-    nxt_mem_pool_cache_t               *cache;
-    nxt_mem_pool_cleanup_t             *cleanup;
-
-#if (NXT_DEBUG)
-    nxt_pid_t                          pid;
-    nxt_tid_t                          tid;
-#endif
-};
-
-
-NXT_EXPORT nxt_mem_pool_t *nxt_mem_pool_create(size_t size)
-    NXT_MALLOC_LIKE;
-NXT_EXPORT void nxt_mem_pool_destroy(nxt_mem_pool_t *mp);
-
-
-/*
- * Generic aligned allocation, suitable for struct allocations
- * without "long double" and SIMD values.
- */
-#define                                                                       \
-nxt_mem_alloc(mp, size)                                                       \
-    nxt_mem_align((mp), NXT_ALIGNMENT, (size))
-
-
-NXT_EXPORT void *nxt_mem_align(nxt_mem_pool_t *mp, size_t alignment,
-    size_t size)
-    NXT_MALLOC_LIKE;
-
-NXT_EXPORT void *nxt_mem_zalign(nxt_mem_pool_t *mp, size_t alignment,
-    size_t size)
-    NXT_MALLOC_LIKE;
-
-NXT_EXPORT void *nxt_mem_nalloc(nxt_mem_pool_t *mp, size_t size)
-    NXT_MALLOC_LIKE;
-
-NXT_EXPORT void *nxt_mem_zalloc(nxt_mem_pool_t *mp, size_t size)
-    NXT_MALLOC_LIKE;
-
-
-/*
- * nxt_mem_buf() is intended to allocate I/O buffers.
- * Unix network buffers usually have no size restrictions, so
- * NXT_MEM_BUF_CUTBACK and NXT_MEM_BUF_USABLE options allow to
- * utilize better allocated memory (details in unix/nxt_malloc.h).
- * Windows locks buffers in kernel memory on page basis for both
- * network and file operations, so nxt_mem_buf() should minimize
- * number of allocated pages.  However, these allocations are not
- * necessary page-aligned.
- */
-#define NXT_MEM_BUF_CUTBACK  1
-#define NXT_MEM_BUF_USABLE   2
-
-NXT_EXPORT void *nxt_mem_buf(nxt_mem_pool_t *mp, size_t *sizep,
-    nxt_uint_t flags);
-
-
-/*
- * Aligned allocation, suitable for generic allocations compatible
- * with malloc() alignment.
- */
-#define                                                                       \
-nxt_mem_malloc(mp, size)                                                      \
-    nxt_mem_align((mp), NXT_MAX_ALIGNMENT, (size))
-
-
-NXT_EXPORT nxt_int_t nxt_mem_free(nxt_mem_pool_t *mp, void *p);
-NXT_EXPORT nxt_mem_pool_cleanup_t *nxt_mem_pool_cleanup(nxt_mem_pool_t *mp,
-    size_t size);
-
-NXT_EXPORT void *nxt_mem_cache_alloc0(nxt_mem_pool_t *mp, size_t size)
-    NXT_MALLOC_LIKE;
-NXT_EXPORT void *nxt_mem_cache_zalloc0(nxt_mem_pool_t *mp, size_t size)
-    NXT_MALLOC_LIKE;
-NXT_EXPORT void nxt_mem_cache_free0(nxt_mem_pool_t *mp, void *p, size_t size);
-
-NXT_EXPORT void *nxt_mem_lvlhsh_alloc(void *ctx, size_t size,
-    nxt_uint_t nalloc);
-NXT_EXPORT void nxt_mem_lvlhsh_free(void *ctx, void *p, size_t size);
-
-
-#if (NXT_DEBUG)
-
-#define                                                                       \
-nxt_mem_pool_debug_lock(_mp, _tid)                                            \
-    (_mp->tid) = _tid
-
-#else
-
-#define                                                                       \
-nxt_mem_pool_debug_lock(_mp, _tid)
-
-#endif
-
-
-#endif /* _NXT_MEM_POOL_H_INCLUDED_ */
diff --git a/src/nxt_openssl.c b/src/nxt_openssl.c
index 66f0ad32..c5f33504 100644
--- a/src/nxt_openssl.c
+++ b/src/nxt_openssl.c
@@ -256,7 +256,7 @@ nxt_openssl_conn_init(nxt_task_t *task, nxt_ssltls_conf_t *conf, nxt_conn_t *c)
 
     nxt_log_debug(c->socket.log, "openssl conn init");
 
-    ssltls = nxt_mem_zalloc(c->mem_pool, sizeof(nxt_openssl_conn_t));
+    ssltls = nxt_mp_zget(c->mem_pool, sizeof(nxt_openssl_conn_t));
     if (ssltls == NULL) {
         goto fail;
     }
diff --git a/src/nxt_php_sapi.c b/src/nxt_php_sapi.c
index ece3ec92..147361ed 100644
--- a/src/nxt_php_sapi.c
+++ b/src/nxt_php_sapi.c
@@ -167,7 +167,7 @@ nxt_php_request_init(nxt_app_request_t *r)
 {
     nxt_php_ctx_t  *ctx;
 
-    ctx = nxt_mem_zalloc(r->mem_pool, sizeof(nxt_php_ctx_t));
+    ctx = nxt_mp_zget(r->mem_pool, sizeof(nxt_php_ctx_t));
     if (nxt_slow_path(ctx == NULL)) {
         return NXT_ERROR;
     }
@@ -261,7 +261,7 @@ nxt_php_handler(nxt_app_request_t *r)
 
 #if !ABS_MODE
     ctx->script.len = sizeof(root) - 1 + ctx->script_name_len;
-    ctx->script.data = nxt_mem_nalloc(r->mem_pool, ctx->script.len + 1);
+    ctx->script.data = nxt_mp_nget(r->mem_pool, ctx->script.len + 1);
 
     if (nxt_slow_path(ctx->script.data == NULL)) {
         return NXT_ERROR;
@@ -565,7 +565,7 @@ nxt_php_register_variables(zval *track_vars_array TSRMLS_DC)
                           ctx->content_length->len, track_vars_array TSRMLS_CC);
     }
 
-    var = nxt_mem_nalloc(r->mem_pool, sizeof(prefix) + ctx->max_name + 1);
+    var = nxt_mp_nget(r->mem_pool, sizeof(prefix) + ctx->max_name + 1);
 
     if (nxt_slow_path(var == NULL)) {
         return;
diff --git a/src/nxt_poll_engine.c b/src/nxt_poll_engine.c
index 607cd144..faf245b3 100644
--- a/src/nxt_poll_engine.c
+++ b/src/nxt_poll_engine.c
@@ -98,7 +98,6 @@ const nxt_event_interface_t  nxt_poll_engine = {
 static const nxt_lvlhsh_proto_t  nxt_poll_fd_hash_proto  nxt_aligned(64) =
 {
     NXT_LVLHSH_LARGE_MEMALIGN,
-    0,
     nxt_poll_fd_hash_test,
     nxt_lvlhsh_alloc,
     nxt_lvlhsh_free,
diff --git a/src/nxt_port.c b/src/nxt_port.c
index fc807d1f..e23db689 100644
--- a/src/nxt_port.c
+++ b/src/nxt_port.c
@@ -144,10 +144,10 @@ nxt_port_new_port_buf_completion(nxt_task_t *task, void *obj, void *data)
 void
 nxt_port_new_port_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg)
 {
+    nxt_mp_t                 *mp;
     nxt_port_t               *port;
     nxt_process_t            *process;
     nxt_runtime_t            *rt;
-    nxt_mem_pool_t           *mp;
     nxt_port_msg_new_port_t  *new_port_msg;
 
     rt = task->thread->runtime;
@@ -165,7 +165,7 @@ nxt_port_new_port_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg)
         return;
     }
 
-    mp = nxt_mem_pool_create(1024);
+    mp = nxt_mp_create(1024, 128, 256, 32);
     if (nxt_slow_path(mp == NULL)) {
         return;
     }
diff --git a/src/nxt_port.h b/src/nxt_port.h
index 76775660..28b10557 100644
--- a/src/nxt_port.h
+++ b/src/nxt_port.h
@@ -66,7 +66,7 @@ struct nxt_port_s {
     nxt_port_handler_t  handler;
     void                *data;
 
-    nxt_mem_pool_t      *mem_pool;
+    nxt_mp_t            *mem_pool;
     nxt_buf_t           *free_bufs;
     nxt_socket_t        pair[2];
 
diff --git a/src/nxt_port_memory.c b/src/nxt_port_memory.c
index 447ef138..83df9f21 100644
--- a/src/nxt_port_memory.c
+++ b/src/nxt_port_memory.c
@@ -100,9 +100,9 @@ static void
 nxt_port_mmap_buf_completion(nxt_task_t *task, void *obj, void *data)
 {
     u_char                  *p;
+    nxt_mp_t                *mp;
     nxt_buf_t               *b;
     nxt_chunk_id_t          c;
-    nxt_mem_pool_t          *mp;
     nxt_port_mmap_t         *port_mmap;
     nxt_port_mmap_header_t  *hdr;
 
@@ -448,7 +448,7 @@ nxt_port_mmap_get_buf(nxt_task_t *task, nxt_port_t *port, size_t size)
 
     nxt_debug(task, "request %z bytes shm buffer", size);
 
-    b = nxt_mem_cache_zalloc0(port->mem_pool, NXT_BUF_PORT_MMAP_SIZE);
+    b = nxt_mp_zalloc(port->mem_pool, NXT_BUF_PORT_MMAP_SIZE);
     if (nxt_slow_path(b == NULL)) {
         return NULL;
     }
@@ -508,7 +508,7 @@ nxt_port_mmap_get_incoming_buf(nxt_task_t *task, nxt_port_t *port,
     nxt_buf_t               *b;
     nxt_port_mmap_t         *port_mmap;
 
-    b = nxt_mem_cache_zalloc0(port->mem_pool, NXT_BUF_PORT_MMAP_SIZE);
+    b = nxt_mp_zalloc(port->mem_pool, NXT_BUF_PORT_MMAP_SIZE);
     if (nxt_slow_path(b == NULL)) {
         return NULL;
     }
diff --git a/src/nxt_port_socket.c b/src/nxt_port_socket.c
index 51d88ff7..4de528fd 100644
--- a/src/nxt_port_socket.c
+++ b/src/nxt_port_socket.c
@@ -19,9 +19,9 @@ static void nxt_port_error_handler(nxt_task_t *task, void *obj, void *data);
 nxt_int_t
 nxt_port_socket_init(nxt_task_t *task, nxt_port_t *port, size_t max_size)
 {
-    nxt_int_t       sndbuf, rcvbuf, size;
-    nxt_socket_t    snd, rcv;
-    nxt_mem_pool_t  *mp;
+    nxt_mp_t      *mp;
+    nxt_int_t     sndbuf, rcvbuf, size;
+    nxt_socket_t  snd, rcv;
 
     port->socket.task = task;
 
@@ -30,7 +30,7 @@ nxt_port_socket_init(nxt_task_t *task, nxt_port_t *port, size_t max_size)
 
     nxt_queue_init(&port->messages);
 
-    mp = nxt_mem_pool_create(1024);
+    mp = nxt_mp_create(1024, 128, 256, 32);
     if (nxt_slow_path(mp == NULL)) {
         return NXT_ERROR;
     }
@@ -100,7 +100,7 @@ getsockopt_fail:
 
 socketpair_fail:
 
-    nxt_mem_pool_destroy(port->mem_pool);
+    nxt_mp_destroy(port->mem_pool);
 
     return NXT_ERROR;
 }
@@ -110,7 +110,7 @@ void
 nxt_port_destroy(nxt_port_t *port)
 {
     nxt_socket_close(port->socket.task, port->socket.fd);
-    nxt_mem_pool_destroy(port->mem_pool);
+    nxt_mp_destroy(port->mem_pool);
 }
 
 
@@ -159,7 +159,7 @@ nxt_port_socket_write(nxt_task_t *task, nxt_port_t *port, nxt_uint_t type,
         }
     }
 
-    msg = nxt_mem_cache_zalloc0(port->mem_pool, sizeof(nxt_port_send_msg_t));
+    msg = nxt_mp_zalloc(port->mem_pool, sizeof(nxt_port_send_msg_t));
     if (nxt_slow_path(msg == NULL)) {
         return NXT_ERROR;
     }
@@ -289,8 +289,7 @@ nxt_port_write_handler(nxt_task_t *task, void *obj, void *data)
 
             } else {
                 nxt_queue_remove(link);
-                nxt_mem_cache_free0(port->mem_pool, msg,
-                                    sizeof(nxt_port_send_msg_t));
+                nxt_mp_free(port->mem_pool, msg);
             }
 
         } else if (nxt_slow_path(n == NXT_ERROR)) {
diff --git a/src/nxt_process.c b/src/nxt_process.c
index 64fd1f19..ac294dba 100644
--- a/src/nxt_process.c
+++ b/src/nxt_process.c
@@ -513,7 +513,7 @@ nxt_process_port_new(nxt_process_t *process)
 {
     nxt_port_t  *port;
 
-    port = nxt_mem_cache_zalloc0(process->mem_pool, sizeof(nxt_port_t));
+    port = nxt_mp_zalloc(process->mem_pool, sizeof(nxt_port_t));
     if (nxt_fast_path(port != NULL)) {
         port->id = process->last_port_id++;
         port->pid = process->pid;
diff --git a/src/nxt_process.h b/src/nxt_process.h
index b6262106..00be35cb 100644
--- a/src/nxt_process.h
+++ b/src/nxt_process.h
@@ -49,7 +49,7 @@ struct nxt_process_init_s {
 
 
 typedef struct {
-    nxt_mem_pool_t      *mem_pool;
+    nxt_mp_t            *mem_pool;
 
     nxt_pid_t           pid;
     nxt_queue_t         ports;      /* of nxt_port_t */
diff --git a/src/nxt_router.c b/src/nxt_router.c
index 0d6d58b9..75edba40 100644
--- a/src/nxt_router.c
+++ b/src/nxt_router.c
@@ -17,26 +17,23 @@ static nxt_int_t nxt_router_stub_conf(nxt_task_t *task,
     nxt_router_temp_conf_t *tmcf);
 static nxt_int_t nxt_router_listen_sockets_stub_create(nxt_task_t *task,
     nxt_router_temp_conf_t *tmcf);
-static nxt_socket_conf_t *nxt_router_socket_conf(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_sockaddr_t *sa);
+static nxt_socket_conf_t *nxt_router_socket_conf(nxt_task_t *task, nxt_mp_t *mp,
+    nxt_sockaddr_t *sa);
 static nxt_sockaddr_t *nxt_router_listen_sockaddr_stub(nxt_task_t *task,
-    nxt_mem_pool_t *mp, uint32_t port);
+    nxt_mp_t *mp, uint32_t port);
 
 static nxt_int_t nxt_router_engines_create(nxt_task_t *task,
     nxt_router_t *router, nxt_router_temp_conf_t *tmcf,
     const nxt_event_interface_t *interface);
-static nxt_int_t nxt_router_engine_conf_create(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_router_temp_conf_t *tmcf,
-    nxt_router_engine_conf_t *recf);
-static nxt_int_t nxt_router_engine_conf_update(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_router_temp_conf_t *tmcf,
-    nxt_router_engine_conf_t *recf);
-static nxt_int_t nxt_router_engine_conf_delete(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_router_temp_conf_t *tmcf,
-    nxt_router_engine_conf_t *recf);
-static nxt_int_t nxt_router_engine_joints_create(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_router_engine_conf_t *recf, nxt_queue_t *sockets,
-    nxt_array_t *array, nxt_work_handler_t handler);
+static nxt_int_t nxt_router_engine_conf_create(nxt_task_t *task, nxt_mp_t *mp,
+    nxt_router_temp_conf_t *tmcf, nxt_router_engine_conf_t *recf);
+static nxt_int_t nxt_router_engine_conf_update(nxt_task_t *task, nxt_mp_t *mp,
+    nxt_router_temp_conf_t *tmcf, nxt_router_engine_conf_t *recf);
+static nxt_int_t nxt_router_engine_conf_delete(nxt_task_t *task, nxt_mp_t *mp,
+    nxt_router_temp_conf_t *tmcf, nxt_router_engine_conf_t *recf);
+static nxt_int_t nxt_router_engine_joints_create(nxt_task_t *task, nxt_mp_t *mp,
+    nxt_router_engine_conf_t *recf, nxt_queue_t *sockets, nxt_array_t *array,
+    nxt_work_handler_t handler);
 static nxt_int_t nxt_router_engine_joints_delete(nxt_task_t *task,
     nxt_router_engine_conf_t *recf, nxt_queue_t *sockets, nxt_array_t *array);
 
@@ -133,16 +130,16 @@ nxt_router_start(nxt_task_t *task, nxt_runtime_t *rt)
 static nxt_router_temp_conf_t *
 nxt_router_temp_conf(nxt_task_t *task, nxt_router_t *router)
 {
-    nxt_mem_pool_t          *mp, *tmp;
+    nxt_mp_t                *mp, *tmp;
     nxt_router_conf_t       *rtcf;
     nxt_router_temp_conf_t  *tmcf;
 
-    mp = nxt_mem_pool_create(1024);
+    mp = nxt_mp_create(1024, 128, 256, 32);
     if (nxt_slow_path(mp == NULL)) {
         return NULL;
     }
 
-    rtcf = nxt_mem_zalloc(mp, sizeof(nxt_router_conf_t));
+    rtcf = nxt_mp_zget(mp, sizeof(nxt_router_conf_t));
     if (nxt_slow_path(rtcf == NULL)) {
         goto fail;
     }
@@ -151,12 +148,12 @@ nxt_router_temp_conf(nxt_task_t *task, nxt_router_t *router)
     rtcf->router = router;
     rtcf->count = 1;
 
-    tmp = nxt_mem_pool_create(1024);
+    tmp = nxt_mp_create(1024, 128, 256, 32);
     if (nxt_slow_path(tmp == NULL)) {
         goto fail;
     }
 
-    tmcf = nxt_mem_zalloc(tmp, sizeof(nxt_router_temp_conf_t));
+    tmcf = nxt_mp_zget(tmp, sizeof(nxt_router_temp_conf_t));
     if (nxt_slow_path(tmcf == NULL)) {
         goto temp_fail;
     }
@@ -180,11 +177,11 @@ nxt_router_temp_conf(nxt_task_t *task, nxt_router_t *router)
 
 temp_fail:
 
-    nxt_mem_pool_destroy(tmp);
+    nxt_mp_destroy(tmp);
 
 fail:
 
-    nxt_mem_pool_destroy(mp);
+    nxt_mp_destroy(mp);
 
     return NULL;
 }
@@ -193,8 +190,8 @@ fail:
 static nxt_int_t
 nxt_router_stub_conf(nxt_task_t *task, nxt_router_temp_conf_t *tmcf)
 {
+    nxt_mp_t           *mp;
     nxt_sockaddr_t     *sa;
-    nxt_mem_pool_t     *mp;
     nxt_socket_conf_t  *skcf;
 
     tmcf->conf->threads = 1;
@@ -205,11 +202,6 @@ nxt_router_stub_conf(nxt_task_t *task, nxt_router_temp_conf_t *tmcf)
     skcf = nxt_router_socket_conf(task, mp, sa);
 
     skcf->listen.handler = nxt_router_conn_init;
-    skcf->listen.mem_pool_size = nxt_listen_socket_pool_min_size(&skcf->listen)
-                        + sizeof(nxt_conn_proxy_t)
-                        + sizeof(nxt_conn_t)
-                        + 4 * sizeof(nxt_buf_t);
-
     skcf->header_buffer_size = 2048;
     skcf->large_header_buffer_size = 8192;
     skcf->header_read_timeout = 5000;
@@ -220,11 +212,6 @@ nxt_router_stub_conf(nxt_task_t *task, nxt_router_temp_conf_t *tmcf)
     skcf = nxt_router_socket_conf(task, mp, sa);
 
     skcf->listen.handler = nxt_stream_connection_init;
-    skcf->listen.mem_pool_size = nxt_listen_socket_pool_min_size(&skcf->listen)
-                        + sizeof(nxt_conn_proxy_t)
-                        + sizeof(nxt_conn_t)
-                        + 4 * sizeof(nxt_buf_t);
-
     skcf->header_read_timeout = 5000;
 
     nxt_queue_insert_tail(&tmcf->pending, &skcf->link);
@@ -234,11 +221,11 @@ nxt_router_stub_conf(nxt_task_t *task, nxt_router_temp_conf_t *tmcf)
 
 
 static nxt_socket_conf_t *
-nxt_router_socket_conf(nxt_task_t *task, nxt_mem_pool_t *mp, nxt_sockaddr_t *sa)
+nxt_router_socket_conf(nxt_task_t *task, nxt_mp_t *mp, nxt_sockaddr_t *sa)
 {
     nxt_socket_conf_t  *conf;
 
-    conf = nxt_mem_zalloc(mp, sizeof(nxt_socket_conf_t));
+    conf = nxt_mp_zget(mp, sizeof(nxt_socket_conf_t));
     if (nxt_slow_path(conf == NULL)) {
         return NULL;
     }
@@ -255,8 +242,7 @@ nxt_router_socket_conf(nxt_task_t *task, nxt_mem_pool_t *mp, nxt_sockaddr_t *sa)
 
 
 static nxt_sockaddr_t *
-nxt_router_listen_sockaddr_stub(nxt_task_t *task, nxt_mem_pool_t *mp,
-    uint32_t port)
+nxt_router_listen_sockaddr_stub(nxt_task_t *task, nxt_mp_t *mp, uint32_t port)
 {
     nxt_sockaddr_t      *sa;
     struct sockaddr_in  sin;
@@ -348,9 +334,9 @@ static nxt_int_t
 nxt_router_engines_create(nxt_task_t *task, nxt_router_t *router,
     nxt_router_temp_conf_t *tmcf, const nxt_event_interface_t *interface)
 {
+    nxt_mp_t                  *mp;
     nxt_int_t                 ret;
     nxt_uint_t                n, threads;
-    nxt_mem_pool_t            *mp;
     nxt_queue_link_t          *qlk;
     nxt_router_engine_conf_t  *recf;
 
@@ -420,7 +406,7 @@ nxt_router_engines_create(nxt_task_t *task, nxt_router_t *router,
 
 
 static nxt_int_t
-nxt_router_engine_conf_create(nxt_task_t *task, nxt_mem_pool_t *mp,
+nxt_router_engine_conf_create(nxt_task_t *task, nxt_mp_t *mp,
     nxt_router_temp_conf_t *tmcf, nxt_router_engine_conf_t *recf)
 {
     nxt_int_t  ret;
@@ -442,7 +428,7 @@ nxt_router_engine_conf_create(nxt_task_t *task, nxt_mem_pool_t *mp,
 
 
 static nxt_int_t
-nxt_router_engine_conf_update(nxt_task_t *task, nxt_mem_pool_t *mp,
+nxt_router_engine_conf_update(nxt_task_t *task, nxt_mp_t *mp,
     nxt_router_temp_conf_t *tmcf, nxt_router_engine_conf_t *recf)
 {
     nxt_int_t  ret;
@@ -480,7 +466,7 @@ nxt_router_engine_conf_update(nxt_task_t *task, nxt_mem_pool_t *mp,
 
 
 static nxt_int_t
-nxt_router_engine_conf_delete(nxt_task_t *task, nxt_mem_pool_t *mp,
+nxt_router_engine_conf_delete(nxt_task_t *task, nxt_mp_t *mp,
     nxt_router_temp_conf_t *tmcf, nxt_router_engine_conf_t *recf)
 {
     nxt_int_t  ret;
@@ -502,7 +488,7 @@ nxt_router_engine_conf_delete(nxt_task_t *task, nxt_mem_pool_t *mp,
 
 
 static nxt_int_t
-nxt_router_engine_joints_create(nxt_task_t *task, nxt_mem_pool_t *mp,
+nxt_router_engine_joints_create(nxt_task_t *task, nxt_mp_t *mp,
     nxt_router_engine_conf_t *recf, nxt_queue_t *sockets, nxt_array_t *array,
     nxt_work_handler_t handler)
 {
@@ -524,7 +510,7 @@ nxt_router_engine_joints_create(nxt_task_t *task, nxt_mem_pool_t *mp,
         work->task = &recf->task;
         work->obj = recf->engine;
 
-        joint = nxt_mem_alloc(mp, sizeof(nxt_socket_conf_joint_t));
+        joint = nxt_mp_alloc(mp, sizeof(nxt_socket_conf_joint_t));
         if (nxt_slow_path(joint == NULL)) {
             return NXT_ERROR;
         }
@@ -846,7 +832,7 @@ nxt_router_conf_release(nxt_task_t *task, nxt_socket_conf_joint_t *joint)
     nxt_thread_spin_unlock(lock);
 
     if (rtcf != NULL) {
-        nxt_mem_pool_destroy(rtcf->mem_pool);
+        nxt_mp_destroy(rtcf->mem_pool);
     }
 
     if (nxt_queue_is_empty(&joint->engine->joints)) {
@@ -949,7 +935,7 @@ nxt_router_conn_http_header_parse(nxt_task_t *task, void *obj, void *data)
     nxt_debug(task, "router conn http header parse");
 
     if (rp == NULL) {
-        rp = nxt_mem_zalloc(c->mem_pool, sizeof(nxt_http_request_parse_t));
+        rp = nxt_mp_zget(c->mem_pool, sizeof(nxt_http_request_parse_t));
         if (nxt_slow_path(rp == NULL)) {
             nxt_router_conn_close(task, c, data);
             return;
@@ -1043,7 +1029,7 @@ nxt_router_conn_free(nxt_task_t *task, void *obj, void *data)
     joint = c->listen->socket.data;
     nxt_router_conf_release(task, joint);
 
-    nxt_mem_pool_destroy(c->mem_pool);
+    nxt_mp_destroy(c->mem_pool);
 }
 
 
diff --git a/src/nxt_router.h b/src/nxt_router.h
index d31a5964..9e2dd0a6 100644
--- a/src/nxt_router.h
+++ b/src/nxt_router.h
@@ -25,7 +25,7 @@ typedef struct {
     uint32_t               count;
     uint32_t               threads;
     nxt_router_t           *router;
-    nxt_mem_pool_t         *mem_pool;
+    nxt_mp_t               *mem_pool;
 } nxt_router_conf_t;
 
 
@@ -49,7 +49,7 @@ typedef struct {
 
     nxt_array_t            *engines;
     nxt_router_conf_t      *conf;
-    nxt_mem_pool_t         *mem_pool;
+    nxt_mp_t               *mem_pool;
 } nxt_router_temp_conf_t;
 
 
diff --git a/src/nxt_runtime.c b/src/nxt_runtime.c
index e35baa8f..4b823ad2 100644
--- a/src/nxt_runtime.c
+++ b/src/nxt_runtime.c
@@ -28,13 +28,13 @@ static nxt_int_t nxt_runtime_event_engine_change(nxt_task_t *task,
 static nxt_int_t nxt_runtime_conf_init(nxt_task_t *task, nxt_runtime_t *rt);
 static nxt_int_t nxt_runtime_conf_read_cmd(nxt_task_t *task, nxt_runtime_t *rt);
 static nxt_sockaddr_t *nxt_runtime_sockaddr_parse(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_str_t *addr);
+    nxt_mp_t *mp, nxt_str_t *addr);
 static nxt_sockaddr_t *nxt_runtime_sockaddr_unix_parse(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_str_t *addr);
+    nxt_mp_t *mp, nxt_str_t *addr);
 static nxt_sockaddr_t *nxt_runtime_sockaddr_inet6_parse(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_str_t *addr);
+    nxt_mp_t *mp, nxt_str_t *addr);
 static nxt_sockaddr_t *nxt_runtime_sockaddr_inet_parse(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_str_t *addr);
+    nxt_mp_t *mp, nxt_str_t *addr);
 static nxt_int_t nxt_runtime_hostname(nxt_task_t *task, nxt_runtime_t *rt);
 static nxt_int_t nxt_runtime_log_files_init(nxt_runtime_t *rt);
 static nxt_int_t nxt_runtime_log_files_create(nxt_task_t *task,
@@ -51,19 +51,21 @@ static void nxt_runtime_thread_pool_destroy(nxt_task_t *task, nxt_runtime_t *rt,
 nxt_int_t
 nxt_runtime_create(nxt_task_t *task)
 {
-    nxt_int_t       ret;
-    nxt_array_t     *listen_sockets;
-    nxt_runtime_t   *rt;
-    nxt_mem_pool_t  *mp;
+    nxt_mp_t       *mp;
+    nxt_int_t      ret;
+    nxt_array_t    *listen_sockets;
+    nxt_runtime_t  *rt;
 
-    mp = nxt_mem_pool_create(1024);
+    mp = nxt_mp_create(1024, 128, 256, 32);
 
     if (nxt_slow_path(mp == NULL)) {
         return NXT_ERROR;
     }
 
-    /* This alloction cannot fail. */
-    rt = nxt_mem_zalloc(mp, sizeof(nxt_runtime_t));
+    rt = nxt_mp_zget(mp, sizeof(nxt_runtime_t));
+    if (nxt_slow_path(rt == NULL)) {
+        return NXT_ERROR;
+    }
 
     task->thread->runtime = rt;
     rt->mem_pool = mp;
@@ -117,7 +119,7 @@ nxt_runtime_create(nxt_task_t *task)
 
 fail:
 
-    nxt_mem_pool_destroy(mp);
+    nxt_mp_destroy(mp);
 
     return NXT_ERROR;
 }
@@ -321,8 +323,6 @@ nxt_runtime_start(nxt_task_t *task, void *obj, void *data)
 
     nxt_debug(task, "rt conf done");
 
-    nxt_mem_pool_debug_lock(rt->mem_pool, nxt_thread_tid(task->thread));
-
     task->thread->log->ctx_handler = NULL;
     task->thread->log->ctx = NULL;
 
@@ -905,8 +905,7 @@ nxt_runtime_conf_read_cmd(nxt_task_t *task, nxt_runtime_t *rt)
 
 
 static nxt_sockaddr_t *
-nxt_runtime_sockaddr_parse(nxt_task_t *task, nxt_mem_pool_t *mp,
-    nxt_str_t *addr)
+nxt_runtime_sockaddr_parse(nxt_task_t *task, nxt_mp_t *mp, nxt_str_t *addr)
 {
     u_char  *p;
     size_t  length;
@@ -927,8 +926,7 @@ nxt_runtime_sockaddr_parse(nxt_task_t *task, nxt_mem_pool_t *mp,
 
 
 static nxt_sockaddr_t *
-nxt_runtime_sockaddr_unix_parse(nxt_task_t *task, nxt_mem_pool_t *mp,
-    nxt_str_t *addr)
+nxt_runtime_sockaddr_unix_parse(nxt_task_t *task, nxt_mp_t *mp, nxt_str_t *addr)
 {
 #if (NXT_HAVE_UNIX_DOMAIN)
     u_char          *p;
@@ -1008,14 +1006,14 @@ nxt_runtime_sockaddr_unix_parse(nxt_task_t *task, nxt_mem_pool_t *mp,
 
 
 static nxt_sockaddr_t *
-nxt_runtime_sockaddr_inet6_parse(nxt_task_t *task, nxt_mem_pool_t *mp,
+nxt_runtime_sockaddr_inet6_parse(nxt_task_t *task, nxt_mp_t *mp,
     nxt_str_t *addr)
 {
 #if (NXT_INET6)
     u_char           *p, *addr, *addr_end;
     size_t           length;
+    nxt_mp_t         *mp;
     nxt_int_t        port;
-    nxt_mem_pool_t   *mp;
     nxt_sockaddr_t   *sa;
     struct in6_addr  *in6_addr;
 
@@ -1085,7 +1083,7 @@ invalid_address:
 
 
 static nxt_sockaddr_t *
-nxt_runtime_sockaddr_inet_parse(nxt_task_t *task, nxt_mem_pool_t *mp,
+nxt_runtime_sockaddr_inet_parse(nxt_task_t *task, nxt_mp_t *mp,
     nxt_str_t *string)
 {
     u_char          *p, *ip;
@@ -1182,7 +1180,7 @@ invalid_addr:
 nxt_listen_socket_t *
 nxt_runtime_listen_socket_add(nxt_runtime_t *rt, nxt_sockaddr_t *sa)
 {
-    nxt_mem_pool_t       *mp;
+    nxt_mp_t             *mp;
     nxt_listen_socket_t  *ls;
 
     ls = nxt_array_zero_add(rt->listen_sockets);
@@ -1233,7 +1231,7 @@ nxt_runtime_hostname(nxt_task_t *task, nxt_runtime_t *rt)
     length = nxt_strlen(hostname);
     rt->hostname.length = length;
 
-    rt->hostname.start = nxt_mem_nalloc(rt->mem_pool, length);
+    rt->hostname.start = nxt_mp_nget(rt->mem_pool, length);
 
     if (rt->hostname.start != NULL) {
         nxt_memcpy_lowcase(rt->hostname.start, (u_char *) hostname, length);
@@ -1403,7 +1401,7 @@ nxt_runtime_listen_sockets_enable(nxt_task_t *task, nxt_runtime_t *rt)
 
 
 nxt_str_t *
-nxt_current_directory(nxt_mem_pool_t *mp)
+nxt_current_directory(nxt_mp_t *mp)
 {
     size_t     length;
     u_char     *p;
@@ -1465,7 +1463,7 @@ nxt_runtime_process_new(nxt_runtime_t *rt)
 
     /* TODO: memory failures. */
 
-    process = nxt_mem_cache_zalloc0(rt->mem_pool, sizeof(nxt_process_t));
+    process = nxt_mp_zalloc(rt->mem_pool, sizeof(nxt_process_t));
     if (nxt_slow_path(process == NULL)) {
         return NULL;
     }
@@ -1496,7 +1494,6 @@ nxt_runtime_lvlhsh_pid_test(nxt_lvlhsh_query_t *lhq, void *data)
 
 static const nxt_lvlhsh_proto_t  lvlhsh_processes_proto  nxt_aligned(64) = {
     NXT_LVLHSH_DEFAULT,
-    0,
     nxt_runtime_lvlhsh_pid_test,
     nxt_lvlhsh_alloc,
     nxt_lvlhsh_free,
@@ -1528,7 +1525,6 @@ nxt_runtime_lvlhsh_port_test(nxt_lvlhsh_query_t *lhq, void *data)
 
 static const nxt_lvlhsh_proto_t  lvlhsh_ports_proto  nxt_aligned(64) = {
     NXT_LVLHSH_DEFAULT,
-    0,
     nxt_runtime_lvlhsh_port_test,
     nxt_lvlhsh_alloc,
     nxt_lvlhsh_free,
diff --git a/src/nxt_runtime.h b/src/nxt_runtime.h
index c24618b7..d0ed00a1 100644
--- a/src/nxt_runtime.h
+++ b/src/nxt_runtime.h
@@ -13,7 +13,7 @@ typedef void (*nxt_runtime_cont_t)(nxt_task_t *task);
 
 
 struct nxt_runtime_s {
-    nxt_mem_pool_t         *mem_pool;
+    nxt_mp_t               *mem_pool;
 
     nxt_array_t            *inherited_sockets;  /* of nxt_listen_socket_t */
     nxt_array_t            *listen_sockets;     /* of nxt_listen_socket_t */
@@ -112,7 +112,7 @@ nxt_port_t *nxt_runtime_port_find(nxt_runtime_t *rt, nxt_pid_t pid,
 /* STUB */
 nxt_int_t nxt_runtime_controller_socket(nxt_task_t *task, nxt_runtime_t *rt);
 
-nxt_str_t *nxt_current_directory(nxt_mem_pool_t *mp);
+nxt_str_t *nxt_current_directory(nxt_mp_t *mp);
 
 nxt_listen_socket_t *nxt_runtime_listen_socket_add(nxt_runtime_t *rt,
     nxt_sockaddr_t *sa);
diff --git a/src/nxt_service.c b/src/nxt_service.c
index 43aecfdd..e96e7c58 100644
--- a/src/nxt_service.c
+++ b/src/nxt_service.c
@@ -58,7 +58,7 @@ static const nxt_service_t  nxt_services[] = {
 
 
 nxt_array_t *
-nxt_services_init(nxt_mem_pool_t *mp)
+nxt_services_init(nxt_mp_t *mp)
 {
     nxt_uint_t           n;
     nxt_array_t          *services;
diff --git a/src/nxt_service.h b/src/nxt_service.h
index 1484f73e..55d98351 100644
--- a/src/nxt_service.h
+++ b/src/nxt_service.h
@@ -20,7 +20,7 @@ nxt_service_is_module(s)                                                      \
     ((s)->type == NULL)
 
 
-NXT_EXPORT nxt_array_t *nxt_services_init(nxt_mem_pool_t *mp);
+NXT_EXPORT nxt_array_t *nxt_services_init(nxt_mp_t *mp);
 NXT_EXPORT nxt_int_t nxt_service_add(nxt_array_t *services,
     const nxt_service_t *service);
 NXT_EXPORT const void *nxt_service_get(nxt_array_t *services, const char *type,
diff --git a/src/nxt_sockaddr.c b/src/nxt_sockaddr.c
index 66acfbd0..40d00929 100644
--- a/src/nxt_sockaddr.c
+++ b/src/nxt_sockaddr.c
@@ -17,7 +17,7 @@ static nxt_int_t nxt_job_sockaddr_inet_parse(nxt_job_sockaddr_parse_t *jbs);
 
 
 nxt_sockaddr_t *
-nxt_sockaddr_alloc(nxt_mem_pool_t *mp, socklen_t socklen, size_t address_length)
+nxt_sockaddr_alloc(nxt_mp_t *mp, socklen_t socklen, size_t address_length)
 {
     size_t          size;
     nxt_sockaddr_t  *sa;
@@ -27,12 +27,12 @@ nxt_sockaddr_alloc(nxt_mem_pool_t *mp, socklen_t socklen, size_t address_length)
     /*
      * The current struct sockaddr's define 32-bit fields at maximum
      * and may define 64-bit AF_INET6 fields in the future.  Alignment
-     * of memory allocated by nxt_mem_zalloc() is enough for these fields.
+     * of memory allocated by nxt_mp_zalloc() is enough for these fields.
      * If 128-bit alignment will be required then nxt_mem_malloc() and
      * nxt_memzero() should be used instead.
      */
 
-    sa = nxt_mem_zalloc(mp, size);
+    sa = nxt_mp_zalloc(mp, size);
 
     if (nxt_fast_path(sa != NULL)) {
         sa->socklen = socklen;
@@ -45,8 +45,8 @@ nxt_sockaddr_alloc(nxt_mem_pool_t *mp, socklen_t socklen, size_t address_length)
 
 
 nxt_sockaddr_t *
-nxt_sockaddr_create(nxt_mem_pool_t *mp, struct sockaddr *sockaddr,
-    socklen_t length, size_t address_length)
+nxt_sockaddr_create(nxt_mp_t *mp, struct sockaddr *sockaddr, socklen_t length,
+    size_t address_length)
 {
     size_t          size, copy;
     nxt_sockaddr_t  *sa;
@@ -120,14 +120,14 @@ nxt_sockaddr_create(nxt_mem_pool_t *mp, struct sockaddr *sockaddr,
 
 
 nxt_sockaddr_t *
-nxt_sockaddr_copy(nxt_mem_pool_t *mp, nxt_sockaddr_t *src)
+nxt_sockaddr_copy(nxt_mp_t *mp, nxt_sockaddr_t *src)
 {
     size_t          length;
     nxt_sockaddr_t  *dst;
 
     length = offsetof(nxt_sockaddr_t, u) + src->socklen;
 
-    dst = nxt_mem_alloc(mp, length);
+    dst = nxt_mp_alloc(mp, length);
 
     if (nxt_fast_path(dst != NULL)) {
         nxt_memcpy(dst, src, length);
@@ -138,7 +138,7 @@ nxt_sockaddr_copy(nxt_mem_pool_t *mp, nxt_sockaddr_t *src)
 
 
 nxt_sockaddr_t *
-nxt_getsockname(nxt_task_t *task, nxt_mem_pool_t *mp, nxt_socket_t s)
+nxt_getsockname(nxt_task_t *task, nxt_mp_t *mp, nxt_socket_t s)
 {
     int                 ret;
     size_t              length;
@@ -608,7 +608,7 @@ nxt_job_sockaddr_unix_parse(nxt_job_sockaddr_parse_t *jbs)
 #if (NXT_HAVE_UNIX_DOMAIN)
     size_t          length, socklen;
     u_char          *path;
-    nxt_mem_pool_t  *mp;
+    nxt_mp_t        *mp;
     nxt_sockaddr_t  *sa;
 
     /*
@@ -655,7 +655,7 @@ nxt_job_sockaddr_unix_parse(nxt_job_sockaddr_parse_t *jbs)
 
     mp = jbs->resolve.job.mem_pool;
 
-    jbs->resolve.sockaddrs = nxt_mem_alloc(mp, sizeof(void *));
+    jbs->resolve.sockaddrs = nxt_mp_alloc(mp, sizeof(void *));
 
     if (nxt_fast_path(jbs->resolve.sockaddrs != NULL)) {
         sa = nxt_sockaddr_alloc(mp, socklen, jbs->addr.length);
@@ -690,8 +690,8 @@ nxt_job_sockaddr_inet6_parse(nxt_job_sockaddr_parse_t *jbs)
 #if (NXT_INET6)
     u_char           *p, *addr, *addr_end;
     size_t           length;
+    nxt_mp_t         *mp;
     nxt_int_t        port;
-    nxt_mem_pool_t   *mp;
     nxt_sockaddr_t   *sa;
     struct in6_addr  *in6_addr;
 
@@ -706,7 +706,7 @@ nxt_job_sockaddr_inet6_parse(nxt_job_sockaddr_parse_t *jbs)
 
     mp = jbs->resolve.job.mem_pool;
 
-    jbs->resolve.sockaddrs = nxt_mem_alloc(mp, sizeof(void *));
+    jbs->resolve.sockaddrs = nxt_mp_alloc(mp, sizeof(void *));
 
     if (nxt_slow_path(jbs->resolve.sockaddrs == NULL)) {
         return NXT_ERROR;
@@ -782,9 +782,9 @@ nxt_job_sockaddr_inet_parse(nxt_job_sockaddr_parse_t *jbs)
 {
     u_char          *p, *host;
     size_t          length;
-    in_addr_t       addr;
+    nxt_mp_t        *mp;
     nxt_int_t       port;
-    nxt_mem_pool_t  *mp;
+    in_addr_t       addr;
     nxt_sockaddr_t  *sa;
 
     addr = INADDR_ANY;
@@ -860,7 +860,7 @@ nxt_job_sockaddr_inet_parse(nxt_job_sockaddr_parse_t *jbs)
 
     mp = jbs->resolve.job.mem_pool;
 
-    jbs->resolve.sockaddrs = nxt_mem_alloc(mp, sizeof(void *));
+    jbs->resolve.sockaddrs = nxt_mp_alloc(mp, sizeof(void *));
     if (nxt_slow_path(jbs->resolve.sockaddrs == NULL)) {
         return NXT_ERROR;
     }
diff --git a/src/nxt_sockaddr.h b/src/nxt_sockaddr.h
index c5f8ec71..11f4b9d1 100644
--- a/src/nxt_sockaddr.h
+++ b/src/nxt_sockaddr.h
@@ -69,17 +69,16 @@ typedef struct {
 } nxt_job_sockaddr_parse_t;
 
 
-NXT_EXPORT nxt_sockaddr_t *nxt_sockaddr_alloc(nxt_mem_pool_t *mp,
-    socklen_t socklen, size_t address_length)
+NXT_EXPORT nxt_sockaddr_t *nxt_sockaddr_alloc(nxt_mp_t *mp, socklen_t socklen,
+    size_t address_length)
     NXT_MALLOC_LIKE;
-NXT_EXPORT nxt_sockaddr_t *nxt_sockaddr_create(nxt_mem_pool_t *mp,
+NXT_EXPORT nxt_sockaddr_t *nxt_sockaddr_create(nxt_mp_t *mp,
     struct sockaddr *sockaddr, socklen_t socklen, size_t address_length)
     NXT_MALLOC_LIKE;
-NXT_EXPORT nxt_sockaddr_t *nxt_sockaddr_copy(nxt_mem_pool_t *mp,
-    nxt_sockaddr_t *src)
+NXT_EXPORT nxt_sockaddr_t *nxt_sockaddr_copy(nxt_mp_t *mp, nxt_sockaddr_t *src)
     NXT_MALLOC_LIKE;
-NXT_EXPORT nxt_sockaddr_t *nxt_getsockname(nxt_task_t *task,
-    nxt_mem_pool_t *mp, nxt_socket_t s)
+NXT_EXPORT nxt_sockaddr_t *nxt_getsockname(nxt_task_t *task, nxt_mp_t *mp,
+    nxt_socket_t s)
     NXT_MALLOC_LIKE;
 NXT_EXPORT void nxt_sockaddr_text(nxt_sockaddr_t *sa);
 
diff --git a/src/nxt_stream_module.c b/src/nxt_stream_module.c
index 6000daaf..461928c9 100644
--- a/src/nxt_stream_module.c
+++ b/src/nxt_stream_module.c
@@ -25,7 +25,7 @@ nxt_stream_connection_init(nxt_task_t *task, void *obj, void *data)
 
     nxt_debug(task, "stream connection init");
 
-    up = nxt_mem_zalloc(c->mem_pool, sizeof(nxt_upstream_peer_t));
+    up = nxt_mp_zget(c->mem_pool, sizeof(nxt_upstream_peer_t));
     if (nxt_slow_path(up == NULL)) {
         goto fail;
     }
@@ -91,7 +91,7 @@ nxt_stream_connection_peer(nxt_task_t *task, nxt_upstream_peer_t *up)
         nxt_event_engine_t      *engine;
         nxt_event_write_rate_t  *rate;
 
-        rate = nxt_mem_alloc(c->mem_pool, sizeof(nxt_event_write_rate_t));
+        rate = nxt_mp_get(c->mem_pool, sizeof(nxt_event_write_rate_t));
 
         if (nxt_slow_path(rate == NULL)) {
             goto fail;
@@ -126,5 +126,5 @@ nxt_stream_connection_close(nxt_task_t *task, void *obj, void *data)
 
     nxt_log_debug(p->client->socket.log, "stream connection close");
 
-    nxt_mem_pool_destroy(p->client->mem_pool);
+    nxt_mp_destroy(p->client->mem_pool);
 }
diff --git a/src/nxt_string.c b/src/nxt_string.c
index 7e9d8fd4..79dfe72d 100644
--- a/src/nxt_string.c
+++ b/src/nxt_string.c
@@ -8,12 +8,12 @@
 
 
 nxt_str_t *
-nxt_str_alloc(nxt_mem_pool_t *mp, size_t length)
+nxt_str_alloc(nxt_mp_t *mp, size_t length)
 {
     nxt_str_t  *s;
 
     /* The string start is allocated aligned to be close to nxt_str_t. */
-    s = nxt_mem_alloc(mp, sizeof(nxt_str_t) + length);
+    s = nxt_mp_get(mp, sizeof(nxt_str_t) + length);
 
     if (nxt_fast_path(s != NULL)) {
         s->length = length;
@@ -31,13 +31,13 @@ nxt_str_alloc(nxt_mem_pool_t *mp, size_t length)
  */
 
 nxt_str_t *
-nxt_str_dup(nxt_mem_pool_t *mp, nxt_str_t *dst, const nxt_str_t *src)
+nxt_str_dup(nxt_mp_t *mp, nxt_str_t *dst, const nxt_str_t *src)
 {
     u_char  *p;
 
     if (dst == NULL) {
         /* The string start is allocated aligned to be close to nxt_str_t. */
-        dst = nxt_mem_alloc(mp, sizeof(nxt_str_t) + src->length);
+        dst = nxt_mp_get(mp, sizeof(nxt_str_t) + src->length);
         if (nxt_slow_path(dst == NULL)) {
             return NULL;
         }
@@ -47,7 +47,7 @@ nxt_str_dup(nxt_mem_pool_t *mp, nxt_str_t *dst, const nxt_str_t *src)
         dst->start = p;
 
     } else {
-        dst->start = nxt_mem_nalloc(mp, src->length);
+        dst->start = nxt_mp_nget(mp, src->length);
         if (nxt_slow_path(dst->start == NULL)) {
             return NULL;
         }
@@ -69,11 +69,11 @@ nxt_str_dup(nxt_mem_pool_t *mp, nxt_str_t *dst, const nxt_str_t *src)
  */
 
 char *
-nxt_str_copy(nxt_mem_pool_t *mp, const nxt_str_t *src)
+nxt_str_copy(nxt_mp_t *mp, const nxt_str_t *src)
 {
     char  *p, *dst;
 
-    dst = nxt_mem_align(mp, 2, src->length + 1);
+    dst = nxt_mp_align(mp, 2, src->length + 1);
 
     if (nxt_fast_path(dst != NULL)) {
         p = nxt_cpymem(dst, src->start, src->length);
diff --git a/src/nxt_string.h b/src/nxt_string.h
index d121b788..6fce9284 100644
--- a/src/nxt_string.h
+++ b/src/nxt_string.h
@@ -133,10 +133,10 @@ nxt_str_null(str)                                                             \
     } while (0)
 
 
-NXT_EXPORT nxt_str_t *nxt_str_alloc(nxt_mem_pool_t *mp, size_t length);
-NXT_EXPORT nxt_str_t *nxt_str_dup(nxt_mem_pool_t *mp, nxt_str_t *dst,
+NXT_EXPORT nxt_str_t *nxt_str_alloc(nxt_mp_t *mp, size_t length);
+NXT_EXPORT nxt_str_t *nxt_str_dup(nxt_mp_t *mp, nxt_str_t *dst,
     const nxt_str_t *src);
-NXT_EXPORT char *nxt_str_copy(nxt_mem_pool_t *mp, const nxt_str_t *src);
+NXT_EXPORT char *nxt_str_copy(nxt_mp_t *mp, const nxt_str_t *src);
 
 
 #define                                                                       \
diff --git a/src/nxt_upstream.h b/src/nxt_upstream.h
index a7d2a224..d1fca2a5 100644
--- a/src/nxt_upstream.h
+++ b/src/nxt_upstream.h
@@ -24,7 +24,7 @@ struct nxt_upstream_peer_s {
     in_port_t       port;
 
     nxt_str_t       addr;
-    nxt_mem_pool_t  *mem_pool;
+    nxt_mp_t        *mem_pool;
     void            (*ready_handler)(nxt_task_t *task, nxt_upstream_peer_t *up);
 
     void            (*protocol_handler)(nxt_upstream_source_t *us);
diff --git a/src/nxt_upstream_round_robin.c b/src/nxt_upstream_round_robin.c
index 480f7eb8..089f22b1 100644
--- a/src/nxt_upstream_round_robin.c
+++ b/src/nxt_upstream_round_robin.c
@@ -72,15 +72,15 @@ nxt_upstream_round_robin_create(nxt_task_t *task, void *obj, void *data)
     jbs = obj;
     up = jbs->resolve.job.data;
 
-    urr = nxt_mem_zalloc(up->mem_pool, sizeof(nxt_upstream_round_robin_t));
+    urr = nxt_mp_zget(up->mem_pool, sizeof(nxt_upstream_round_robin_t));
     if (nxt_slow_path(urr == NULL)) {
         goto fail;
     }
 
     urr->npeers = jbs->resolve.count;
 
-    peer = nxt_mem_zalloc(up->mem_pool,
-                   urr->npeers * sizeof(nxt_upstream_round_robin_peer_t));
+    peer = nxt_mp_zget(up->mem_pool,
+                       urr->npeers * sizeof(nxt_upstream_round_robin_peer_t));
     if (nxt_slow_path(peer == NULL)) {
         goto fail;
     }
diff --git a/src/nxt_upstream_source.c b/src/nxt_upstream_source.c
index 7b595806..ee3fc21e 100644
--- a/src/nxt_upstream_source.c
+++ b/src/nxt_upstream_source.c
@@ -21,7 +21,7 @@ const nxt_lvlhsh_proto_t  nxt_upstream_header_hash_proto  nxt_aligned(64) = {
 
 
 nxt_int_t
-nxt_upstream_header_hash_add(nxt_mem_pool_t *mp, nxt_lvlhsh_t *lh,
+nxt_upstream_header_hash_add(nxt_mp_t *mp, nxt_lvlhsh_t *lh,
     const nxt_upstream_name_value_t *unv, nxt_uint_t n)
 {
     nxt_lvlhsh_query_t  lhq;
diff --git a/src/nxt_upstream_source.h b/src/nxt_upstream_source.h
index 706cb5c9..4189a356 100644
--- a/src/nxt_upstream_source.h
+++ b/src/nxt_upstream_source.h
@@ -72,7 +72,7 @@ struct nxt_upstream_source_s {
 #define nxt_upstream_name_value(s)   sizeof(s) - 1, s
 
 
-NXT_EXPORT nxt_int_t nxt_upstream_header_hash_add(nxt_mem_pool_t *mp,
+NXT_EXPORT nxt_int_t nxt_upstream_header_hash_add(nxt_mp_t *mp,
     nxt_lvlhsh_t *lh, const nxt_upstream_name_value_t *unv, nxt_uint_t n);
 NXT_EXPORT nxt_int_t nxt_upstream_name_value_ignore(nxt_upstream_source_t *us,
     nxt_name_value_t *nv);