Browse Source
refactor: s/mem/allocator/
refactor: s/mem/allocator/
git-svn-id: svn://svn.lighttpd.net/xcache/trunk@1135 c26eb9a1-5813-0410-bd6c-c2e55f420ca73.0
Xuefer
9 years ago
14 changed files with 352 additions and 628 deletions
-
35Makefile.frag.deps
-
3config.m4
-
3config.w32
-
16devel/test.mak
-
70mod_cacher/xc_cacher.c
-
18processor/head.m4
-
112xcache/xc_allocator.c
-
73xcache/xc_allocator.h
-
136xcache/xc_malloc.c
-
415xcache/xc_mem.c
-
74xcache/xc_mem.h
-
4xcache/xc_shm.c
-
13xcache/xc_shm.h
-
8xcache/xc_shm_mmap.c
@ -1,24 +1,25 @@ |
|||
$(XCACHE_INCLUDES_I) $(builddir)/includes.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h |
|||
$(XCACHE_INCLUDES_I) $(builddir)/includes.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h |
|||
$(builddir)/mod_assembler/xc_assembler.lo: |
|||
$(builddir)/mod_cacher/xc_cacher.lo: $(srcdir)/mod_cacher/xc_cacher.h $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_compatibility.h $(XCACHE_PROC_H) $(srcdir)/xcache.h $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/util/xc_trace.h $(srcdir)/util/xc_vector.h $(srcdir)/util/xc_align.h |
|||
$(builddir)/mod_coverager/xc_coverager.lo: $(srcdir)/mod_coverager/xc_coverager.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_trace.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h |
|||
$(builddir)/mod_cacher/xc_cacher.lo: $(srcdir)/mod_cacher/xc_cacher.h $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_compatibility.h $(XCACHE_PROC_H) $(srcdir)/xcache.h $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/util/xc_trace.h $(srcdir)/util/xc_vector.h $(srcdir)/util/xc_align.h |
|||
$(builddir)/mod_coverager/xc_coverager.lo: $(srcdir)/mod_coverager/xc_coverager.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_trace.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h |
|||
$(builddir)/mod_decoder/xc_decoder.lo: |
|||
$(builddir)/mod_disassembler/xc_disassembler.lo: $(srcdir)/mod_disassembler/xc_disassembler.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/xcache/xc_compatibility.h $(XCACHE_PROC_H) $(srcdir)/xcache.h $(srcdir)/mod_cacher/xc_cache.h |
|||
$(builddir)/mod_disassembler/xc_disassembler.lo: $(srcdir)/mod_disassembler/xc_disassembler.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/xcache/xc_compatibility.h $(XCACHE_PROC_H) $(srcdir)/xcache.h $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_shm.h |
|||
$(builddir)/mod_encoder/xc_encoder.lo: |
|||
$(builddir)/mod_optimizer/xc_optimizer.lo: $(srcdir)/mod_optimizer/xc_optimizer.h $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_trace.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h |
|||
$(builddir)/mod_optimizer/xc_optimizer.lo: $(srcdir)/mod_optimizer/xc_optimizer.h $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_trace.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h |
|||
$(builddir)/util/xc_stack.lo: $(srcdir)/util/xc_trace.h $(srcdir)/util/xc_stack.h |
|||
$(builddir)/util/xc_trace.lo: $(srcdir)/util/xc_trace.h |
|||
$(builddir)/xcache.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_foreachcoresig.h |
|||
$(builddir)/xcache.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_foreachcoresig.h |
|||
$(builddir)/xcache/xc_allocator_bestfit.lo: $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_shm.h $(srcdir)/util/xc_align.h $(srcdir)/util/xc_trace.h |
|||
$(builddir)/xcache/xc_allocator.lo: $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_shm.h |
|||
$(builddir)/xcache/xc_compatibility.lo: $(srcdir)/xcache/xc_compatibility.h |
|||
$(builddir)/xcache/xc_const_string.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_const_string_opcodes_php5.4.h |
|||
$(builddir)/xcache/xc_extension.lo: $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_trace.h |
|||
$(builddir)/xcache/xc_const_string.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_const_string_opcodes_php5.4.h |
|||
$(builddir)/xcache/xc_extension.lo: $(srcdir)/xcache/xc_extension.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_trace.h |
|||
$(builddir)/xcache/xc_ini.lo: $(srcdir)/xcache/xc_ini.h |
|||
$(builddir)/xcache/xc_lock.lo: $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h |
|||
$(builddir)/xcache/xc_malloc.lo: $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_align.h |
|||
$(builddir)/xcache/xc_mem.lo: $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/util/xc_align.h $(srcdir)/util/xc_trace.h |
|||
$(builddir)/xcache/xc_opcode_spec.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_opcode_spec_def.h |
|||
$(builddir)/xcache/xc_processor.lo: $(XCACHE_PROC_C) $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_align.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(XCACHE_PROC_H) $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h |
|||
$(builddir)/xcache/xc_sandbox.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h |
|||
$(builddir)/xcache/xc_shm.lo: $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h |
|||
$(builddir)/xcache/xc_shm_mmap.lo: $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_compatibility.h |
|||
$(builddir)/xcache/xc_utils.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_mem.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/util/xc_trace.h |
|||
$(builddir)/xcache/xc_lock.lo: $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h |
|||
$(builddir)/xcache/xc_malloc.lo: $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_align.h |
|||
$(builddir)/xcache/xc_opcode_spec.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_opcode_spec_def.h |
|||
$(builddir)/xcache/xc_processor.lo: $(XCACHE_PROC_C) $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/util/xc_align.h $(XCACHE_PROC_H) $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h |
|||
$(builddir)/xcache/xc_sandbox.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h |
|||
$(builddir)/xcache/xc_shm.lo: $(srcdir)/xcache/xc_shm.h |
|||
$(builddir)/xcache/xc_shm_mmap.lo: $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_compatibility.h |
|||
$(builddir)/xcache/xc_utils.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache_globals.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache/xc_utils.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/util/xc_trace.h |
|||
@ -1,18 +1,18 @@ |
|||
#! /usr/bin/make -f
|
|||
|
|||
EXES=mem_test |
|||
OBJS=mem.o |
|||
EXES=allocator_test |
|||
OBJS=allocator.o |
|||
CC=gcc |
|||
CFLAGS=-g -O0 -I. -D TEST -Wall |
|||
CFLAGS=-g -O0 -I. -D TEST -D HAVE_XCACHE_TEST -Wall |
|||
TEST=valgrind |
|||
|
|||
all: mem |
|||
all: allocator |
|||
|
|||
mem_test: xcache/xc_mem.c xcache/xc_mem.h util/xc_trace.c util/xc_trace.h |
|||
$(CC) $(CFLAGS) -o mem_test xcache/xc_mem.c util/xc_trace.c |
|||
allocator_test: xcache/xc_allocator.h xcache/xc_allocator.c xcache/xc_malloc.c xcache/xc_allocator_bestfit.c util/xc_trace.c util/xc_trace.h |
|||
$(CC) $(CFLAGS) -o allocator_test xcache/xc_allocator.c xcache/xc_malloc.c xcache/xc_allocator_bestfit.c util/xc_trace.c |
|||
|
|||
mem: mem_test |
|||
$(TEST) ./mem_test |
|||
allocator: allocator_test |
|||
$(TEST) ./allocator_test |
|||
|
|||
clean: |
|||
rm -f $(OBJS) $(EXES) |
|||
@ -0,0 +1,112 @@ |
|||
#include "xc_allocator.h" |
|||
#include <string.h> |
|||
#include <stdio.h> |
|||
|
|||
typedef struct { |
|||
const char *name; |
|||
const xc_allocator_vtable_t *allocator_vtable; |
|||
} xc_allocator_info_t; |
|||
static xc_allocator_info_t xc_allocator_infos[10]; |
|||
|
|||
int xc_allocator_register(const char *name, const xc_allocator_vtable_t *allocator_vtable) /* {{{ */ |
|||
{ |
|||
size_t i; |
|||
for (i = 0; i < sizeof(xc_allocator_infos) / sizeof(xc_allocator_infos[0]); i ++) { |
|||
if (!xc_allocator_infos[i].name) { |
|||
xc_allocator_infos[i].name = name; |
|||
xc_allocator_infos[i].allocator_vtable = allocator_vtable; |
|||
return 1; |
|||
} |
|||
} |
|||
return 0; |
|||
} |
|||
/* }}} */ |
|||
const xc_allocator_vtable_t *xc_allocator_find(const char *name) /* {{{ */ |
|||
{ |
|||
size_t i; |
|||
for (i = 0; i < sizeof(xc_allocator_infos) / sizeof(xc_allocator_infos[0]) && xc_allocator_infos[i].name; i ++) { |
|||
if (strcmp(xc_allocator_infos[i].name, name) == 0) { |
|||
return xc_allocator_infos[i].allocator_vtable; |
|||
} |
|||
} |
|||
return NULL; |
|||
} |
|||
/* }}} */ |
|||
void xc_allocator_init() /* {{{ */ |
|||
{ |
|||
extern void xc_allocator_bestfit_register(); |
|||
#ifdef HAVE_XCACHE_TEST |
|||
extern void xc_allocator_malloc_register(); |
|||
#endif |
|||
|
|||
memset(xc_allocator_infos, 0, sizeof(xc_allocator_infos)); |
|||
xc_allocator_bestfit_register(); |
|||
#ifdef HAVE_XCACHE_TEST |
|||
xc_allocator_malloc_register(); |
|||
#endif |
|||
} |
|||
/* }}} */ |
|||
#ifdef TEST |
|||
/* {{{ testing */ |
|||
#undef CHECK |
|||
#define CHECK(a, msg) do { \ |
|||
if (!(a)) { \ |
|||
fprintf(stderr, "%s\n", msg); return -1; \ |
|||
} \ |
|||
} while (0) |
|||
|
|||
#include <time.h> |
|||
|
|||
int testAllocator(const xc_allocator_vtable_t *allocator_vtable) |
|||
{ |
|||
int count = 0; |
|||
void *p; |
|||
xc_allocator_t *allocator; |
|||
void *memory; |
|||
void **ptrs; |
|||
int size, i; |
|||
|
|||
#if 0 |
|||
fprintf(stderr, "%s", "Input test size: "); |
|||
scanf("%d", &size); |
|||
#else |
|||
size = 1024; |
|||
#endif |
|||
CHECK(memory = malloc(size), "OOM"); |
|||
CHECK(ptrs = malloc(size * sizeof(void *)), "OOM"); |
|||
allocator = (xc_allocator_t *) memory; |
|||
allocator->vtable = allocator_vtable; |
|||
CHECK(allocator = allocator->vtable->init(NULL, allocator, size), "Failed init memory allocator"); |
|||
|
|||
while ((p = allocator->vtable->malloc(allocator, 1))) { |
|||
ptrs[count ++] = p; |
|||
} |
|||
fprintf(stderr, "count=%d, random freeing\n", count); |
|||
srandom(time(NULL)); |
|||
while (count) { |
|||
i = (random() % count); |
|||
fprintf(stderr, "freeing %d: ", i); |
|||
allocator->vtable->free(allocator, ptrs[i]); |
|||
ptrs[i] = ptrs[count - 1]; |
|||
count --; |
|||
} |
|||
|
|||
free(ptrs); |
|||
free(memory); |
|||
return 0; |
|||
} |
|||
/* }}} */ |
|||
int main() /* {{{ */ |
|||
{ |
|||
int i; |
|||
|
|||
xc_allocator_init(); |
|||
|
|||
for (i = 0; i < sizeof(xc_allocator_infos) / sizeof(xc_allocator_infos[0]) && xc_allocator_infos[i].name; i ++) { |
|||
fprintf(stderr, "testing %s...\n", xc_allocator_infos[i].name); |
|||
testAllocator(xc_allocator_infos[i].allocator_vtable); |
|||
} |
|||
return 0; |
|||
} |
|||
/* }}} */ |
|||
#endif |
|||
@ -0,0 +1,73 @@ |
|||
#ifndef XC_ALLOCATOR_H_155E773CA8AFC18F3CCCDCF0831EE41D |
|||
#define XC_ALLOCATOR_H_155E773CA8AFC18F3CCCDCF0831EE41D |
|||
|
|||
#if _MSC_VER > 1000 |
|||
#pragma once |
|||
#endif /* _MSC_VER > 1000 */ |
|||
|
|||
#include "xc_shm.h" |
|||
|
|||
typedef struct _xc_allocator_vtable_t xc_allocator_vtable_t; |
|||
|
|||
#ifndef _xc_allocator_t |
|||
struct _xc_allocator_t { |
|||
const xc_allocator_vtable_t *vtable; |
|||
xc_shm_t *shm; |
|||
}; |
|||
#endif |
|||
|
|||
typedef struct _xc_allocator_t xc_allocator_t; |
|||
typedef struct _xc_allocator_block_t xc_allocator_block_t; |
|||
typedef xc_shmsize_t xc_memsize_t; |
|||
|
|||
/* allocator */ |
|||
#define XC_ALLOCATOR_MALLOC(func) void *func(xc_allocator_t *allocator, xc_memsize_t size) |
|||
#define XC_ALLOCATOR_FREE(func) xc_memsize_t func(xc_allocator_t *allocator, const void *p) |
|||
#define XC_ALLOCATOR_CALLOC(func) void *func(xc_allocator_t *allocator, xc_memsize_t memb, xc_memsize_t size) |
|||
#define XC_ALLOCATOR_REALLOC(func) void *func(xc_allocator_t *allocator, const void *p, xc_memsize_t size) |
|||
#define XC_ALLOCATOR_AVAIL(func) xc_memsize_t func(const xc_allocator_t *allocator) |
|||
#define XC_ALLOCATOR_SIZE(func) xc_memsize_t func(const xc_allocator_t *allocator) |
|||
#define XC_ALLOCATOR_FREEBLOCK_FIRST(func) const xc_allocator_block_t *func(const xc_allocator_t *allocator) |
|||
#define XC_ALLOCATOR_FREEBLOCK_NEXT(func) const xc_allocator_block_t *func(const xc_allocator_block_t *block) |
|||
#define XC_ALLOCATOR_BLOCK_SIZE(func) xc_memsize_t func(const xc_allocator_block_t *block) |
|||
#define XC_ALLOCATOR_BLOCK_OFFSET(func) xc_memsize_t func(const xc_allocator_t *allocator, const xc_allocator_block_t *block) |
|||
|
|||
#define XC_ALLOCATOR_INIT(func) xc_allocator_t *func(xc_shm_t *shm, xc_allocator_t *allocator, xc_memsize_t size) |
|||
#define XC_ALLOCATOR_DESTROY(func) void func(xc_allocator_t *allocator) |
|||
|
|||
#define XC_ALLOCATOR_VTABLE(name) { \ |
|||
xc_##name##_malloc \ |
|||
, xc_##name##_free \ |
|||
, xc_##name##_calloc \ |
|||
, xc_##name##_realloc \ |
|||
, xc_##name##_avail \ |
|||
, xc_##name##_size \ |
|||
, xc_##name##_freeblock_first \ |
|||
, xc_##name##_freeblock_next \ |
|||
, xc_##name##_block_size \ |
|||
, xc_##name##_block_offset \ |
|||
\ |
|||
, xc_##name##_init \ |
|||
, xc_##name##_destroy \ |
|||
} |
|||
|
|||
struct _xc_allocator_vtable_t { |
|||
XC_ALLOCATOR_MALLOC((*malloc)); |
|||
XC_ALLOCATOR_FREE((*free)); |
|||
XC_ALLOCATOR_CALLOC((*calloc)); |
|||
XC_ALLOCATOR_REALLOC((*realloc)); |
|||
XC_ALLOCATOR_AVAIL((*avail)); |
|||
XC_ALLOCATOR_SIZE((*size)); |
|||
XC_ALLOCATOR_FREEBLOCK_FIRST((*freeblock_first)); |
|||
XC_ALLOCATOR_FREEBLOCK_NEXT((*freeblock_next)); |
|||
XC_ALLOCATOR_BLOCK_SIZE((*block_size)); |
|||
XC_ALLOCATOR_BLOCK_OFFSET((*block_offset)); |
|||
|
|||
XC_ALLOCATOR_INIT((*init)); |
|||
XC_ALLOCATOR_DESTROY((*destroy)); |
|||
}; |
|||
|
|||
int xc_allocator_register(const char *name, const xc_allocator_vtable_t *allocator_vtable); |
|||
const xc_allocator_vtable_t *xc_allocator_find(const char *name); |
|||
|
|||
#endif /* XC_ALLOCATOR_H_155E773CA8AFC18F3CCCDCF0831EE41D */ |
|||
@ -1,415 +0,0 @@ |
|||
#ifdef TEST |
|||
# include <limits.h> |
|||
# include <stdio.h> |
|||
# define XCACHE_DEBUG |
|||
typedef int zend_bool; |
|||
# define ZEND_ATTRIBUTE_PTR_FORMAT(a, b, c) |
|||
# define zend_error(type, error) fprintf(stderr, "%s", error) |
|||
#else |
|||
# include <php.h> |
|||
#endif |
|||
|
|||
#ifdef XCACHE_DEBUG |
|||
# define ALLOC_DEBUG_BLOCK_CHECK |
|||
#endif |
|||
|
|||
|
|||
#include <assert.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
#define XC_MEMBLOCK_IMPL _xc_mem_block_t |
|||
#define XC_MEM_IMPL _xc_mem_mem_t |
|||
#include "xc_shm.h" |
|||
#include "util/xc_align.h" |
|||
#include "util/xc_trace.h" |
|||
|
|||
#if 0 |
|||
#undef ALLOC_DEBUG_BLOCK_CHECK |
|||
#endif |
|||
|
|||
#define CHAR_PTR(p) ((char *) (p)) |
|||
#define PADD(p, a) (CHAR_PTR(p) + a) |
|||
#define PSUB(p1, p2) (CHAR_PTR(p1) - CHAR_PTR(p2)) |
|||
|
|||
/* {{{ mem */ |
|||
struct _xc_mem_block_t { |
|||
#ifdef ALLOC_DEBUG_BLOCK_CHECK |
|||
unsigned int magic; |
|||
#endif |
|||
xc_memsize_t size; /* reserved even after alloc */ |
|||
xc_block_t *next; /* not used after alloc */ |
|||
}; |
|||
|
|||
struct _xc_mem_mem_t { |
|||
const xc_mem_handlers_t *handlers; |
|||
xc_shm_t *shm; |
|||
xc_memsize_t size; |
|||
xc_memsize_t avail; /* total free */ |
|||
xc_block_t headblock[1]; /* just as a pointer to first block*/ |
|||
}; |
|||
|
|||
#ifndef XtOffsetOf |
|||
# include <linux/stddef.h> |
|||
# define XtOffsetOf(s_type, field) offsetof(s_type, field) |
|||
#endif |
|||
|
|||
#define SizeOf(type, field) sizeof( ((type *) 0)->field ) |
|||
#define BLOCK_HEADER_SIZE() (ALIGN( XtOffsetOf(xc_block_t, size) + SizeOf(xc_block_t, size) )) |
|||
|
|||
#define BLOCK_MAGIC ((unsigned int) 0x87655678) |
|||
|
|||
/* }}} */ |
|||
static inline void xc_block_setup(xc_block_t *b, xc_memsize_t size, xc_block_t *next) /* {{{ */ |
|||
{ |
|||
#ifdef ALLOC_DEBUG_BLOCK_CHECK |
|||
b->magic = BLOCK_MAGIC; |
|||
#endif |
|||
b->size = size; |
|||
b->next = next; |
|||
} |
|||
/* }}} */ |
|||
#ifdef ALLOC_DEBUG_BLOCK_CHECK |
|||
static void xc_block_check(xc_block_t *b) /* {{{ */ |
|||
{ |
|||
if (b->magic != BLOCK_MAGIC) { |
|||
fprintf(stderr, "0x%X != 0x%X magic wrong \n", b->magic, BLOCK_MAGIC); |
|||
} |
|||
} |
|||
/* }}} */ |
|||
#else |
|||
# define xc_block_check(b) do { } while(0) |
|||
#endif |
|||
|
|||
|
|||
static XC_MEM_MALLOC(xc_mem_malloc) /* {{{ */ |
|||
{ |
|||
xc_block_t *prev, *cur; |
|||
xc_block_t *newb, *b; |
|||
xc_memsize_t realsize; |
|||
xc_memsize_t minsize; |
|||
void *p; |
|||
/* [xc_block_t:size|size] */ |
|||
realsize = BLOCK_HEADER_SIZE() + size; |
|||
/* realsize is ALIGNed so next block start at ALIGNed address */ |
|||
realsize = ALIGN(realsize); |
|||
|
|||
TRACE("avail: %lu (%luKB). Allocate size: %lu realsize: %lu (%luKB)" |
|||
, mem->avail, mem->avail / 1024 |
|||
, size |
|||
, realsize, realsize / 1024 |
|||
); |
|||
do { |
|||
p = NULL; |
|||
if (mem->avail < realsize) { |
|||
TRACE("%s", " oom"); |
|||
break; |
|||
} |
|||
|
|||
b = NULL; |
|||
minsize = ULONG_MAX; |
|||
|
|||
/* prev|cur */ |
|||
|
|||
for (prev = mem->headblock; prev->next; prev = cur) { |
|||
/* while (prev->next != 0) { */ |
|||
cur = prev->next; |
|||
xc_block_check(cur); |
|||
if (cur->size == realsize) { |
|||
/* found a perfect fit, stop searching */ |
|||
b = prev; |
|||
break; |
|||
} |
|||
/* make sure we can split on the block */ |
|||
else if (cur->size > (sizeof(xc_block_t) + realsize) && |
|||
cur->size < minsize) { |
|||
/* cur is acceptable and memller */ |
|||
b = prev; |
|||
minsize = cur->size; |
|||
} |
|||
prev = cur; |
|||
} |
|||
|
|||
if (b == NULL) { |
|||
TRACE("%s", " no fit chunk"); |
|||
break; |
|||
} |
|||
|
|||
prev = b; |
|||
|
|||
cur = prev->next; |
|||
p = PADD(cur, BLOCK_HEADER_SIZE()); |
|||
|
|||
/* update the block header */ |
|||
mem->avail -= realsize; |
|||
|
|||
/* perfect fit, just unlink */ |
|||
if (cur->size == realsize) { |
|||
prev->next = cur->next; |
|||
TRACE(" perfect fit. Got: %p", p); |
|||
break; |
|||
} |
|||
|
|||
/* make new free block after alloced space */ |
|||
|
|||
/* save, as it might be overwrited by newb (cur->size is ok) */ |
|||
b = cur->next; |
|||
|
|||
/* prev|cur |next=b */ |
|||
|
|||
newb = (xc_block_t *)PADD(cur, realsize); |
|||
xc_block_setup(newb, cur->size - realsize, b); |
|||
cur->size = realsize; |
|||
/* prev|cur|newb|next |
|||
* `--^ |
|||
*/ |
|||
|
|||
TRACE(" -> avail: %lu (%luKB). new next: %p offset: %lu %luKB. Got: %p" |
|||
, mem->avail, mem->avail / 1024 |
|||
, newb |
|||
, PSUB(newb, mem), PSUB(newb, mem) / 1024 |
|||
, p |
|||
); |
|||
prev->next = newb; |
|||
/* prev|cur|newb|next |
|||
* `-----^ |
|||
*/ |
|||
|
|||
} while (0); |
|||
|
|||
return p; |
|||
} |
|||
/* }}} */ |
|||
static XC_MEM_FREE(xc_mem_free) /* {{{ return block size freed */ |
|||
{ |
|||
xc_block_t *cur, *b; |
|||
int size; |
|||
|
|||
cur = (xc_block_t *) (CHAR_PTR(p) - BLOCK_HEADER_SIZE()); |
|||
TRACE("freeing: %p, size=%lu", p, cur->size); |
|||
xc_block_check(cur); |
|||
assert((char*)mem < (char*)cur && (char*)cur < (char*)mem + mem->size); |
|||
|
|||
/* find free block right before the p */ |
|||
b = mem->headblock; |
|||
while (b->next != 0 && b->next < cur) { |
|||
b = b->next; |
|||
} |
|||
|
|||
/* restore block */ |
|||
cur->next = b->next; |
|||
b->next = cur; |
|||
size = cur->size; |
|||
|
|||
TRACE(" avail %lu (%luKB)", mem->avail, mem->avail / 1024); |
|||
mem->avail += size; |
|||
|
|||
/* combine prev|cur */ |
|||
if (PADD(b, b->size) == (char *)cur) { |
|||
b->size += cur->size; |
|||
b->next = cur->next; |
|||
cur = b; |
|||
TRACE("%s", " combine prev"); |
|||
} |
|||
|
|||
/* combine cur|next */ |
|||
b = cur->next; |
|||
if (PADD(cur, cur->size) == (char *)b) { |
|||
cur->size += b->size; |
|||
cur->next = b->next; |
|||
TRACE("%s", " combine next"); |
|||
} |
|||
TRACE(" -> avail %lu (%luKB)", mem->avail, mem->avail / 1024); |
|||
return size; |
|||
} |
|||
/* }}} */ |
|||
static XC_MEM_CALLOC(xc_mem_calloc) /* {{{ */ |
|||
{ |
|||
xc_memsize_t realsize = memb * size; |
|||
void *p = xc_mem_malloc(mem, realsize); |
|||
|
|||
if (p) { |
|||
memset(p, 0, realsize); |
|||
} |
|||
return p; |
|||
} |
|||
/* }}} */ |
|||
static XC_MEM_REALLOC(xc_mem_realloc) /* {{{ */ |
|||
{ |
|||
void *newp = xc_mem_malloc(mem, size); |
|||
if (p && newp) { |
|||
memcpy(newp, p, size); |
|||
xc_mem_free(mem, p); |
|||
} |
|||
return newp; |
|||
} |
|||
/* }}} */ |
|||
static XC_MEM_STRNDUP(xc_mem_strndup) /* {{{ */ |
|||
{ |
|||
void *p = xc_mem_malloc(mem, len + 1); |
|||
if (p) { |
|||
memcpy(p, str, len + 1); |
|||
} |
|||
return p; |
|||
} |
|||
/* }}} */ |
|||
static XC_MEM_STRDUP(xc_mem_strdup) /* {{{ */ |
|||
{ |
|||
return xc_mem_strndup(mem, str, strlen(str)); |
|||
} |
|||
/* }}} */ |
|||
|
|||
static XC_MEM_AVAIL(xc_mem_avail) /* {{{ */ |
|||
{ |
|||
return mem->avail; |
|||
} |
|||
/* }}} */ |
|||
static XC_MEM_SIZE(xc_mem_size) /* {{{ */ |
|||
{ |
|||
return mem->size; |
|||
} |
|||
/* }}} */ |
|||
|
|||
static XC_MEM_FREEBLOCK_FIRST(xc_mem_freeblock_first) /* {{{ */ |
|||
{ |
|||
return mem->headblock->next; |
|||
} |
|||
/* }}} */ |
|||
XC_MEM_FREEBLOCK_NEXT(xc_mem_freeblock_next) /* {{{ */ |
|||
{ |
|||
return block->next; |
|||
} |
|||
/* }}} */ |
|||
XC_MEM_BLOCK_SIZE(xc_mem_block_size) /* {{{ */ |
|||
{ |
|||
return block->size; |
|||
} |
|||
/* }}} */ |
|||
XC_MEM_BLOCK_OFFSET(xc_mem_block_offset) /* {{{ */ |
|||
{ |
|||
return ((char *) block) - ((char *) mem); |
|||
} |
|||
/* }}} */ |
|||
|
|||
static XC_MEM_INIT(xc_mem_init) /* {{{ */ |
|||
{ |
|||
xc_block_t *b; |
|||
#define MINSIZE (ALIGN(sizeof(xc_mem_t)) + sizeof(xc_block_t)) |
|||
/* requires at least the header and 1 tail block */ |
|||
if (size < MINSIZE) { |
|||
fprintf(stderr, "xc_mem_init requires %lu bytes at least\n", (unsigned long) MINSIZE); |
|||
return NULL; |
|||
} |
|||
TRACE("size=%lu", size); |
|||
mem->shm = shm; |
|||
mem->size = size; |
|||
mem->avail = size - MINSIZE; |
|||
|
|||
/* pointer to first block, right after ALIGNed header */ |
|||
b = mem->headblock; |
|||
xc_block_setup(b, 0, (xc_block_t *) PADD(mem, ALIGN(sizeof(xc_mem_t)))); |
|||
|
|||
/* first block*/ |
|||
b = b->next; |
|||
xc_block_setup(b, mem->avail, 0); |
|||
#undef MINSIZE |
|||
|
|||
return mem; |
|||
} |
|||
/* }}} */ |
|||
static XC_MEM_DESTROY(xc_mem_destroy) /* {{{ */ |
|||
{ |
|||
} |
|||
/* }}} */ |
|||
|
|||
#ifdef TEST |
|||
/* {{{ testing */ |
|||
#undef CHECK |
|||
#define CHECK(a, msg) do { \ |
|||
if (!(a)) { \ |
|||
fprintf(stderr, "%s\n", msg); return -1; \ |
|||
} \ |
|||
} while (0) |
|||
|
|||
#include <time.h> |
|||
|
|||
int main() |
|||
{ |
|||
int count = 0; |
|||
void *p; |
|||
void *memory; |
|||
xc_mem_t *mem; |
|||
void **ptrs; |
|||
int size, i; |
|||
|
|||
#if 0 |
|||
fprintf(stderr, "%s", "Input test size: "); |
|||
scanf("%d", &size); |
|||
#else |
|||
size = 1024; |
|||
#endif |
|||
CHECK(memory = malloc(size), "OOM"); |
|||
CHECK(ptrs = malloc(size * sizeof(void *)), "OOM"); |
|||
mem = (xc_mem_t *) memory; |
|||
CHECK(mem = xc_mem_init(NULL, mem, size), "Failed init memory allocator"); |
|||
|
|||
while ((p = xc_mem_malloc(mem, 1))) { |
|||
ptrs[count ++] = p; |
|||
} |
|||
fprintf(stderr, "count=%d, random freeing\n", count); |
|||
srandom(time(NULL)); |
|||
while (count) { |
|||
i = (random() % count); |
|||
fprintf(stderr, "freeing %d: ", i); |
|||
xc_mem_free(mem, ptrs[i]); |
|||
ptrs[i] = ptrs[count - 1]; |
|||
count --; |
|||
} |
|||
|
|||
free(ptrs); |
|||
free(memory); |
|||
return 0; |
|||
} |
|||
/* }}} */ |
|||
#endif |
|||
|
|||
typedef struct { |
|||
const char *name; |
|||
const xc_mem_handlers_t *handlers; |
|||
} xc_mem_scheme_t; |
|||
static xc_mem_scheme_t xc_mem_schemes[10]; |
|||
|
|||
int xc_mem_scheme_register(const char *name, const xc_mem_handlers_t *handlers) /* {{{ */ |
|||
{ |
|||
int i; |
|||
for (i = 0; i < 10; i ++) { |
|||
if (!xc_mem_schemes[i].name) { |
|||
xc_mem_schemes[i].name = name; |
|||
xc_mem_schemes[i].handlers = handlers; |
|||
return 1; |
|||
} |
|||
} |
|||
return 0; |
|||
} |
|||
/* }}} */ |
|||
const xc_mem_handlers_t *xc_mem_scheme_find(const char *name) /* {{{ */ |
|||
{ |
|||
int i; |
|||
for (i = 0; i < 10 && xc_mem_schemes[i].name; i ++) { |
|||
if (strcmp(xc_mem_schemes[i].name, name) == 0) { |
|||
return xc_mem_schemes[i].handlers; |
|||
} |
|||
} |
|||
return NULL; |
|||
} |
|||
/* }}} */ |
|||
|
|||
static xc_mem_handlers_t xc_mem_mem_handlers = XC_MEM_HANDLERS(mem); |
|||
void xc_shm_mem_init() /* {{{ */ |
|||
{ |
|||
memset(xc_mem_schemes, 0, sizeof(xc_mem_schemes)); |
|||
|
|||
if (xc_mem_scheme_register("mem", &xc_mem_mem_handlers) == 0) { |
|||
zend_error(E_ERROR, "XCache: failed to register mem mem_scheme"); |
|||
} |
|||
} |
|||
/* }}} */ |
|||
@ -1,74 +0,0 @@ |
|||
#include "xc_shm.h" |
|||
|
|||
typedef struct _xc_mem_handlers_t xc_mem_handlers_t; |
|||
|
|||
#ifndef XC_MEM_IMPL |
|||
struct _xc_mem_t { |
|||
const xc_mem_handlers_t *handlers; |
|||
xc_shm_t *shm; |
|||
}; |
|||
# define XC_MEM_IMPL _xc_mem_t |
|||
#endif |
|||
|
|||
#ifndef XC_MEMBLOCK_IMPL |
|||
# define XC_MEMBLOCK_IMPL _xc_block_t |
|||
#endif |
|||
typedef struct XC_MEM_IMPL xc_mem_t; |
|||
typedef struct XC_MEMBLOCK_IMPL xc_block_t; |
|||
typedef xc_shmsize_t xc_memsize_t; |
|||
|
|||
/* shm::mem */ |
|||
#define XC_MEM_MALLOC(func) void *func(xc_mem_t *mem, xc_memsize_t size) |
|||
#define XC_MEM_FREE(func) xc_memsize_t func(xc_mem_t *mem, const void *p) |
|||
#define XC_MEM_CALLOC(func) void *func(xc_mem_t *mem, xc_memsize_t memb, xc_memsize_t size) |
|||
#define XC_MEM_REALLOC(func) void *func(xc_mem_t *mem, const void *p, xc_memsize_t size) |
|||
#define XC_MEM_STRNDUP(func) char *func(xc_mem_t *mem, const char *str, xc_memsize_t len) |
|||
#define XC_MEM_STRDUP(func) char *func(xc_mem_t *mem, const char *str) |
|||
#define XC_MEM_AVAIL(func) xc_memsize_t func(const xc_mem_t *mem) |
|||
#define XC_MEM_SIZE(func) xc_memsize_t func(const xc_mem_t *mem) |
|||
#define XC_MEM_FREEBLOCK_FIRST(func) const xc_block_t *func(const xc_mem_t *mem) |
|||
#define XC_MEM_FREEBLOCK_NEXT(func) const xc_block_t *func(const xc_block_t *block) |
|||
#define XC_MEM_BLOCK_SIZE(func) xc_memsize_t func(const xc_block_t *block) |
|||
#define XC_MEM_BLOCK_OFFSET(func) xc_memsize_t func(const xc_mem_t *mem, const xc_block_t *block) |
|||
|
|||
#define XC_MEM_INIT(func) xc_mem_t *func(xc_shm_t *shm, xc_mem_t *mem, xc_memsize_t size) |
|||
#define XC_MEM_DESTROY(func) void func(xc_mem_t *mem) |
|||
|
|||
#define XC_MEM_HANDLERS(name) { \ |
|||
xc_##name##_malloc \ |
|||
, xc_##name##_free \ |
|||
, xc_##name##_calloc \ |
|||
, xc_##name##_realloc \ |
|||
, xc_##name##_strndup \ |
|||
, xc_##name##_strdup \ |
|||
, xc_##name##_avail \ |
|||
, xc_##name##_size \ |
|||
, xc_##name##_freeblock_first \ |
|||
, xc_##name##_freeblock_next \ |
|||
, xc_##name##_block_size \ |
|||
, xc_##name##_block_offset \ |
|||
\ |
|||
, xc_##name##_init \ |
|||
, xc_##name##_destroy \ |
|||
} |
|||
|
|||
struct _xc_mem_handlers_t { |
|||
XC_MEM_MALLOC((*malloc)); |
|||
XC_MEM_FREE((*free)); |
|||
XC_MEM_CALLOC((*calloc)); |
|||
XC_MEM_REALLOC((*realloc)); |
|||
XC_MEM_STRNDUP((*strndup)); |
|||
XC_MEM_STRDUP((*strdup)); |
|||
XC_MEM_AVAIL((*avail)); |
|||
XC_MEM_SIZE((*size)); |
|||
XC_MEM_FREEBLOCK_FIRST((*freeblock_first)); |
|||
XC_MEM_FREEBLOCK_NEXT((*freeblock_next)); |
|||
XC_MEM_BLOCK_SIZE((*block_size)); |
|||
XC_MEM_BLOCK_OFFSET((*block_offset)); |
|||
|
|||
XC_MEM_INIT((*init)); |
|||
XC_MEM_DESTROY((*destroy)); |
|||
}; |
|||
|
|||
int xc_mem_scheme_register(const char *name, const xc_mem_handlers_t *handlers); |
|||
const xc_mem_handlers_t *xc_mem_scheme_find(const char *name); |
|||