151 lines
4.3 KiB
C
151 lines
4.3 KiB
C
|
#ifndef _H_MSPACE
|
||
|
|
#define _H_MSPACE
|
||
|
|
|
||
|
|
#define NO_MALLINFO 1
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
extern "C" {
|
||
|
|
#endif /* __cplusplus */
|
||
|
|
|
||
|
|
//typedef unsigned long size_t;
|
||
|
|
typedef void (*mspace_abort_t)(void *user_data);
|
||
|
|
typedef void (*mspace_print_t)(void *user_data, char *format, ...);
|
||
|
|
|
||
|
|
void mspace_set_abort_func(mspace_abort_t f);
|
||
|
|
void mspace_set_print_func(mspace_print_t f);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace is an opaque type representing an independent
|
||
|
|
region of space that supports mspace_malloc, etc.
|
||
|
|
*/
|
||
|
|
typedef void* mspace;
|
||
|
|
|
||
|
|
/*
|
||
|
|
create_mspace creates and returns a new independent space with the
|
||
|
|
given initial capacity, or, if 0, the default granularity size. It
|
||
|
|
returns null if there is no system memory available to create the
|
||
|
|
space. If argument locked is non-zero, the space uses a separate
|
||
|
|
lock to control access. The capacity of the space will grow
|
||
|
|
dynamically as needed to service mspace_malloc requests. You can
|
||
|
|
control the sizes of incremental increases of this space by
|
||
|
|
compiling with a different DEFAULT_GRANULARITY or dynamically
|
||
|
|
setting with mallopt(M_GRANULARITY, value).
|
||
|
|
*/
|
||
|
|
//mspace create_mspace(size_t capacity, int locked);
|
||
|
|
|
||
|
|
/*
|
||
|
|
destroy_mspace destroys the given space, and attempts to return all
|
||
|
|
of its memory back to the system, returning the total number of
|
||
|
|
bytes freed. After destruction, the results of access to all memory
|
||
|
|
used by the space become undefined.
|
||
|
|
*/
|
||
|
|
//size_t destroy_mspace(mspace msp);
|
||
|
|
|
||
|
|
/*
|
||
|
|
create_mspace_with_base uses the memory supplied as the initial base
|
||
|
|
of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this
|
||
|
|
space is used for bookkeeping, so the capacity must be at least this
|
||
|
|
large. (Otherwise 0 is returned.) When this initial space is
|
||
|
|
exhausted, additional memory will be obtained from the system.
|
||
|
|
Destroying this space will deallocate all additionally allocated
|
||
|
|
space (if possible) but not the initial base.
|
||
|
|
*/
|
||
|
|
mspace create_mspace_with_base(void* base, size_t capacity, int locked, void *user_data);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_malloc behaves as malloc, but operates within
|
||
|
|
the given space.
|
||
|
|
*/
|
||
|
|
void* mspace_malloc(mspace msp, size_t bytes);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_free behaves as free, but operates within
|
||
|
|
the given space.
|
||
|
|
|
||
|
|
If compiled with FOOTERS==1, mspace_free is not actually needed.
|
||
|
|
free may be called instead of mspace_free because freed chunks from
|
||
|
|
any space are handled by their originating spaces.
|
||
|
|
*/
|
||
|
|
void mspace_free(mspace msp, void* mem);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_realloc behaves as realloc, but operates within
|
||
|
|
the given space.
|
||
|
|
|
||
|
|
If compiled with FOOTERS==1, mspace_realloc is not actually
|
||
|
|
needed. realloc may be called instead of mspace_realloc because
|
||
|
|
realloced chunks from any space are handled by their originating
|
||
|
|
spaces.
|
||
|
|
*/
|
||
|
|
void* mspace_realloc(mspace msp, void* mem, size_t newsize);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_calloc behaves as calloc, but operates within
|
||
|
|
the given space.
|
||
|
|
*/
|
||
|
|
void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_memalign behaves as memalign, but operates within
|
||
|
|
the given space.
|
||
|
|
*/
|
||
|
|
void* mspace_memalign(mspace msp, size_t alignment, size_t bytes);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_independent_calloc behaves as independent_calloc, but
|
||
|
|
operates within the given space.
|
||
|
|
*/
|
||
|
|
//void** mspace_independent_calloc(mspace msp, size_t n_elements,
|
||
|
|
// size_t elem_size, void* chunks[]);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_independent_comalloc behaves as independent_comalloc, but
|
||
|
|
operates within the given space.
|
||
|
|
*/
|
||
|
|
//void** mspace_independent_comalloc(mspace msp, size_t n_elements,
|
||
|
|
// size_t sizes[], void* chunks[]);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_footprint() returns the number of bytes obtained from the
|
||
|
|
system for this space.
|
||
|
|
*/
|
||
|
|
size_t mspace_footprint(mspace msp);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_max_footprint() returns the peak number of bytes obtained from the
|
||
|
|
system for this space.
|
||
|
|
*/
|
||
|
|
size_t mspace_max_footprint(mspace msp);
|
||
|
|
|
||
|
|
|
||
|
|
#if !NO_MALLINFO
|
||
|
|
/*
|
||
|
|
mspace_mallinfo behaves as mallinfo, but reports properties of
|
||
|
|
the given space.
|
||
|
|
*/
|
||
|
|
struct mallinfo mspace_mallinfo(mspace msp);
|
||
|
|
#endif /* NO_MALLINFO */
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_malloc_stats behaves as malloc_stats, but reports
|
||
|
|
properties of the given space.
|
||
|
|
*/
|
||
|
|
void mspace_malloc_stats(mspace msp);
|
||
|
|
|
||
|
|
/*
|
||
|
|
mspace_trim behaves as malloc_trim, but
|
||
|
|
operates within the given space.
|
||
|
|
*/
|
||
|
|
//int mspace_trim(mspace msp, size_t pad);
|
||
|
|
|
||
|
|
/*
|
||
|
|
An alias for mallopt.
|
||
|
|
*/
|
||
|
|
int mspace_mallopt(int, int);
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
}; /* end of extern "C" */
|
||
|
|
#endif /* __cplusplus */
|
||
|
|
|
||
|
|
#endif
|