nxt_mem_cache_pool_t -> nxt_mp_t.
nxt_mem_cache_* -> nxt_mp_*.
vm->mem_cache_pool -> vm->mem_pool.
$(NXT_BUILDDIR)/nxt_pcre.o \
$(NXT_BUILDDIR)/nxt_time.o \
$(NXT_BUILDDIR)/nxt_malloc.o \
- $(NXT_BUILDDIR)/nxt_mem_cache_pool.o \
+ $(NXT_BUILDDIR)/nxt_mp.o \
ar -r -c $(NXT_BUILDDIR)/libnjs.a \
$(NXT_BUILDDIR)/njs_shell.o \
$(NXT_BUILDDIR)/nxt_pcre.o \
$(NXT_BUILDDIR)/nxt_time.o \
$(NXT_BUILDDIR)/nxt_malloc.o \
- $(NXT_BUILDDIR)/nxt_mem_cache_pool.o \
+ $(NXT_BUILDDIR)/nxt_mp.o \
all: test lib_test
}
-const nxt_mem_proto_t njs_vm_mem_cache_pool_proto = {
+const nxt_mem_proto_t njs_vm_mp_proto = {
njs_alloc,
njs_zalloc,
njs_align,
static void *
njs_array_mem_alloc(void *mem, size_t size)
{
- return nxt_mem_cache_alloc(mem, size);
+ return nxt_mp_alloc(mem, size);
}
static void
njs_array_mem_free(void *mem, void *p)
{
- nxt_mem_cache_free(mem, p);
+ nxt_mp_free(mem, p);
}
njs_vm_t *
njs_vm_create(njs_vm_opt_t *options)
{
+ nxt_mp_t *mp;
njs_vm_t *vm;
nxt_int_t ret;
nxt_array_t *debug;
- nxt_mem_cache_pool_t *mcp;
njs_regexp_pattern_t *pattern;
- mcp = nxt_mem_cache_pool_create(&njs_vm_mem_cache_pool_proto, NULL,
- NULL, 2 * nxt_pagesize(), 128, 512, 16);
- if (nxt_slow_path(mcp == NULL)) {
+ mp = nxt_mp_create(&njs_vm_mp_proto, NULL, NULL, 2 * nxt_pagesize(),
+ 128, 512, 16);
+ if (nxt_slow_path(mp == NULL)) {
return NULL;
}
- vm = nxt_mem_cache_zalign(mcp, sizeof(njs_value_t), sizeof(njs_vm_t));
+ vm = nxt_mp_zalign(mp, sizeof(njs_value_t), sizeof(njs_vm_t));
if (nxt_fast_path(vm != NULL)) {
- vm->mem_cache_pool = mcp;
+ vm->mem_pool = mp;
ret = njs_regexp_init(vm);
if (nxt_slow_path(ret != NXT_OK)) {
vm->shared = options->shared;
} else {
- vm->shared = nxt_mem_cache_zalloc(mcp, sizeof(njs_vm_shared_t));
+ vm->shared = nxt_mp_zalloc(mp, sizeof(njs_vm_shared_t));
if (nxt_slow_path(vm->shared == NULL)) {
return NULL;
}
nxt_lvlhsh_init(&vm->shared->keywords_hash);
- ret = njs_lexer_keywords_init(mcp, &vm->shared->keywords_hash);
+ ret = njs_lexer_keywords_init(mp, &vm->shared->keywords_hash);
if (nxt_slow_path(ret != NXT_OK)) {
return NULL;
}
vm->external_objects = nxt_array_create(4, sizeof(void *),
&njs_array_mem_proto,
- vm->mem_cache_pool);
+ vm->mem_pool);
if (nxt_slow_path(vm->external_objects == NULL)) {
return NULL;
}
if (options->backtrace) {
debug = nxt_array_create(4, sizeof(njs_function_debug_t),
- &njs_array_mem_proto,
- vm->mem_cache_pool);
+ &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(debug == NULL)) {
return NULL;
}
}
}
- nxt_mem_cache_pool_destroy(vm->mem_cache_pool);
+ nxt_mp_destroy(vm->mem_pool);
}
njs_parser_t *parser, *prev;
njs_generator_t *generator;
- parser = nxt_mem_cache_zalloc(vm->mem_cache_pool, sizeof(njs_parser_t));
+ parser = nxt_mp_zalloc(vm->mem_pool, sizeof(njs_parser_t));
if (nxt_slow_path(parser == NULL)) {
return NJS_ERROR;
}
prev = vm->parser;
vm->parser = parser;
- lexer = nxt_mem_cache_zalloc(vm->mem_cache_pool, sizeof(njs_lexer_t));
+ lexer = nxt_mp_zalloc(vm->mem_pool, sizeof(njs_lexer_t));
if (nxt_slow_path(lexer == NULL)) {
return NJS_ERROR;
}
*/
vm->code = NULL;
- generator = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- sizeof(njs_generator_t));
+ generator = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ sizeof(njs_generator_t));
if (nxt_slow_path(generator == NULL)) {
goto fail;
njs_vm_t *
njs_vm_clone(njs_vm_t *vm, njs_external_ptr_t external)
{
- njs_vm_t *nvm;
- uint32_t items;
- nxt_int_t ret;
- nxt_array_t *externals;
- nxt_mem_cache_pool_t *nmcp;
+ nxt_mp_t *nmp;
+ njs_vm_t *nvm;
+ uint32_t items;
+ nxt_int_t ret;
+ nxt_array_t *externals;
nxt_thread_log_debug("CLONE:");
return NULL;
}
- nmcp = nxt_mem_cache_pool_create(&njs_vm_mem_cache_pool_proto, NULL,
- NULL, 2 * nxt_pagesize(), 128, 512, 16);
- if (nxt_slow_path(nmcp == NULL)) {
+ nmp = nxt_mp_create(&njs_vm_mp_proto, NULL, NULL, 2 * nxt_pagesize(),
+ 128, 512, 16);
+ if (nxt_slow_path(nmp == NULL)) {
return NULL;
}
- nvm = nxt_mem_cache_zalign(nmcp, sizeof(njs_value_t), sizeof(njs_vm_t));
+ nvm = nxt_mp_zalign(nmp, sizeof(njs_value_t), sizeof(njs_vm_t));
if (nxt_fast_path(nvm != NULL)) {
- nvm->mem_cache_pool = nmcp;
+ nvm->mem_pool = nmp;
nvm->shared = vm->shared;
nvm->trace = vm->trace;
items = vm->external_objects->items;
externals = nxt_array_create(items + 4, sizeof(void *),
- &njs_array_mem_proto, nvm->mem_cache_pool);
+ &njs_array_mem_proto, nvm->mem_pool);
if (nxt_slow_path(externals == NULL)) {
return NULL;
fail:
- nxt_mem_cache_pool_destroy(nmcp);
+ nxt_mp_destroy(nmp);
return NULL;
}
size = NJS_GLOBAL_FRAME_SIZE + scope_size + NJS_FRAME_SPARE_SIZE;
size = nxt_align_size(size, NJS_FRAME_SPARE_SIZE);
- frame = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t), size);
+ frame = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t), size);
if (nxt_slow_path(frame == NULL)) {
return NXT_ERROR;
}
if (vm->debug != NULL) {
backtrace = nxt_array_create(4, sizeof(njs_backtrace_entry_t),
- &njs_array_mem_proto, vm->mem_cache_pool);
+ &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(backtrace == NULL)) {
return NXT_ERROR;
}
{
njs_event_t *event;
- event = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_event_t));
+ event = nxt_mp_alloc(vm->mem_pool, sizeof(njs_event_t));
if (nxt_slow_path(event == NULL)) {
return NULL;
}
if (nargs != 0 && !event->posted) {
event->nargs = nargs;
- event->args = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_value_t) * nargs);
+ event->args = nxt_mp_alloc(vm->mem_pool, sizeof(njs_value_t) * nargs);
if (nxt_slow_path(event->args == NULL)) {
return NJS_ERROR;
}
}
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
lhq.proto = &njs_object_hash_proto;
njs_string_get(name, &lhq.key);
NXT_EXPORT njs_value_t *njs_vm_object_prop(njs_vm_t *vm,
const njs_value_t *value, const nxt_str_t *key);
-extern const nxt_mem_proto_t njs_vm_mem_cache_pool_proto;
+extern const nxt_mem_proto_t njs_vm_mp_proto;
#endif /* _NJS_H_INCLUDED_ */
uint64_t size;
njs_array_t *array;
- array = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_array_t));
+ array = nxt_mp_alloc(vm->mem_pool, sizeof(njs_array_t));
if (nxt_slow_path(array == NULL)) {
goto memory_error;
}
goto memory_error;
}
- array->data = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- size * sizeof(njs_value_t));
+ array->data = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ size * sizeof(njs_value_t));
if (nxt_slow_path(array->data == NULL)) {
goto memory_error;
}
goto memory_error;
}
- start = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- (prepend + size) * sizeof(njs_value_t));
+ start = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ (prepend + size) * sizeof(njs_value_t));
if (nxt_slow_path(start == NULL)) {
goto memory_error;
}
array->start = start;
- nxt_mem_cache_free(vm->mem_cache_pool, old);
+ nxt_mp_free(vm->mem_pool, old);
return NXT_OK;
}
if (max != 0) {
- values = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- sizeof(njs_value_t) * max);
+ values = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ sizeof(njs_value_t) * max);
if (nxt_slow_path(values == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
njs_release(vm, &values[i]);
}
- nxt_mem_cache_free(vm->mem_cache_pool, values);
+ nxt_mp_free(vm->mem_pool, values);
return NXT_OK;
}
}
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
for (p = njs_module_init; *p != NULL; p++) {
obj = *p;
- module = nxt_mem_cache_zalloc(vm->mem_cache_pool, sizeof(njs_module_t));
+ module = nxt_mp_zalloc(vm->mem_pool, sizeof(njs_module_t));
if (nxt_slow_path(module == NULL)) {
return NJS_ERROR;
}
njs_string_get(&prop->name, &string);
len = obj->name.length + string.length + 2;
- compl = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ compl = nxt_mp_zalloc(vm->mem_pool, len);
if (compl == NULL) {
return NULL;
}
njs_string_get(&prop->name, &string);
len = string.length + 2;
- compl = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ compl = nxt_mp_zalloc(vm->mem_pool, len);
if (compl == NULL) {
return NULL;
}
njs_string_get(&prop->name, &string);
len = obj->name.length + string.length + 2;
- compl = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ compl = nxt_mp_zalloc(vm->mem_pool, len);
if (compl == NULL) {
return NULL;
}
nxt_lvlhsh_each_init(&lhe_prop, &njs_extern_hash_proto);
len = ev->name.length + 1;
- compl = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ compl = nxt_mp_zalloc(vm->mem_pool, len);
if (compl == NULL) {
return NULL;
}
}
len = ev->name.length + ev->name.length + 2;
- compl = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ compl = nxt_mp_zalloc(vm->mem_pool, len);
if (compl == NULL) {
return NULL;
}
size = njs_builtin_completions_size(vm);
completions = nxt_array_create(size, sizeof(nxt_str_t),
- &njs_array_mem_proto,
- vm->mem_cache_pool);
+ &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(completions == NULL)) {
return NULL;
} while (o != NULL);
completions = nxt_array_create(size, sizeof(nxt_str_t),
- &njs_array_mem_proto, vm->mem_cache_pool);
+ &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(completions == NULL)) {
return NULL;
njs_string_get(&prop->name, &string);
len = obj->name.length + string.length + sizeof(".");
- buf = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ buf = nxt_mp_zalloc(vm->mem_pool, len);
if (buf == NULL) {
return NXT_ERROR;
}
njs_string_get(&prop->name, &string);
len = obj->name.length + string.length + sizeof(".prototype.");
- buf = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ buf = nxt_mp_zalloc(vm->mem_pool, len);
if (buf == NULL) {
return NXT_ERROR;
}
njs_string_get(&prop->name, &string);
len = obj->name.length + string.length + sizeof(".");
- buf = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ buf = nxt_mp_zalloc(vm->mem_pool, len);
if (buf == NULL) {
return NXT_ERROR;
}
njs_string_get(&prop->name, &string);
len = obj->name.length + string.length + sizeof(".");
- buf = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ buf = nxt_mp_zalloc(vm->mem_pool, len);
if (buf == NULL) {
return NXT_ERROR;
}
#include <nxt_random.h>
#include <nxt_time.h>
#include <nxt_malloc.h>
-#include <nxt_mem_cache_pool.h>
+#include <nxt_mp.h>
#include <njs.h>
#include <njs_vm.h>
{
njs_object_value_t *ov;
- ov = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_object_value_t));
+ ov = nxt_mp_alloc(vm->mem_pool, sizeof(njs_object_value_t));
if (nxt_fast_path(ov != NULL)) {
nxt_lvlhsh_init(&ov->object.hash);
return NJS_ERROR;
}
- dgst = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_digest_t));
+ dgst = nxt_mp_alloc(vm->mem_pool, sizeof(njs_digest_t));
if (nxt_slow_path(dgst == NULL)) {
njs_memory_error(vm);
return NJS_ERROR;
njs_string_get(&args[2], &key);
- ctx = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_hmac_t));
+ ctx = nxt_mp_alloc(vm->mem_pool, sizeof(njs_hmac_t));
if (nxt_slow_path(ctx == NULL)) {
njs_memory_error(vm);
return NJS_ERROR;
done:
- date = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_date_t));
+ date = nxt_mp_alloc(vm->mem_pool, sizeof(njs_date_t));
if (nxt_slow_path(date == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
njs_object_prop_t *prop;
nxt_lvlhsh_query_t lhq;
- error = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_object_t));
+ error = nxt_mp_alloc(vm->mem_pool, sizeof(njs_object_t));
if (nxt_slow_path(error == NULL)) {
njs_memory_error(vm);
return NULL;
error->__proto__ = &vm->prototypes[njs_error_prototype_index(type)].object;
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
if (name != NULL) {
lhq.key = nxt_string_value("name");
lhq.key_hash = nxt_djb_hash(lhq.key.start, lhq.key.length);
lhq.value = event;
lhq.proto = &njs_event_hash_proto;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
ret = nxt_lvlhsh_insert(&vm->events_hash, &lhq);
if (nxt_slow_path(ret != NXT_OK)) {
njs_string_get(&ev->id, &lhq.key);
lhq.key_hash = nxt_djb_hash(lhq.key.start, lhq.key.length);
lhq.proto = &njs_event_hash_proto;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
if (ev->posted) {
ev->posted = 0;
nxt_lvlhsh_query_t lhq;
do {
- ext = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_extern_t));
+ ext = nxt_mp_alloc(vm->mem_pool, sizeof(njs_extern_t));
if (nxt_slow_path(ext == NULL)) {
goto memory_error;
}
ext->data = external->data;
if (external->method != NULL) {
- function = nxt_mem_cache_zalloc(vm->mem_cache_pool,
- sizeof(njs_function_t));
+ function = nxt_mp_zalloc(vm->mem_pool, sizeof(njs_function_t));
if (nxt_slow_path(function == NULL)) {
goto memory_error;
}
/*
- * nxt_mem_cache_zalloc() does also:
+ * nxt_mp_zalloc() does also:
* nxt_lvlhsh_init(&function->object.hash);
* function->object.__proto__ = NULL;
*/
lhq.key = ext->name;
lhq.replace = 0;
lhq.value = ext;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
lhq.proto = &njs_extern_hash_proto;
ret = nxt_lvlhsh_insert(hash, &lhq);
}
obj = nxt_array_add(vm->external_objects, &njs_array_mem_proto,
- vm->mem_cache_pool);
+ vm->mem_pool);
if (nxt_slow_path(obj == NULL)) {
return NXT_ERROR;
}
return NXT_ERROR;
}
- ev = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- sizeof(njs_extern_value_t));
+ ev = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ sizeof(njs_extern_value_t));
if (nxt_slow_path(ev == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
lhq.proto = &njs_extern_value_hash_proto;
lhq.value = ev;
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
ret = nxt_lvlhsh_insert(&vm->externals_hash, &lhq);
if (nxt_slow_path(ret != NXT_OK)) {
len += pr->str.length + nxt_length(".");
}
- buf = nxt_mem_cache_zalloc(vm->mem_cache_pool, len);
+ buf = nxt_mp_zalloc(vm->mem_pool, len);
if (buf == NULL) {
return NXT_ERROR;
}
}
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
if (errn != 0) {
lhq.key = nxt_string_value("errno");
{
njs_function_t *function;
- function = nxt_mem_cache_zalloc(vm->mem_cache_pool, sizeof(njs_function_t));
+ function = nxt_mp_zalloc(vm->mem_pool, sizeof(njs_function_t));
if (nxt_fast_path(function != NULL)) {
/*
- * nxt_mem_cache_zalloc() does also:
+ * nxt_mp_zalloc() does also:
* nxt_lvlhsh_init(&function->object.hash);
* function->object.__proto__ = NULL;
*/
function->object.extensible = 1;
function->args_offset = 1;
- function->u.lambda = nxt_mem_cache_zalloc(vm->mem_cache_pool,
- sizeof(njs_function_lambda_t));
+ function->u.lambda = nxt_mp_zalloc(vm->mem_pool,
+ sizeof(njs_function_lambda_t));
if (nxt_slow_path(function->u.lambda == NULL)) {
njs_memory_error(vm);
return NULL;
size = sizeof(njs_function_t) + nesting * sizeof(njs_closure_t *);
- copy = nxt_mem_cache_alloc(vm->mem_cache_pool, size);
+ copy = nxt_mp_alloc(vm->mem_pool, size);
if (nxt_slow_path(copy == NULL)) {
njs_memory_error(vm);
return NULL;
njs_string_get(&prop->name, &lhq.key);
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
lhq.proto = &njs_object_hash_proto;
ret = nxt_lvlhsh_insert(&arguments->hash, &lhq);
return NULL;
}
- frame = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- spare_size);
+ frame = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t), spare_size);
if (nxt_slow_path(frame == NULL)) {
njs_memory_error(vm);
return NULL;
size = lambda->closure_size;
if (size != 0) {
- closure = nxt_mem_cache_align(vm->mem_cache_pool,
- sizeof(njs_value_t), size);
+ closure = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t), size);
if (nxt_slow_path(closure == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
if (frame->size != 0) {
vm->stack_size -= frame->size;
- nxt_mem_cache_free(vm->mem_cache_pool, frame);
+ nxt_mp_free(vm->mem_pool, frame);
}
frame = previous;
return NXT_ERROR;
}
- function = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_function_t));
+ function = nxt_mp_alloc(vm->mem_pool, sizeof(njs_function_t));
if (nxt_slow_path(function == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
function->args_offset = nargs;
size = nargs * sizeof(njs_value_t);
- values = nxt_mem_cache_alloc(vm->mem_cache_pool, size);
+ values = nxt_mp_alloc(vm->mem_pool, size);
if (nxt_slow_path(values == NULL)) {
njs_memory_error(vm);
- nxt_mem_cache_free(vm->mem_cache_pool, function);
+ nxt_mp_free(vm->mem_pool, function);
return NXT_ERROR;
}
size += size / 2;
}
- p = nxt_mem_cache_alloc(vm->mem_cache_pool, size);
+ p = nxt_mp_alloc(vm->mem_pool, size);
if (nxt_slow_path(p == NULL)) {
njs_memory_error(vm);
return NULL;
size = generator->code_end - generator->code_start;
memcpy(p, generator->code_start, size);
- nxt_mem_cache_free(vm->mem_cache_pool, generator->code_start);
+ nxt_mp_free(vm->mem_pool, generator->code_start);
generator->code_start = p;
generator->code_end = p + size;
return ret;
}
- patch = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_generator_patch_t));
+ patch = nxt_mp_alloc(vm->mem_pool, sizeof(njs_generator_patch_t));
if (nxt_slow_path(patch == NULL)) {
return NXT_ERROR;
}
next = patch->next;
- nxt_mem_cache_free(vm->mem_cache_pool, patch);
+ nxt_mp_free(vm->mem_pool, patch);
patch = next;
node = branch->right;
{
njs_generator_block_t *block;
- block = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_generator_block_t));
+ block = nxt_mp_alloc(vm->mem_pool, sizeof(njs_generator_block_t));
if (nxt_fast_path(block != NULL)) {
block->next = generator->block;
{
njs_generator_patch_t *patch;
- patch = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_generator_patch_t));
+ patch = nxt_mp_alloc(vm->mem_pool, sizeof(njs_generator_patch_t));
if (nxt_slow_path(patch == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
njs_code_update_offset(generator, patch);
next = patch->next;
- nxt_mem_cache_free(vm->mem_cache_pool, patch);
+ nxt_mp_free(vm->mem_pool, patch);
}
}
{
njs_generator_patch_t *patch;
- patch = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_generator_patch_t));
+ patch = nxt_mp_alloc(vm->mem_pool, sizeof(njs_generator_patch_t));
if (nxt_slow_path(patch == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
njs_generate_patch_block(vm, generator, block->exit);
- nxt_mem_cache_free(vm->mem_cache_pool, block);
+ nxt_mp_free(vm->mem_pool, block);
}
/* TODO: LABEL */
- patch = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_generator_patch_t));
+ patch = nxt_mp_alloc(vm->mem_pool, sizeof(njs_generator_patch_t));
if (nxt_fast_path(patch != NULL)) {
patch->next = block->continuation;
/* TODO: LABEL: loop and switch may have label, block must have label. */
- patch = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_generator_patch_t));
+ patch = nxt_mp_alloc(vm->mem_pool, sizeof(njs_generator_patch_t));
if (nxt_fast_path(patch != NULL)) {
patch->next = block->exit;
nxt_array_t *closure;
njs_generator_t *generator;
- generator = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- sizeof(njs_generator_t));
+ generator = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ sizeof(njs_generator_t));
if (nxt_slow_path(generator == NULL)) {
return NXT_ERROR;
}
lambda->start = generator->code_start;
}
- nxt_mem_cache_free(vm->mem_cache_pool, generator);
+ nxt_mp_free(vm->mem_pool, generator);
return ret;
}
generator->code_size = 128;
- p = nxt_mem_cache_alloc(vm->mem_cache_pool, generator->code_size);
+ p = nxt_mp_alloc(vm->mem_pool, generator->code_size);
if (nxt_slow_path(p == NULL)) {
return NXT_ERROR;
}
scope_size -= NJS_INDEX_GLOBAL_OFFSET;
}
- generator->local_scope = nxt_mem_cache_alloc(vm->mem_cache_pool,
- scope_size);
+ generator->local_scope = nxt_mp_alloc(vm->mem_pool, scope_size);
if (nxt_slow_path(generator->local_scope == NULL)) {
return NXT_ERROR;
}
if (vm->code == NULL) {
vm->code = nxt_array_create(4, sizeof(njs_vm_code_t),
- &njs_array_mem_proto, vm->mem_cache_pool);
+ &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(vm->code == NULL)) {
return NXT_ERROR;
}
}
- code = nxt_array_add(vm->code, &njs_array_mem_proto, vm->mem_cache_pool);
+ code = nxt_array_add(vm->code, &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(code == NULL)) {
return NXT_ERROR;
}
return NXT_OK;
}
- patch = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_generator_patch_t));
+ patch = nxt_mp_alloc(vm->mem_pool, sizeof(njs_generator_patch_t));
if (nxt_slow_path(patch == NULL)) {
return NXT_ERROR;
}
* all global variables are allocated in absolute scope
* to simplify global scope handling.
*/
- value = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- sizeof(njs_value_t));
+ value = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ sizeof(njs_value_t));
if (nxt_slow_path(value == NULL)) {
return NJS_INDEX_ERROR;
}
} else {
value = nxt_array_add(scope->values[0], &njs_array_mem_proto,
- vm->mem_cache_pool);
+ vm->mem_pool);
if (nxt_slow_path(value == NULL)) {
return NJS_INDEX_ERROR;
}
if (cache == NULL) {
cache = nxt_array_create(4, sizeof(njs_value_t *),
- &njs_array_mem_proto, vm->mem_cache_pool);
+ &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(cache == NULL)) {
return NXT_ERROR;
}
generator->index_cache = cache;
}
- last = nxt_array_add(cache, &njs_array_mem_proto, vm->mem_cache_pool);
+ last = nxt_array_add(cache, &njs_array_mem_proto, vm->mem_pool);
if (nxt_fast_path(last != NULL)) {
*last = index;
return NXT_OK;
{
njs_function_debug_t *debug;
- debug = nxt_array_add(vm->debug, &njs_array_mem_proto, vm->mem_cache_pool);
+ debug = nxt_array_add(vm->debug, &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(debug == NULL)) {
return NXT_ERROR;
}
typedef struct {
njs_vm_t *vm;
- nxt_mem_cache_pool_t *pool;
+ nxt_mp_t *pool;
nxt_uint_t depth;
const u_char *start;
const u_char *end;
njs_value_t key;
njs_vm_t *vm;
- nxt_mem_cache_pool_t *pool;
+ nxt_mp_t *pool;
njs_chb_node_t *nodes;
njs_chb_node_t *last;
nxt_array_t stack;
njs_string_prop_t string;
njs_json_parse_ctx_t ctx;
- value = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_value_t));
+ value = nxt_mp_alloc(vm->mem_pool, sizeof(njs_value_t));
if (nxt_slow_path(value == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
end = p + string.size;
ctx.vm = vm;
- ctx.pool = vm->mem_cache_pool;
+ ctx.pool = vm->mem_pool;
ctx.depth = 32;
ctx.start = string.start;
ctx.end = end;
parse->function = args[2].data.u.function;
if (nxt_array_init(&parse->stack, NULL, 4, sizeof(njs_json_state_t),
- &njs_array_mem_proto, vm->mem_cache_pool)
+ &njs_array_mem_proto, vm->mem_pool)
== NULL)
{
goto memory_error;
stringify = njs_vm_continuation(vm);
stringify->vm = vm;
- stringify->pool = vm->mem_cache_pool;
+ stringify->pool = vm->mem_pool;
stringify->u.cont.function = njs_json_stringify_continuation;
stringify->nodes = NULL;
stringify->last = NULL;
num = nxt_min(num, 10);
stringify->space.length = (size_t) num;
- stringify->space.start = nxt_mem_cache_alloc(vm->mem_cache_pool,
- (size_t) num + 1);
+ stringify->space.start = nxt_mp_alloc(vm->mem_pool,
+ (size_t) num + 1);
if (nxt_slow_path(stringify->space.start == NULL)) {
goto memory_error;
}
}
if (nxt_array_init(&stringify->stack, NULL, 4, sizeof(njs_json_state_t),
- &njs_array_mem_proto, vm->mem_cache_pool)
+ &njs_array_mem_proto, vm->mem_pool)
== NULL)
{
goto memory_error;
goto error_token;
}
- prop_name = nxt_mem_cache_alloc(ctx->pool, sizeof(njs_value_t));
+ prop_name = nxt_mp_alloc(ctx->pool, sizeof(njs_value_t));
if (nxt_slow_path(prop_name == NULL)) {
goto memory_error;
}
goto error_end;
}
- prop_value = nxt_mem_cache_alloc(ctx->pool, sizeof(njs_value_t));
+ prop_value = nxt_mp_alloc(ctx->pool, sizeof(njs_value_t));
if (nxt_slow_path(prop_value == NULL)) {
goto memory_error;
}
break;
}
- element = nxt_mem_cache_alloc(ctx->pool, sizeof(njs_value_t));
+ element = nxt_mp_alloc(ctx->pool, sizeof(njs_value_t));
if (nxt_slow_path(element == NULL)) {
njs_memory_error(ctx->vm);
return NULL;
if (surplus != 0) {
p = start;
- dst = nxt_mem_cache_alloc(ctx->pool, size);
+ dst = nxt_mp_alloc(ctx->pool, size);
if (nxt_slow_path(dst == NULL)) {
njs_memory_error(ctx->vm);;
return NULL;
lhq.key_hash = nxt_djb_hash(lhq.key.start, lhq.key.length);
lhq.replace = 1;
lhq.proto = &njs_object_hash_proto;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
if (njs_is_void(&parse->retval)) {
ret = nxt_lvlhsh_delete(&state->value.data.u.object->hash,
{
njs_json_state_t *state;
- state = nxt_array_add(&parse->stack, &njs_array_mem_proto,
- vm->mem_cache_pool);
+ state = nxt_array_add(&parse->stack, &njs_array_mem_proto, vm->mem_pool);
if (state != NULL) {
state = nxt_array_last(&parse->stack);
state->value = *value;
}
state = nxt_array_add(&stringify->stack, &njs_array_mem_proto,
- vm->mem_cache_pool);
+ vm->mem_pool);
if (nxt_slow_path(state == NULL)) {
njs_memory_error(vm);
return NULL;
njs_object_prop_t *prop;
nxt_lvlhsh_query_t lhq;
- wrapper = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_value_t));
+ wrapper = nxt_mp_alloc(vm->mem_pool, sizeof(njs_value_t));
if (nxt_slow_path(wrapper == NULL)) {
return NULL;
}
lhq.replace = 0;
lhq.proto = &njs_object_hash_proto;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
lhq.key = nxt_string_value("");
lhq.key_hash = NXT_DJB_HASH_INIT;
size = NJS_JSON_BUF_MIN_SIZE;
}
- n = nxt_mem_cache_alloc(stringify->pool, sizeof(njs_chb_node_t) + size);
+ n = nxt_mp_alloc(stringify->pool, sizeof(njs_chb_node_t) + size);
if (nxt_slow_path(n == NULL)) {
return NULL;
}
n = n->next;
}
- start = nxt_mem_cache_alloc(stringify->pool, size);
+ start = nxt_mp_alloc(stringify->pool, size);
if (nxt_slow_path(start == NULL)) {
return NXT_ERROR;
}
goto exception;
}
- stringify = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_json_stringify_t));
+ stringify = nxt_mp_alloc(vm->mem_pool, sizeof(njs_json_stringify_t));
if (nxt_slow_path(stringify == NULL)) {
goto memory_error;
}
stringify->vm = vm;
- stringify->pool = vm->mem_cache_pool;
+ stringify->pool = vm->mem_pool;
stringify->nodes = NULL;
stringify->last = NULL;
}
stringify->space.length = indent;
- stringify->space.start = nxt_mem_cache_alloc(vm->mem_cache_pool, indent);
+ stringify->space.start = nxt_mp_alloc(vm->mem_pool, indent);
if (nxt_slow_path(stringify->space.start == NULL)) {
goto memory_error;
}
nxt_memset(stringify->space.start, ' ', indent);
if (nxt_array_init(&stringify->stack, NULL, 4, sizeof(njs_json_state_t),
- &njs_array_mem_proto, vm->mem_cache_pool)
+ &njs_array_mem_proto, vm->mem_pool)
== NULL)
{
goto memory_error;
nxt_int_t
-njs_lexer_keywords_init(nxt_mem_cache_pool_t *mcp, nxt_lvlhsh_t *hash)
+njs_lexer_keywords_init(nxt_mp_t *mcp, nxt_lvlhsh_t *hash)
{
nxt_uint_t n;
nxt_lvlhsh_query_t lhq;
{
njs_object_t *object;
- object = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_object_t));
+ object = nxt_mp_alloc(vm->mem_pool, sizeof(njs_object_t));
if (nxt_fast_path(object != NULL)) {
nxt_lvlhsh_init(&object->hash);
return object;
}
- object = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_object_t));
+ object = nxt_mp_alloc(vm->mem_pool, sizeof(njs_object_t));
if (nxt_fast_path(object != NULL)) {
*object = *value->data.u.object;
nxt_uint_t index;
njs_object_value_t *ov;
- ov = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_object_value_t));
+ ov = nxt_mp_alloc(vm->mem_pool, sizeof(njs_object_value_t));
if (nxt_fast_path(ov != NULL)) {
nxt_lvlhsh_init(&ov->object.hash);
lhq.replace = 0;
lhq.proto = &njs_object_hash_proto;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
while (n != 0) {
njs_string_get(&prop->name, &lhq.key);
{
njs_object_prop_t *prop;
- prop = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- sizeof(njs_object_prop_t));
+ prop = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ sizeof(njs_object_prop_t));
if (nxt_fast_path(prop != NULL)) {
/* GC: retain. */
njs_function_t *function;
njs_object_prop_t *prop, *shared;
- prop = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_object_prop_t));
+ prop = nxt_mp_alloc(vm->mem_pool, sizeof(njs_object_prop_t));
if (nxt_slow_path(prop == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
pq->lhq.replace = 0;
pq->lhq.value = prop;
- pq->lhq.pool = vm->mem_cache_pool;
+ pq->lhq.pool = vm->mem_pool;
return nxt_lvlhsh_insert(&pq->prototype->hash, &pq->lhq);
}
} else {
pq.lhq.value = desc;
pq.lhq.replace = 0;
- pq.lhq.pool = vm->mem_cache_pool;
+ pq.lhq.pool = vm->mem_pool;
ret = nxt_lvlhsh_insert(&object->data.u.object->hash, &pq.lhq);
if (nxt_slow_path(ret != NXT_OK)) {
lhq.proto = &njs_object_hash_proto;
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
lhq.proto = &njs_object_hash_proto;
lhq.key = nxt_string_value("value");
lhq.key_hash = NJS_PROTOTYPE_HASH;
lhq.key = nxt_string_value("prototype");
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
lhq.proto = &njs_object_hash_proto;
ret = nxt_lvlhsh_insert(hash, &lhq);
lhq.key_hash = NJS_CONSTRUCTOR_HASH;
lhq.key = nxt_string_value("constructor");
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
lhq.proto = &njs_object_hash_proto;
ret = nxt_lvlhsh_insert(hash, &lhq);
lhq.proto = &njs_variables_hash_proto;
lhq.replace = 0;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
variables = &parser->scope->variables;
prev_variables = &prev->scope->variables;
}
}
- scope = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_parser_scope_t));
+ scope = nxt_mp_alloc(vm->mem_pool, sizeof(njs_parser_scope_t));
if (nxt_slow_path(scope == NULL)) {
return NXT_ERROR;
}
if (scope->type < NJS_SCOPE_BLOCK) {
values = nxt_array_create(4, sizeof(njs_value_t), &njs_array_mem_proto,
- vm->mem_cache_pool);
+ vm->mem_pool);
if (nxt_slow_path(values == NULL)) {
return NXT_ERROR;
}
if (node != NULL && node->token == NJS_TOKEN_BLOCK) {
parser->node = node->left;
- nxt_mem_cache_free(vm->mem_cache_pool, node);
+ nxt_mp_free(vm->mem_pool, node);
}
return token;
} else {
/* Anonymous function. */
- lambda = nxt_mem_cache_zalloc(vm->mem_cache_pool,
- sizeof(njs_function_lambda_t));
+ lambda = nxt_mp_zalloc(vm->mem_pool, sizeof(njs_function_lambda_t));
if (nxt_slow_path(lambda == NULL)) {
return NJS_TOKEN_ERROR;
}
if (node != NULL && node->token == NJS_TOKEN_BLOCK) {
parser->node = node->left;
- nxt_mem_cache_free(vm->mem_cache_pool, node);
+ nxt_mp_free(vm->mem_pool, node);
}
return token;
#define njs_parser_node_alloc(vm) \
- nxt_mem_cache_zalloc((vm)->mem_cache_pool, sizeof(njs_parser_node_t))
+ nxt_mp_zalloc((vm)->mem_pool, sizeof(njs_parser_node_t))
struct njs_parser_s {
njs_token_t njs_lexer_token(njs_lexer_t *lexer);
void njs_lexer_rollback(njs_lexer_t *lexer);
-nxt_int_t njs_lexer_keywords_init(nxt_mem_cache_pool_t *mcp,
- nxt_lvlhsh_t *hash);
+nxt_int_t njs_lexer_keywords_init(nxt_mp_t *mcp, nxt_lvlhsh_t *hash);
njs_token_t njs_lexer_keyword(njs_lexer_t *lexer);
njs_value_t *njs_parser_external(njs_vm_t *vm, njs_parser_t *parser);
njs_regexp_init(njs_vm_t *vm)
{
vm->regex_context = nxt_regex_context_create(njs_regexp_malloc,
- njs_regexp_free, vm->mem_cache_pool);
+ njs_regexp_free, vm->mem_pool);
if (nxt_slow_path(vm->regex_context == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
static void *
njs_regexp_malloc(size_t size, void *memory_data)
{
- return nxt_mem_cache_alloc(memory_data, size);
+ return nxt_mp_alloc(memory_data, size);
}
static void
njs_regexp_free(void *p, void *memory_data)
{
- nxt_mem_cache_free(memory_data, p);
+ nxt_mp_free(memory_data, p);
}
size += ((flags & NJS_REGEXP_IGNORE_CASE) != 0);
size += ((flags & NJS_REGEXP_MULTILINE) != 0);
- pattern = nxt_mem_cache_zalloc(vm->mem_cache_pool,
- sizeof(njs_regexp_pattern_t)
- + 1 + length + size + 1);
+ pattern = nxt_mp_zalloc(vm->mem_pool,
+ sizeof(njs_regexp_pattern_t)
+ + 1 + length + size + 1);
if (nxt_slow_path(pattern == NULL)) {
njs_memory_error(vm);
return NULL;
if (nxt_slow_path((u_int) ret != pattern->ncaptures)) {
njs_internal_error(vm, "regexp pattern compile failed");
- nxt_mem_cache_free(vm->mem_cache_pool, pattern);
+ nxt_mp_free(vm->mem_pool, pattern);
return NULL;
}
} else if (ret != NXT_DECLINED) {
- nxt_mem_cache_free(vm->mem_cache_pool, pattern);
+ nxt_mp_free(vm->mem_pool, pattern);
return NULL;
}
{
njs_regexp_t *regexp;
- regexp = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_regexp_t));
+ regexp = nxt_mp_alloc(vm->mem_pool, sizeof(njs_regexp_t));
if (nxt_fast_path(regexp != NULL)) {
nxt_lvlhsh_init(®exp->object.hash);
lhq.key = nxt_string_value("index");
lhq.replace = 0;
lhq.value = prop;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
lhq.proto = &njs_object_hash_proto;
ret = nxt_lvlhsh_insert(&array->object.hash, &lhq);
return NXT_ERROR;
}
- value = nxt_mem_cache_zalloc(vm->mem_cache_pool,
- sizeof(njs_opaque_value_t));
+ value = nxt_mp_zalloc(vm->mem_pool, sizeof(njs_opaque_value_t));
if (value == NULL) {
return NXT_ERROR;
}
console = external;
vm = console->vm;
- ev = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_ev_t));
+ ev = nxt_mp_alloc(vm->mem_pool, sizeof(njs_ev_t));
if (nxt_slow_path(ev == NULL)) {
return NULL;
}
lhq.replace = 0;
lhq.value = ev;
lhq.proto = &lvlhsh_proto;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
ret = nxt_lvlhsh_insert(&console->events, &lhq);
if (nxt_slow_path(ret != NXT_OK)) {
lhq.key_hash = nxt_djb_hash(lhq.key.start, lhq.key.length);
lhq.proto = &lvlhsh_proto;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
if (ev->link.prev != NULL) {
nxt_queue_remove(&ev->link);
fprintf(stderr, "nxt_lvlhsh_delete() failed\n");
}
- nxt_mem_cache_free(vm->mem_cache_pool, ev);
+ nxt_mp_free(vm->mem_pool, ev);
}
static void *
lvlhsh_pool_alloc(void *pool, size_t size, nxt_uint_t nalloc)
{
- return nxt_mem_cache_align(pool, size, size);
+ return nxt_mp_align(pool, size, size);
}
static void
lvlhsh_pool_free(void *pool, void *p, size_t size)
{
- nxt_mem_cache_free(pool, p);
+ nxt_mp_free(pool, p);
}
value->long_string.external = 0xff;
value->long_string.size = size;
- string = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_string_t));
+ string = nxt_mp_alloc(vm->mem_pool, sizeof(njs_string_t));
if (nxt_slow_path(string == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
total = size;
}
- string = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_string_t) + total);
+ string = nxt_mp_alloc(vm->mem_pool, sizeof(njs_string_t) + total);
if (nxt_fast_path(string != NULL)) {
value->long_string.data = string;
map_offset = njs_string_map_offset(size);
new_size = map_offset + njs_string_map_size(length);
- start = nxt_mem_cache_alloc(vm->mem_cache_pool, new_size);
+ start = nxt_mp_alloc(vm->mem_pool, new_size);
if (nxt_slow_path(start == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
/* This cannot fail. */
r->part = nxt_array_init(&r->parts, &r->array,
3, sizeof(njs_string_replace_part_t),
- &njs_array_mem_proto, vm->mem_cache_pool);
+ &njs_array_mem_proto, vm->mem_pool);
r->substitutions = NULL;
r->function = NULL;
} else {
if (r->part != r->parts.start) {
r->part = nxt_array_add(&r->parts, &njs_array_mem_proto,
- vm->mem_cache_pool);
+ vm->mem_pool);
if (nxt_slow_path(r->part == NULL)) {
return NXT_ERROR;
}
r->part = nxt_array_add(&r->parts, &njs_array_mem_proto,
- vm->mem_cache_pool);
+ vm->mem_pool);
if (nxt_slow_path(r->part == NULL)) {
return NXT_ERROR;
}
nxt_regex_match_data_free(r->match_data, vm->regex_context);
- nxt_array_destroy(&r->parts, &njs_array_mem_proto, vm->mem_cache_pool);
+ nxt_array_destroy(&r->parts, &njs_array_mem_proto, vm->mem_pool);
njs_string_copy(&vm->retval, &args[0]);
r->u.cont.function = njs_string_replace_regexp_continuation;
njs_set_invalid(&r->retval);
- arguments = nxt_mem_cache_alloc(vm->mem_cache_pool,
- (n + 3) * sizeof(njs_value_t));
+ arguments = nxt_mp_alloc(vm->mem_pool, (n + 3) * sizeof(njs_value_t));
if (nxt_slow_path(arguments == NULL)) {
return NXT_ERROR;
}
njs_string_subst_t *s;
r->substitutions = nxt_array_create(4, sizeof(njs_string_subst_t),
- &njs_array_mem_proto, vm->mem_cache_pool);
+ &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(r->substitutions == NULL)) {
return NXT_ERROR;
copy:
if (s == NULL) {
- s = nxt_array_add(r->substitutions, &njs_array_mem_proto,
- vm->mem_cache_pool);
+ s = nxt_array_add(r->substitutions, &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(s == NULL)) {
return NXT_ERROR;
}
goto copy;
}
- s = nxt_array_add(r->substitutions, &njs_array_mem_proto,
- vm->mem_cache_pool);
+ s = nxt_array_add(r->substitutions, &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(s == NULL)) {
return NXT_ERROR;
}
last = r->substitutions->items;
- part = nxt_array_add_multiple(&r->parts, &njs_array_mem_proto,
- vm->mem_cache_pool, last + 1);
+ part = nxt_array_add_multiple(&r->parts, &njs_array_mem_proto, vm->mem_pool,
+ last + 1);
if (nxt_slow_path(part == NULL)) {
return NXT_ERROR;
}
/* GC: release valid values. */
}
- nxt_array_destroy(&r->parts, &njs_array_mem_proto, vm->mem_cache_pool);
+ nxt_array_destroy(&r->parts, &njs_array_mem_proto, vm->mem_pool);
return NXT_OK;
}
}
}
- data = nxt_mem_cache_alloc(vm->mem_cache_pool, size + 1);
+ data = nxt_mp_alloc(vm->mem_pool, size + 1);
if (nxt_slow_path(data == NULL)) {
njs_memory_error(vm);
return NULL;
}
}
- value = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- value_size + size);
+ value = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ value_size + size);
if (nxt_slow_path(value == NULL)) {
return NJS_INDEX_NONE;
}
lhq.replace = 0;
lhq.value = value;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
values_hash = runtime ? &vm->values_hash : &vm->shared->values_hash;
delay = args[2].data.u.number;
}
- event = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_event_t));
+ event = nxt_mp_alloc(vm->mem_pool, sizeof(njs_event_t));
if (nxt_slow_path(event == NULL)) {
goto memory_error;
}
event->posted = 0;
if (event->nargs != 0) {
- event->args = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_value_t) * event->nargs);
+ event->args = nxt_mp_alloc(vm->mem_pool,
+ sizeof(njs_value_t) * event->nargs);
if (nxt_slow_path(event->args == NULL)) {
goto memory_error;
}
(unsigned) args[1].data.u.number);
lhq.key_hash = nxt_djb_hash(lhq.key.start, lhq.key.length);
lhq.proto = &njs_event_hash_proto;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
ret = nxt_lvlhsh_find(&vm->events_hash, &lhq);
if (ret == NXT_OK) {
lhq.replace = 0;
lhq.value = var;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
ret = nxt_lvlhsh_insert(&scope->variables, &lhq);
return var;
}
- nxt_mem_cache_free(vm->mem_cache_pool, var->name.start);
- nxt_mem_cache_free(vm->mem_cache_pool, var);
+ nxt_mp_free(vm->mem_pool, var->name.start);
+ nxt_mp_free(vm->mem_pool, var);
njs_type_error(vm, "lvlhsh insert failed");
lhq.proto = &njs_reference_hash_proto;
lhq.replace = 0;
lhq.value = node;
- lhq.pool = vm->mem_cache_pool;
+ lhq.pool = vm->mem_pool;
ret = nxt_lvlhsh_insert(&scope->references, &lhq);
* global variables should be allocated in absolute scope
* to share them among consecutive VM invocations.
*/
- value = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
- sizeof(njs_value_t));
+ value = nxt_mp_align(vm->mem_pool, sizeof(njs_value_t),
+ sizeof(njs_value_t));
if (nxt_slow_path(value == NULL)) {
njs_memory_error(vm);
return NULL;
if (values == NULL) {
values = nxt_array_create(4, sizeof(njs_value_t),
- &njs_array_mem_proto, vm->mem_cache_pool);
+ &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(values == NULL)) {
return NULL;
}
vr->scope->values[scope_index] = values;
}
- value = nxt_array_add(values, &njs_array_mem_proto, vm->mem_cache_pool);
+ value = nxt_array_add(values, &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(value == NULL)) {
return NULL;
}
njs_ret_t ret;
njs_variable_t *var;
- var = nxt_mem_cache_zalloc(vm->mem_cache_pool, sizeof(njs_variable_t));
+ var = nxt_mp_zalloc(vm->mem_pool, sizeof(njs_variable_t));
if (nxt_slow_path(var == NULL)) {
njs_memory_error(vm);
return NULL;
return var;
}
- nxt_mem_cache_free(vm->mem_cache_pool, var);
+ nxt_mp_free(vm->mem_pool, var);
njs_memory_error(vm);
{
dst->length = src->length;
- dst->start = nxt_mem_cache_alloc(vm->mem_cache_pool, src->length);
+ dst->start = nxt_mp_alloc(vm->mem_pool, src->length);
if (nxt_slow_path(dst->start != NULL)) {
(void) memcpy(dst->start, src->start, src->length);
if (frame->native.size != 0) {
vm->stack_size -= frame->native.size;
- nxt_mem_cache_free(vm->mem_cache_pool, frame);
+ nxt_mp_free(vm->mem_pool, frame);
}
}
}
if ((u_char *) string + sizeof(njs_string_t)
!= string->start)
{
- nxt_memcache_pool_free(vm->mem_cache_pool,
+ nxt_memcache_pool_free(vm->mem_pool,
string->start);
}
- nxt_memcache_pool_free(vm->mem_cache_pool, string);
+ nxt_memcache_pool_free(vm->mem_pool, string);
}
#endif
}
size = sizeof(njs_function_t) + nesting * sizeof(njs_closure_t *);
- function = nxt_mem_cache_zalloc(vm->mem_cache_pool, size);
+ function = nxt_mp_zalloc(vm->mem_pool, size);
if (nxt_slow_path(function == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
pq.lhq.replace = 0;
pq.lhq.value = prop;
- pq.lhq.pool = vm->mem_cache_pool;
+ pq.lhq.pool = vm->mem_pool;
ret = nxt_lvlhsh_insert(&object->data.u.object->hash, &pq.lhq);
if (nxt_slow_path(ret != NXT_OK)) {
njs_vmcode_prop_foreach_t *code;
if (njs_is_object(object)) {
- next = nxt_mem_cache_alloc(vm->mem_cache_pool,
- sizeof(njs_property_next_t));
+ next = nxt_mp_alloc(vm->mem_pool, sizeof(njs_property_next_t));
if (nxt_slow_path(next == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
}
}
- nxt_mem_cache_free(vm->mem_cache_pool, next);
+ nxt_mp_free(vm->mem_pool, next);
} else if (njs_is_external(object)) {
ext_proto = object->external.proto;
njs_vmcode_try_start_t *try_start;
if (vm->top_frame->exception.catch != NULL) {
- e = nxt_mem_cache_alloc(vm->mem_cache_pool, sizeof(njs_exception_t));
+ e = nxt_mp_alloc(vm->mem_pool, sizeof(njs_exception_t));
if (nxt_slow_path(e == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
} else {
vm->top_frame->exception = *e;
- nxt_mem_cache_free(vm->mem_cache_pool, e);
+ nxt_mp_free(vm->mem_pool, e);
}
return (njs_ret_t) offset;
size = value.short_string.size;
if (size != NJS_STRING_LONG) {
- start = nxt_mem_cache_alloc(vm->mem_cache_pool, size);
+ start = nxt_mp_alloc(vm->mem_pool, size);
if (nxt_slow_path(start == NULL)) {
njs_memory_error(vm);
return NXT_ERROR;
prev = &be[i];
}
- p = nxt_mem_cache_alloc(vm->mem_cache_pool, len);
+ p = nxt_mp_alloc(vm->mem_pool, len);
if (p == NULL) {
njs_memory_error(vm);
return NXT_ERROR;
native_frame = &frame->native;
function = native_frame->function;
- be = nxt_array_add(vm->backtrace, &njs_array_mem_proto, vm->mem_cache_pool);
+ be = nxt_array_add(vm->backtrace, &njs_array_mem_proto, vm->mem_pool);
if (nxt_slow_path(be == NULL)) {
return NXT_ERROR;
}
void *
njs_lvlhsh_alloc(void *data, size_t size, nxt_uint_t nalloc)
{
- return nxt_mem_cache_align(data, size, size);
+ return nxt_mp_align(data, size, size);
}
void
njs_lvlhsh_free(void *data, void *p, size_t size)
{
- nxt_mem_cache_free(data, p);
+ nxt_mp_free(data, p);
}
#include <nxt_regex.h>
#include <nxt_random.h>
#include <nxt_djb_hash.h>
-#include <nxt_mem_cache_pool.h>
+#include <nxt_mp.h>
#define NJS_MAX_STACK_SIZE (16 * 1024 * 1024)
njs_object_prototype_t prototypes[NJS_PROTOTYPE_MAX];
njs_function_t constructors[NJS_CONSTRUCTOR_MAX];
- nxt_mem_cache_pool_t *mem_cache_pool;
+ nxt_mp_t *mem_pool;
njs_value_t *global_scope;
size_t scope_size;
typedef struct {
nxt_lvlhsh_t hash;
const njs_extern_t *proto;
- nxt_mem_cache_pool_t *mem_cache_pool;
+ nxt_mp_t *pool;
uint32_t a;
nxt_str_t uri;
static void *
lvlhsh_unit_test_pool_alloc(void *pool, size_t size, nxt_uint_t nalloc)
{
- return nxt_mem_cache_align(pool, size, size);
+ return nxt_mp_align(pool, size, size);
}
static void
lvlhsh_unit_test_pool_free(void *pool, void *p, size_t size)
{
- nxt_mem_cache_free(pool, p);
+ nxt_mp_free(pool, p);
}
static njs_unit_test_prop_t *
-lvlhsh_unit_test_alloc(nxt_mem_cache_pool_t *pool, const njs_value_t *name,
+lvlhsh_unit_test_alloc(nxt_mp_t *pool, const njs_value_t *name,
const njs_value_t *value)
{
njs_unit_test_prop_t *prop;
- prop = nxt_mem_cache_alloc(pool, sizeof(njs_unit_test_prop_t));
+ prop = nxt_mp_alloc(pool, sizeof(njs_unit_test_prop_t));
if (prop == NULL) {
return NULL;
}
lhq.replace = 1;
lhq.value = (void *) prop;
lhq.proto = &lvlhsh_proto;
- lhq.pool = r->mem_cache_pool;
+ lhq.pool = r->pool;
switch (nxt_lvlhsh_insert(&r->hash, &lhq)) {
njs_string_create(vm, &name, key->start, key->length, 0);
njs_string_create(vm, &val, value->start, value->length, 0);
- prop = lvlhsh_unit_test_alloc(vm->mem_cache_pool, &name, &val);
+ prop = lvlhsh_unit_test_alloc(vm->mem_pool, &name, &val);
if (prop == NULL) {
njs_memory_error(vm);
return NXT_ERROR;
return NJS_ERROR;
}
- value = nxt_mem_cache_zalloc(r->mem_cache_pool, sizeof(njs_opaque_value_t));
+ value = nxt_mp_zalloc(r->pool, sizeof(njs_opaque_value_t));
if (value == NULL) {
goto memory_error;
}
- sr = nxt_mem_cache_zalloc(r->mem_cache_pool, sizeof(njs_unit_test_req_t));
+ sr = nxt_mp_zalloc(r->pool, sizeof(njs_unit_test_req_t));
if (sr == NULL) {
goto memory_error;
}
sr->uri = uri;
- sr->mem_cache_pool = r->mem_cache_pool;
+ sr->pool = r->pool;
sr->proto = r->proto;
ret = njs_vm_external_create(vm, value, sr->proto, sr);
return NXT_ERROR;
}
- requests = nxt_mem_cache_zalloc(vm->mem_cache_pool,
- nxt_nitems(nxt_test_requests)
- * sizeof(njs_unit_test_req_t));
+ requests = nxt_mp_zalloc(vm->mem_pool,
+ nxt_nitems(nxt_test_requests)
+ * sizeof(njs_unit_test_req_t));
if (requests == NULL) {
return NXT_ERROR;
}
for (i = 0; i < nxt_nitems(nxt_test_requests); i++) {
requests[i] = nxt_test_requests[i].request;
- requests[i].mem_cache_pool = vm->mem_cache_pool;
+ requests[i].pool = vm->mem_pool;
requests[i].proto = proto;
ret = njs_vm_external_create(vm, njs_value_arg(&requests[i].value),
}
for (j = 0; j < nxt_nitems(nxt_test_requests[i].props); j++) {
- prop = lvlhsh_unit_test_alloc(vm->mem_cache_pool,
+ prop = lvlhsh_unit_test_alloc(vm->mem_pool,
&nxt_test_requests[i].props[j].name,
&nxt_test_requests[i].props[j].value);
$(NXT_BUILDDIR)/nxt_malloc.o \
$(NXT_BUILDDIR)/nxt_trace.o \
$(NXT_BUILDDIR)/nxt_time.o \
- $(NXT_BUILDDIR)/nxt_mem_cache_pool.o \
+ $(NXT_BUILDDIR)/nxt_mp.o \
ar -r -c $(NXT_BUILDDIR)/libnxt.a \
$(NXT_BUILDDIR)/nxt_diyfp.o \
$(NXT_BUILDDIR)/nxt_malloc.o \
$(NXT_BUILDDIR)/nxt_time.o \
$(NXT_BUILDDIR)/nxt_trace.o \
- $(NXT_BUILDDIR)/nxt_mem_cache_pool.o \
+ $(NXT_BUILDDIR)/nxt_mp.o \
$(NXT_BUILDDIR)/nxt_diyfp.o: \
$(NXT_LIB)/nxt_types.h \
-I$(NXT_LIB) \
$(NXT_LIB)/nxt_trace.c
-$(NXT_BUILDDIR)/nxt_mem_cache_pool.o: \
+$(NXT_BUILDDIR)/nxt_mp.o: \
$(NXT_LIB)/nxt_types.h \
$(NXT_LIB)/nxt_clang.h \
$(NXT_LIB)/nxt_alignment.h \
$(NXT_LIB)/nxt_queue.h \
$(NXT_LIB)/nxt_rbtree.h \
- $(NXT_LIB)/nxt_mem_cache_pool.h \
- $(NXT_LIB)/nxt_mem_cache_pool.c \
+ $(NXT_LIB)/nxt_mp.h \
+ $(NXT_LIB)/nxt_mp.c \
- $(NXT_CC) -c -o $(NXT_BUILDDIR)/nxt_mem_cache_pool.o $(NXT_CFLAGS) \
+ $(NXT_CC) -c -o $(NXT_BUILDDIR)/nxt_mp.o $(NXT_CFLAGS) \
-I$(NXT_LIB) \
- $(NXT_LIB)/nxt_mem_cache_pool.c
+ $(NXT_LIB)/nxt_mp.c
include $(NXT_LIB)/test/Makefile
+++ /dev/null
-
-/*
- * Copyright (C) Igor Sysoev
- * Copyright (C) NGINX, Inc.
- */
-
-#ifndef _NXT_MEM_CACHE_POOL_H_INCLUDED_
-#define _NXT_MEM_CACHE_POOL_H_INCLUDED_
-
-
-typedef struct nxt_mem_cache_pool_s nxt_mem_cache_pool_t;
-
-
-NXT_EXPORT nxt_mem_cache_pool_t *
- nxt_mem_cache_pool_create(const nxt_mem_proto_t *proto, void *mem,
- void *trace, size_t cluster_size, size_t page_alignment, size_t page_size,
- size_t min_chunk_size)
- NXT_MALLOC_LIKE;
-NXT_EXPORT nxt_mem_cache_pool_t *
- nxt_mem_cache_pool_fast_create(const nxt_mem_proto_t *proto, void *mem,
- void *trace, size_t cluster_size, size_t page_alignment, size_t page_size,
- size_t min_chunk_size)
- NXT_MALLOC_LIKE;
-NXT_EXPORT nxt_bool_t nxt_mem_cache_pool_is_empty(nxt_mem_cache_pool_t *pool);
-NXT_EXPORT void nxt_mem_cache_pool_destroy(nxt_mem_cache_pool_t *pool);
-
-NXT_EXPORT void *nxt_mem_cache_alloc(nxt_mem_cache_pool_t *pool, size_t size)
- NXT_MALLOC_LIKE;
-NXT_EXPORT void *nxt_mem_cache_zalloc(nxt_mem_cache_pool_t *pool, size_t size)
- NXT_MALLOC_LIKE;
-NXT_EXPORT void *nxt_mem_cache_align(nxt_mem_cache_pool_t *pool,
- size_t alignment, size_t size)
- NXT_MALLOC_LIKE;
-NXT_EXPORT void *nxt_mem_cache_zalign(nxt_mem_cache_pool_t *pool,
- size_t alignment, size_t size)
- NXT_MALLOC_LIKE;
-NXT_EXPORT void nxt_mem_cache_free(nxt_mem_cache_pool_t *pool, void *p);
-
-
-#endif /* _NXT_MEM_CACHE_POOL_H_INCLUDED_ */
#include <nxt_string.h>
#include <nxt_queue.h>
#include <nxt_rbtree.h>
-#include <nxt_mem_cache_pool.h>
+#include <nxt_mp.h>
#include <string.h>
#include <stdint.h>
nxt_queue_link_t link;
/*
- * Size of chunks or page shifted by pool->chunk_size_shift.
+ * Size of chunks or page shifted by mp->chunk_size_shift.
* Zero means that page is free.
*/
uint8_t size;
/* Chunk bitmap. There can be no more than 32 chunks in a page. */
uint8_t map[4];
-} nxt_mem_cache_page_t;
+} nxt_mp_page_t;
typedef enum {
/* Block of cluster. The block is allocated apart of the cluster. */
- NXT_MEM_CACHE_CLUSTER_BLOCK = 0,
+ NXT_MP_CLUSTER_BLOCK = 0,
/*
* Block of large allocation.
* The block is allocated apart of the allocation.
*/
- NXT_MEM_CACHE_DISCRETE_BLOCK,
+ NXT_MP_DISCRETE_BLOCK,
/*
* Block of large allocation.
* The block is allocated just after of the allocation.
*/
- NXT_MEM_CACHE_EMBEDDED_BLOCK,
-} nxt_mem_cache_block_type_t;
+ NXT_MP_EMBEDDED_BLOCK,
+} nxt_mp_block_type_t;
typedef struct {
NXT_RBTREE_NODE (node);
- nxt_mem_cache_block_type_t type:8;
+ nxt_mp_block_type_t type:8;
/* Block size must be less than 4G. */
uint32_t size;
u_char *start;
- nxt_mem_cache_page_t pages[];
-} nxt_mem_cache_block_t;
+ nxt_mp_page_t pages[];
+} nxt_mp_block_t;
typedef struct {
/* Maximum number of free chunks in chunked page. */
uint8_t chunks;
-} nxt_mem_cache_slot_t;
+} nxt_mp_slot_t;
-struct nxt_mem_cache_pool_s {
- /* rbtree of nxt_mem_cache_block_t. */
+struct nxt_mp_s {
+ /* rbtree of nxt_mp_block_t. */
nxt_rbtree_t blocks;
nxt_queue_t free_pages;
void *mem;
void *trace;
- nxt_mem_cache_slot_t slots[];
+ nxt_mp_slot_t slots[];
};
-#define nxt_mem_cache_chunk_is_free(map, chunk) \
+#define nxt_mp_chunk_is_free(map, chunk) \
((map[chunk / 8] & (0x80 >> (chunk & 7))) == 0)
-#define nxt_mem_cache_chunk_set_free(map, chunk) \
+#define nxt_mp_chunk_set_free(map, chunk) \
map[chunk / 8] &= ~(0x80 >> (chunk & 7))
-#define nxt_mem_cache_free_junk(p, size) \
+#define nxt_mp_free_junk(p, size) \
nxt_memset((p), 0x5A, size)
((((value) - 1) & (value)) == 0)
-static nxt_uint_t nxt_mem_cache_shift(nxt_uint_t n);
+static nxt_uint_t nxt_mp_shift(nxt_uint_t n);
#if !(NXT_DEBUG_MEMORY)
-static void *nxt_mem_cache_alloc_small(nxt_mem_cache_pool_t *pool, size_t size);
-static nxt_uint_t nxt_mem_cache_alloc_chunk(u_char *map, nxt_uint_t size);
-static nxt_mem_cache_page_t *
- nxt_mem_cache_alloc_page(nxt_mem_cache_pool_t *pool);
-static nxt_mem_cache_block_t *
- nxt_mem_cache_alloc_cluster(nxt_mem_cache_pool_t *pool);
+static void *nxt_mp_alloc_small(nxt_mp_t *mp, size_t size);
+static nxt_uint_t nxt_mp_alloc_chunk(u_char *map, nxt_uint_t size);
+static nxt_mp_page_t *nxt_mp_alloc_page(nxt_mp_t *mp);
+static nxt_mp_block_t *nxt_mp_alloc_cluster(nxt_mp_t *mp);
#endif
-static void *nxt_mem_cache_alloc_large(nxt_mem_cache_pool_t *pool,
- size_t alignment, size_t size);
-static intptr_t nxt_mem_cache_rbtree_compare(nxt_rbtree_node_t *node1,
+static void *nxt_mp_alloc_large(nxt_mp_t *mp, size_t alignment, size_t size);
+static intptr_t nxt_mp_rbtree_compare(nxt_rbtree_node_t *node1,
nxt_rbtree_node_t *node2);
-static nxt_mem_cache_block_t *nxt_mem_cache_find_block(nxt_rbtree_t *tree,
+static nxt_mp_block_t *nxt_mp_find_block(nxt_rbtree_t *tree,
+ u_char *p);
+static const char *nxt_mp_chunk_free(nxt_mp_t *mp, nxt_mp_block_t *cluster,
u_char *p);
-static const char *nxt_mem_cache_chunk_free(nxt_mem_cache_pool_t *pool,
- nxt_mem_cache_block_t *cluster, u_char *p);
-nxt_mem_cache_pool_t *
-nxt_mem_cache_pool_create(const nxt_mem_proto_t *proto, void *mem,
+nxt_mp_t *
+nxt_mp_create(const nxt_mem_proto_t *proto, void *mem,
void *trace, size_t cluster_size, size_t page_alignment, size_t page_size,
size_t min_chunk_size)
{
return NULL;
}
- return nxt_mem_cache_pool_fast_create(proto, mem, trace,
- cluster_size, page_alignment,
- page_size, min_chunk_size);
+ return nxt_mp_fast_create(proto, mem, trace, cluster_size, page_alignment,
+ page_size, min_chunk_size);
}
-nxt_mem_cache_pool_t *
-nxt_mem_cache_pool_fast_create(const nxt_mem_proto_t *proto, void *mem,
+nxt_mp_t *
+nxt_mp_fast_create(const nxt_mem_proto_t *proto, void *mem,
void *trace, size_t cluster_size, size_t page_alignment, size_t page_size,
size_t min_chunk_size)
{
- nxt_uint_t slots, chunk_size;
- nxt_mem_cache_slot_t *slot;
- nxt_mem_cache_pool_t *pool;
+ nxt_mp_t *mp;
+ nxt_uint_t slots, chunk_size;
+ nxt_mp_slot_t *slot;
slots = 0;
chunk_size = page_size;
chunk_size /= 2;
} while (chunk_size > min_chunk_size);
- pool = proto->zalloc(mem, sizeof(nxt_mem_cache_pool_t)
- + slots * sizeof(nxt_mem_cache_slot_t));
+ mp = proto->zalloc(mem, sizeof(nxt_mp_t) + slots * sizeof(nxt_mp_slot_t));
- if (nxt_fast_path(pool != NULL)) {
- pool->proto = proto;
- pool->mem = mem;
- pool->trace = trace;
+ if (nxt_fast_path(mp != NULL)) {
+ mp->proto = proto;
+ mp->mem = mem;
+ mp->trace = trace;
- pool->page_size = page_size;
- pool->page_alignment = nxt_max(page_alignment, NXT_MAX_ALIGNMENT);
- pool->cluster_size = cluster_size;
+ mp->page_size = page_size;
+ mp->page_alignment = nxt_max(page_alignment, NXT_MAX_ALIGNMENT);
+ mp->cluster_size = cluster_size;
- slot = pool->slots;
+ slot = mp->slots;
do {
nxt_queue_init(&slot->pages);
chunk_size *= 2;
} while (chunk_size < page_size);
- pool->chunk_size_shift = nxt_mem_cache_shift(min_chunk_size);
- pool->page_size_shift = nxt_mem_cache_shift(page_size);
+ mp->chunk_size_shift = nxt_mp_shift(min_chunk_size);
+ mp->page_size_shift = nxt_mp_shift(page_size);
- nxt_rbtree_init(&pool->blocks, nxt_mem_cache_rbtree_compare);
+ nxt_rbtree_init(&mp->blocks, nxt_mp_rbtree_compare);
- nxt_queue_init(&pool->free_pages);
+ nxt_queue_init(&mp->free_pages);
}
- return pool;
+ return mp;
}
static nxt_uint_t
-nxt_mem_cache_shift(nxt_uint_t n)
+nxt_mp_shift(nxt_uint_t n)
{
nxt_uint_t shift;
nxt_bool_t
-nxt_mem_cache_pool_is_empty(nxt_mem_cache_pool_t *pool)
+nxt_mp_is_empty(nxt_mp_t *mp)
{
- return (nxt_rbtree_is_empty(&pool->blocks)
- && nxt_queue_is_empty(&pool->free_pages));
+ return (nxt_rbtree_is_empty(&mp->blocks)
+ && nxt_queue_is_empty(&mp->free_pages));
}
void
-nxt_mem_cache_pool_destroy(nxt_mem_cache_pool_t *pool)
+nxt_mp_destroy(nxt_mp_t *mp)
{
- void *p;
- nxt_rbtree_node_t *node, *next;
- nxt_mem_cache_block_t *block;
+ void *p;
+ nxt_mp_block_t *block;
+ nxt_rbtree_node_t *node, *next;
- next = nxt_rbtree_root(&pool->blocks);
+ next = nxt_rbtree_root(&mp->blocks);
- while (next != nxt_rbtree_sentinel(&pool->blocks)) {
+ while (next != nxt_rbtree_sentinel(&mp->blocks)) {
- node = nxt_rbtree_destroy_next(&pool->blocks, &next);
- block = (nxt_mem_cache_block_t *) node;
+ node = nxt_rbtree_destroy_next(&mp->blocks, &next);
+ block = (nxt_mp_block_t *) node;
p = block->start;
- if (block->type != NXT_MEM_CACHE_EMBEDDED_BLOCK) {
- pool->proto->free(pool->mem, block);
+ if (block->type != NXT_MP_EMBEDDED_BLOCK) {
+ mp->proto->free(mp->mem, block);
}
- pool->proto->free(pool->mem, p);
+ mp->proto->free(mp->mem, p);
}
- pool->proto->free(pool->mem, pool);
+ mp->proto->free(mp->mem, mp);
}
void *
-nxt_mem_cache_alloc(nxt_mem_cache_pool_t *pool, size_t size)
+nxt_mp_alloc(nxt_mp_t *mp, size_t size)
{
- if (pool->proto->trace != NULL) {
- pool->proto->trace(pool->trace, "mem cache alloc: %zd", size);
+ if (mp->proto->trace != NULL) {
+ mp->proto->trace(mp->trace, "mem cache alloc: %zd", size);
}
#if !(NXT_DEBUG_MEMORY)
- if (size <= pool->page_size) {
- return nxt_mem_cache_alloc_small(pool, size);
+ if (size <= mp->page_size) {
+ return nxt_mp_alloc_small(mp, size);
}
#endif
- return nxt_mem_cache_alloc_large(pool, NXT_MAX_ALIGNMENT, size);
+ return nxt_mp_alloc_large(mp, NXT_MAX_ALIGNMENT, size);
}
void *
-nxt_mem_cache_zalloc(nxt_mem_cache_pool_t *pool, size_t size)
+nxt_mp_zalloc(nxt_mp_t *mp, size_t size)
{
void *p;
- p = nxt_mem_cache_alloc(pool, size);
+ p = nxt_mp_alloc(mp, size);
if (nxt_fast_path(p != NULL)) {
nxt_memzero(p, size);
void *
-nxt_mem_cache_align(nxt_mem_cache_pool_t *pool, size_t alignment, size_t size)
+nxt_mp_align(nxt_mp_t *mp, size_t alignment, size_t size)
{
- if (pool->proto->trace != NULL) {
- pool->proto->trace(pool->trace,
- "mem cache align: @%zd:%zd", alignment, size);
+ if (mp->proto->trace != NULL) {
+ mp->proto->trace(mp->trace,
+ "mem cache align: @%zd:%zd", alignment, size);
}
/* Alignment must be a power of 2. */
#if !(NXT_DEBUG_MEMORY)
- if (size <= pool->page_size && alignment <= pool->page_alignment) {
+ if (size <= mp->page_size && alignment <= mp->page_alignment) {
size = nxt_max(size, alignment);
- if (size <= pool->page_size) {
- return nxt_mem_cache_alloc_small(pool, size);
+ if (size <= mp->page_size) {
+ return nxt_mp_alloc_small(mp, size);
}
}
#endif
- return nxt_mem_cache_alloc_large(pool, alignment, size);
+ return nxt_mp_alloc_large(mp, alignment, size);
}
return NULL;
void *
-nxt_mem_cache_zalign(nxt_mem_cache_pool_t *pool, size_t alignment, size_t size)
+nxt_mp_zalign(nxt_mp_t *mp, size_t alignment, size_t size)
{
void *p;
- p = nxt_mem_cache_align(pool, alignment, size);
+ p = nxt_mp_align(mp, alignment, size);
if (nxt_fast_path(p != NULL)) {
nxt_memzero(p, size);
#if !(NXT_DEBUG_MEMORY)
nxt_inline u_char *
-nxt_mem_cache_page_addr(nxt_mem_cache_pool_t *pool, nxt_mem_cache_page_t *page)
+nxt_mp_page_addr(nxt_mp_t *mp, nxt_mp_page_t *page)
{
- nxt_mem_cache_block_t *block;
+ nxt_mp_block_t *block;
- block = (nxt_mem_cache_block_t *)
- ((u_char *) page - page->number * sizeof(nxt_mem_cache_page_t)
- - offsetof(nxt_mem_cache_block_t, pages));
+ block = (nxt_mp_block_t *)
+ ((u_char *) page - page->number * sizeof(nxt_mp_page_t)
+ - offsetof(nxt_mp_block_t, pages));
- return block->start + (page->number << pool->page_size_shift);
+ return block->start + (page->number << mp->page_size_shift);
}
static void *
-nxt_mem_cache_alloc_small(nxt_mem_cache_pool_t *pool, size_t size)
+nxt_mp_alloc_small(nxt_mp_t *mp, size_t size)
{
- u_char *p;
- nxt_queue_link_t *link;
- nxt_mem_cache_page_t *page;
- nxt_mem_cache_slot_t *slot;
+ u_char *p;
+ nxt_mp_page_t *page;
+ nxt_mp_slot_t *slot;
+ nxt_queue_link_t *link;
p = NULL;
- if (size <= pool->page_size / 2) {
+ if (size <= mp->page_size / 2) {
/* Find a slot with appropriate chunk size. */
- for (slot = pool->slots; slot->size < size; slot++) { /* void */ }
+ for (slot = mp->slots; slot->size < size; slot++) { /* void */ }
size = slot->size;
if (nxt_fast_path(!nxt_queue_is_empty(&slot->pages))) {
link = nxt_queue_first(&slot->pages);
- page = nxt_queue_link_data(link, nxt_mem_cache_page_t, link);
+ page = nxt_queue_link_data(link, nxt_mp_page_t, link);
- p = nxt_mem_cache_page_addr(pool, page);
- p += nxt_mem_cache_alloc_chunk(page->map, size);
+ p = nxt_mp_page_addr(mp, page);
+ p += nxt_mp_alloc_chunk(page->map, size);
page->chunks--;
if (page->chunks == 0) {
/*
- * Remove full page from the pool chunk slot list
+ * Remove full page from the mp chunk slot list
* of pages with free chunks.
*/
nxt_queue_remove(&page->link);
}
} else {
- page = nxt_mem_cache_alloc_page(pool);
+ page = nxt_mp_alloc_page(mp);
if (nxt_fast_path(page != NULL)) {
/* slot->chunks are already one less. */
page->chunks = slot->chunks;
- page->size = size >> pool->chunk_size_shift;
+ page->size = size >> mp->chunk_size_shift;
- p = nxt_mem_cache_page_addr(pool, page);
+ p = nxt_mp_page_addr(mp, page);
}
}
} else {
- page = nxt_mem_cache_alloc_page(pool);
+ page = nxt_mp_alloc_page(mp);
if (nxt_fast_path(page != NULL)) {
- page->size = pool->page_size >> pool->chunk_size_shift;
+ page->size = mp->page_size >> mp->chunk_size_shift;
- p = nxt_mem_cache_page_addr(pool, page);
+ p = nxt_mp_page_addr(mp, page);
}
#if (NXT_DEBUG)
- size = pool->page_size;
+ size = mp->page_size;
#endif
}
- if (pool->proto->trace != NULL) {
- pool->proto->trace(pool->trace, "mem cache chunk:%uz alloc: %p",
- size, p);
+ if (mp->proto->trace != NULL) {
+ mp->proto->trace(mp->trace, "mem cache chunk:%uz alloc: %p", size, p);
}
return p;
static nxt_uint_t
-nxt_mem_cache_alloc_chunk(uint8_t *map, nxt_uint_t size)
+nxt_mp_alloc_chunk(uint8_t *map, nxt_uint_t size)
{
uint8_t mask;
nxt_uint_t n, offset;
}
-static nxt_mem_cache_page_t *
-nxt_mem_cache_alloc_page(nxt_mem_cache_pool_t *pool)
+static nxt_mp_page_t *
+nxt_mp_alloc_page(nxt_mp_t *mp)
{
- nxt_queue_link_t *link;
- nxt_mem_cache_page_t *page;
- nxt_mem_cache_block_t *cluster;
+ nxt_mp_page_t *page;
+ nxt_mp_block_t *cluster;
+ nxt_queue_link_t *link;
- if (nxt_queue_is_empty(&pool->free_pages)) {
- cluster = nxt_mem_cache_alloc_cluster(pool);
+ if (nxt_queue_is_empty(&mp->free_pages)) {
+ cluster = nxt_mp_alloc_cluster(mp);
if (nxt_slow_path(cluster == NULL)) {
return NULL;
}
}
- link = nxt_queue_first(&pool->free_pages);
+ link = nxt_queue_first(&mp->free_pages);
nxt_queue_remove(link);
- page = nxt_queue_link_data(link, nxt_mem_cache_page_t, link);
+ page = nxt_queue_link_data(link, nxt_mp_page_t, link);
return page;
}
-static nxt_mem_cache_block_t *
-nxt_mem_cache_alloc_cluster(nxt_mem_cache_pool_t *pool)
+static nxt_mp_block_t *
+nxt_mp_alloc_cluster(nxt_mp_t *mp)
{
- nxt_uint_t n;
- nxt_mem_cache_block_t *cluster;
+ nxt_uint_t n;
+ nxt_mp_block_t *cluster;
- n = pool->cluster_size >> pool->page_size_shift;
+ n = mp->cluster_size >> mp->page_size_shift;
- cluster = pool->proto->zalloc(pool->mem, sizeof(nxt_mem_cache_block_t)
- + n * sizeof(nxt_mem_cache_page_t));
+ cluster = mp->proto->zalloc(mp->mem,
+ sizeof(nxt_mp_block_t)
+ + n * sizeof(nxt_mp_page_t));
if (nxt_slow_path(cluster == NULL)) {
return NULL;
}
- /* NXT_MEM_CACHE_CLUSTER_BLOCK type is zero. */
+ /* NXT_MP_CLUSTER_BLOCK type is zero. */
- cluster->size = pool->cluster_size;
+ cluster->size = mp->cluster_size;
- cluster->start = pool->proto->align(pool->mem, pool->page_alignment,
- pool->cluster_size);
+ cluster->start = mp->proto->align(mp->mem, mp->page_alignment,
+ mp->cluster_size);
if (nxt_slow_path(cluster->start == NULL)) {
- pool->proto->free(pool->mem, cluster);
+ mp->proto->free(mp->mem, cluster);
return NULL;
}
n--;
cluster->pages[n].number = n;
- nxt_queue_insert_head(&pool->free_pages, &cluster->pages[n].link);
+ nxt_queue_insert_head(&mp->free_pages, &cluster->pages[n].link);
while (n != 0) {
n--;
&cluster->pages[n].link);
}
- nxt_rbtree_insert(&pool->blocks, &cluster->node);
+ nxt_rbtree_insert(&mp->blocks, &cluster->node);
return cluster;
}
static void *
-nxt_mem_cache_alloc_large(nxt_mem_cache_pool_t *pool, size_t alignment,
- size_t size)
+nxt_mp_alloc_large(nxt_mp_t *mp, size_t alignment, size_t size)
{
- u_char *p;
- size_t aligned_size;
- uint8_t type;
- nxt_mem_cache_block_t *block;
+ u_char *p;
+ size_t aligned_size;
+ uint8_t type;
+ nxt_mp_block_t *block;
/* Allocation must be less than 4G. */
if (nxt_slow_path(size >= UINT32_MAX)) {
}
if (nxt_is_power_of_two(size)) {
- block = pool->proto->alloc(pool->mem, sizeof(nxt_mem_cache_block_t));
+ block = mp->proto->alloc(mp->mem, sizeof(nxt_mp_block_t));
if (nxt_slow_path(block == NULL)) {
return NULL;
}
- p = pool->proto->align(pool->mem, alignment, size);
+ p = mp->proto->align(mp->mem, alignment, size);
if (nxt_slow_path(p == NULL)) {
- pool->proto->free(pool->mem, block);
+ mp->proto->free(mp->mem, block);
return NULL;
}
- type = NXT_MEM_CACHE_DISCRETE_BLOCK;
+ type = NXT_MP_DISCRETE_BLOCK;
} else {
aligned_size = nxt_align_size(size, sizeof(uintptr_t));
- p = pool->proto->align(pool->mem, alignment,
- aligned_size + sizeof(nxt_mem_cache_block_t));
+ p = mp->proto->align(mp->mem, alignment,
+ aligned_size + sizeof(nxt_mp_block_t));
if (nxt_slow_path(p == NULL)) {
return NULL;
}
- block = (nxt_mem_cache_block_t *) (p + aligned_size);
- type = NXT_MEM_CACHE_EMBEDDED_BLOCK;
+ block = (nxt_mp_block_t *) (p + aligned_size);
+ type = NXT_MP_EMBEDDED_BLOCK;
}
block->type = type;
block->size = size;
block->start = p;
- nxt_rbtree_insert(&pool->blocks, &block->node);
+ nxt_rbtree_insert(&mp->blocks, &block->node);
return p;
}
static intptr_t
-nxt_mem_cache_rbtree_compare(nxt_rbtree_node_t *node1, nxt_rbtree_node_t *node2)
+nxt_mp_rbtree_compare(nxt_rbtree_node_t *node1, nxt_rbtree_node_t *node2)
{
- nxt_mem_cache_block_t *block1, *block2;
+ nxt_mp_block_t *block1, *block2;
- block1 = (nxt_mem_cache_block_t *) node1;
- block2 = (nxt_mem_cache_block_t *) node2;
+ block1 = (nxt_mp_block_t *) node1;
+ block2 = (nxt_mp_block_t *) node2;
return (uintptr_t) block1->start - (uintptr_t) block2->start;
}
void
-nxt_mem_cache_free(nxt_mem_cache_pool_t *pool, void *p)
+nxt_mp_free(nxt_mp_t *mp, void *p)
{
- const char *err;
- nxt_mem_cache_block_t *block;
+ const char *err;
+ nxt_mp_block_t *block;
- if (pool->proto->trace != NULL) {
- pool->proto->trace(pool->trace, "mem cache free %p", p);
+ if (mp->proto->trace != NULL) {
+ mp->proto->trace(mp->trace, "mem cache free %p", p);
}
- block = nxt_mem_cache_find_block(&pool->blocks, p);
+ block = nxt_mp_find_block(&mp->blocks, p);
if (nxt_fast_path(block != NULL)) {
- if (block->type == NXT_MEM_CACHE_CLUSTER_BLOCK) {
- err = nxt_mem_cache_chunk_free(pool, block, p);
+ if (block->type == NXT_MP_CLUSTER_BLOCK) {
+ err = nxt_mp_chunk_free(mp, block, p);
if (nxt_fast_path(err == NULL)) {
return;
}
} else if (nxt_fast_path(p == block->start)) {
- nxt_rbtree_delete(&pool->blocks, &block->node);
+ nxt_rbtree_delete(&mp->blocks, &block->node);
- if (block->type == NXT_MEM_CACHE_DISCRETE_BLOCK) {
- pool->proto->free(pool->mem, block);
+ if (block->type == NXT_MP_DISCRETE_BLOCK) {
+ mp->proto->free(mp->mem, block);
}
- pool->proto->free(pool->mem, p);
+ mp->proto->free(mp->mem, p);
return;
}
} else {
- err = "freed pointer is out of pool: %p";
+ err = "freed pointer is out of mp: %p";
}
- if (pool->proto->alert != NULL) {
- pool->proto->alert(pool->trace, err, p);
+ if (mp->proto->alert != NULL) {
+ mp->proto->alert(mp->trace, err, p);
}
}
-static nxt_mem_cache_block_t *
-nxt_mem_cache_find_block(nxt_rbtree_t *tree, u_char *p)
+static nxt_mp_block_t *
+nxt_mp_find_block(nxt_rbtree_t *tree, u_char *p)
{
- nxt_rbtree_node_t *node, *sentinel;
- nxt_mem_cache_block_t *block;
+ nxt_mp_block_t *block;
+ nxt_rbtree_node_t *node, *sentinel;
node = nxt_rbtree_root(tree);
sentinel = nxt_rbtree_sentinel(tree);
while (node != sentinel) {
- block = (nxt_mem_cache_block_t *) node;
+ block = (nxt_mp_block_t *) node;
if (p < block->start) {
node = node->left;
static const char *
-nxt_mem_cache_chunk_free(nxt_mem_cache_pool_t *pool,
- nxt_mem_cache_block_t *cluster, u_char *p)
+nxt_mp_chunk_free(nxt_mp_t *mp, nxt_mp_block_t *cluster,
+ u_char *p)
{
- u_char *start;
- uintptr_t offset;
- nxt_uint_t n, size, chunk;
- nxt_mem_cache_page_t *page;
- nxt_mem_cache_slot_t *slot;
+ u_char *start;
+ uintptr_t offset;
+ nxt_uint_t n, size, chunk;
+ nxt_mp_page_t *page;
+ nxt_mp_slot_t *slot;
- n = (p - cluster->start) >> pool->page_size_shift;
- start = cluster->start + (n << pool->page_size_shift);
+ n = (p - cluster->start) >> mp->page_size_shift;
+ start = cluster->start + (n << mp->page_size_shift);
page = &cluster->pages[n];
return "freed pointer points to already free page: %p";
}
- size = page->size << pool->chunk_size_shift;
+ size = page->size << mp->chunk_size_shift;
- if (size != pool->page_size) {
+ if (size != mp->page_size) {
- offset = (uintptr_t) (p - start) & (pool->page_size - 1);
+ offset = (uintptr_t) (p - start) & (mp->page_size - 1);
chunk = offset / size;
if (nxt_slow_path(offset != chunk * size)) {
return "freed pointer points to wrong chunk: %p";
}
- if (nxt_slow_path(nxt_mem_cache_chunk_is_free(page->map, chunk))) {
+ if (nxt_slow_path(nxt_mp_chunk_is_free(page->map, chunk))) {
return "freed pointer points to already free chunk: %p";
}
- nxt_mem_cache_chunk_set_free(page->map, chunk);
+ nxt_mp_chunk_set_free(page->map, chunk);
/* Find a slot with appropriate chunk size. */
- for (slot = pool->slots; slot->size < size; slot++) { /* void */ }
+ for (slot = mp->slots; slot->size < size; slot++) { /* void */ }
if (page->chunks != slot->chunks) {
page->chunks++;
if (page->chunks == 1) {
/*
- * Add the page to the head of pool chunk slot list
+ * Add the page to the head of mp chunk slot list
* of pages with free chunks.
*/
nxt_queue_insert_head(&slot->pages, &page->link);
}
- nxt_mem_cache_free_junk(p, size);
+ nxt_mp_free_junk(p, size);
return NULL;
} else {
/*
- * All chunks are free, remove the page from pool chunk slot
+ * All chunks are free, remove the page from mp chunk slot
* list of pages with free chunks.
*/
nxt_queue_remove(&page->link);
return "invalid pointer to chunk: %p";
}
- /* Add the free page to the pool's free pages tree. */
+ /* Add the free page to the mp's free pages tree. */
page->size = 0;
- nxt_queue_insert_head(&pool->free_pages, &page->link);
+ nxt_queue_insert_head(&mp->free_pages, &page->link);
- nxt_mem_cache_free_junk(p, size);
+ nxt_mp_free_junk(p, size);
/* Test if all pages in the cluster are free. */
page = cluster->pages;
- n = pool->cluster_size >> pool->page_size_shift;
+ n = mp->cluster_size >> mp->page_size_shift;
do {
if (page->size != 0) {
/* Free cluster. */
page = cluster->pages;
- n = pool->cluster_size >> pool->page_size_shift;
+ n = mp->cluster_size >> mp->page_size_shift;
do {
nxt_queue_remove(&page->link);
n--;
} while (n != 0);
- nxt_rbtree_delete(&pool->blocks, &cluster->node);
+ nxt_rbtree_delete(&mp->blocks, &cluster->node);
p = cluster->start;
- pool->proto->free(pool->mem, cluster);
- pool->proto->free(pool->mem, p);
+ mp->proto->free(mp->mem, cluster);
+ mp->proto->free(mp->mem, p);
return NULL;
}
--- /dev/null
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) NGINX, Inc.
+ */
+
+#ifndef _NXT_MP_H_INCLUDED_
+#define _NXT_MP_H_INCLUDED_
+
+
+typedef struct nxt_mp_s nxt_mp_t;
+
+
+NXT_EXPORT nxt_mp_t *nxt_mp_create(const nxt_mem_proto_t *proto, void *mem,
+ void *trace, size_t cluster_size, size_t page_alignment, size_t page_size,
+ size_t min_chunk_size)
+ NXT_MALLOC_LIKE;
+NXT_EXPORT nxt_mp_t * nxt_mp_fast_create(const nxt_mem_proto_t *proto,
+ void *mem, void *trace, size_t cluster_size, size_t page_alignment,
+ size_t page_size, size_t min_chunk_size)
+ NXT_MALLOC_LIKE;
+NXT_EXPORT nxt_bool_t nxt_mp_is_empty(nxt_mp_t *mp);
+NXT_EXPORT void nxt_mp_destroy(nxt_mp_t *mp);
+
+NXT_EXPORT void *nxt_mp_alloc(nxt_mp_t *mp, size_t size)
+ NXT_MALLOC_LIKE;
+NXT_EXPORT void *nxt_mp_zalloc(nxt_mp_t *mp, size_t size)
+ NXT_MALLOC_LIKE;
+NXT_EXPORT void *nxt_mp_align(nxt_mp_t *mp, size_t alignment, size_t size)
+ NXT_MALLOC_LIKE;
+NXT_EXPORT void *nxt_mp_zalign(nxt_mp_t *mp,
+ size_t alignment, size_t size)
+ NXT_MALLOC_LIKE;
+NXT_EXPORT void nxt_mp_free(nxt_mp_t *mp, void *p);
+
+
+#endif /* _NXT_MP_H_INCLUDED_ */
$(NXT_BUILDDIR)/lvlhsh_unit_test: \
$(NXT_BUILDDIR)/nxt_lvlhsh.o \
$(NXT_BUILDDIR)/nxt_murmur_hash.o \
- $(NXT_BUILDDIR)/nxt_mem_cache_pool.o \
+ $(NXT_BUILDDIR)/nxt_mp.o \
$(NXT_BUILDDIR)/nxt_malloc.o \
$(NXT_LIB)/test/lvlhsh_unit_test.c \
$(NXT_BUILDDIR)/nxt_lvlhsh.o \
$(NXT_BUILDDIR)/nxt_rbtree.o \
$(NXT_BUILDDIR)/nxt_murmur_hash.o \
- $(NXT_BUILDDIR)/nxt_mem_cache_pool.o \
+ $(NXT_BUILDDIR)/nxt_mp.o \
$(NXT_BUILDDIR)/nxt_malloc.o
$(NXT_BUILDDIR)/random_unit_test: \
#include <nxt_malloc.h>
#include <nxt_lvlhsh.h>
#include <nxt_murmur_hash.h>
-#include <nxt_mem_cache_pool.h>
+#include <nxt_mp.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
static void *
lvlhsh_unit_test_pool_alloc(void *pool, size_t size, nxt_uint_t nalloc)
{
- return nxt_mem_cache_align(pool, size, size);
+ return nxt_mp_align(pool, size, size);
}
static void
lvlhsh_unit_test_pool_free(void *pool, void *p, size_t size)
{
- nxt_mem_cache_free(pool, p);
+ nxt_mp_free(pool, p);
}
}
-static const nxt_mem_proto_t mem_cache_pool_proto = {
+static const nxt_mem_proto_t lvl_mp_proto = {
lvlhsh_malloc,
lvlhsh_zalloc,
lvlhsh_align,
static nxt_int_t
lvlhsh_unit_test(nxt_uint_t n)
{
- uint32_t key;
- nxt_uint_t i;
- nxt_lvlhsh_t lh;
- nxt_lvlhsh_each_t lhe;
- nxt_mem_cache_pool_t *pool;
-
- const size_t min_chunk_size = 32;
- const size_t page_size = 1024;
- const size_t page_alignment = 128;
- const size_t cluster_size = 4096;
-
- pool = nxt_mem_cache_pool_create(&mem_cache_pool_proto, NULL, NULL,
- cluster_size, page_alignment,
- page_size, min_chunk_size);
+ nxt_mp_t *pool;
+ uint32_t key;
+ nxt_uint_t i;
+ nxt_lvlhsh_t lh;
+ nxt_lvlhsh_each_t lhe;
+
+ const size_t min_chunk_size = 32;
+ const size_t page_size = 1024;
+ const size_t page_alignment = 128;
+ const size_t cluster_size = 4096;
+
+ pool = nxt_mp_create(&lvl_mp_proto, NULL, NULL, cluster_size,
+ page_alignment, page_size, min_chunk_size);
if (pool == NULL) {
return NXT_ERROR;
}
}
}
- if (!nxt_mem_cache_pool_is_empty(pool)) {
+ if (!nxt_mp_is_empty(pool)) {
printf("mem cache pool is not empty\n");
return NXT_ERROR;
}
- nxt_mem_cache_pool_destroy(pool);
+ nxt_mp_destroy(pool);
printf("lvlhsh unit test passed\n");
projects / njs.git / commitdiff