You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
545 lines
19 KiB
545 lines
19 KiB
/*
|
|
Default header file for malloc-2.8.x, written by Doug Lea
|
|
and released to the public domain, as explained at
|
|
http://creativecommons.org/licenses/publicdomain.
|
|
|
|
last update: Mon Aug 15 08:55:52 2005 Doug Lea (dl at gee)
|
|
|
|
This header is for ANSI C/C++ only. You can set any of
|
|
the following #defines before including:
|
|
|
|
* If USE_DL_PREFIX is defined, it is assumed that malloc.c
|
|
was also compiled with this option, so all routines
|
|
have names starting with "dl".
|
|
|
|
* If HAVE_USR_INCLUDE_MALLOC_H is defined, it is assumed that this
|
|
file will be #included after <malloc.h>. this is needed only if
|
|
your system defines a struct mallinfo that is incompatible with the
|
|
standard one declared here. Otherwise, you can include this file
|
|
INSTEAD of your system system <malloc.h>. At least on ANSI, all
|
|
declarations should be compatible with system versions
|
|
|
|
* If MSPACES is defined, declarations for mspace versions are included.
|
|
*/
|
|
|
|
#ifndef MALLOC_280_H
|
|
#define MALLOC_280_H
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <stddef.h> /* for size_t */
|
|
|
|
#define USE_DL_PREFIX
|
|
|
|
#if !ONLY_MSPACES
|
|
|
|
#ifndef USE_DL_PREFIX
|
|
#define dlcalloc calloc
|
|
#define dlfree free
|
|
#define dlmalloc malloc
|
|
#define dlmemalign memalign
|
|
#define dlrealloc realloc
|
|
#define dlvalloc valloc
|
|
#define dlpvalloc pvalloc
|
|
#define dlmallinfo mallinfo
|
|
#define dlmallopt mallopt
|
|
#define dlmalloc_trim malloc_trim
|
|
#define dlmalloc_stats malloc_stats
|
|
#define dlmalloc_usable_size malloc_usable_size
|
|
#define dlmalloc_footprint malloc_footprint
|
|
#define dlindependent_calloc independent_calloc
|
|
#define dlindependent_comalloc independent_comalloc
|
|
#endif /* USE_DL_PREFIX */
|
|
|
|
|
|
/*
|
|
malloc(size_t n)
|
|
Returns a pointer to a newly allocated chunk of at least n bytes, or
|
|
null if no space is available, in which case errno is set to ENOMEM
|
|
on ANSI C systems.
|
|
|
|
If n is zero, malloc returns a minimum-sized chunk. (The minimum
|
|
size is 16 bytes on most 32bit systems, and 32 bytes on 64bit
|
|
systems.) Note that size_t is an unsigned type, so calls with
|
|
arguments that would be negative if signed are interpreted as
|
|
requests for huge amounts of space, which will often fail. The
|
|
maximum supported value of n differs across systems, but is in all
|
|
cases less than the maximum representable value of a size_t.
|
|
*/
|
|
void* dlmalloc(size_t);
|
|
|
|
/*
|
|
free(void* p)
|
|
Releases the chunk of memory pointed to by p, that had been previously
|
|
allocated using malloc or a related routine such as realloc.
|
|
It has no effect if p is null. If p was not malloced or already
|
|
freed, free(p) will by default cuase the current program to abort.
|
|
*/
|
|
void dlfree(void*);
|
|
|
|
/*
|
|
calloc(size_t n_elements, size_t element_size);
|
|
Returns a pointer to n_elements * element_size bytes, with all locations
|
|
set to zero.
|
|
*/
|
|
void* dlcalloc(size_t, size_t);
|
|
|
|
/*
|
|
realloc(void* p, size_t n)
|
|
Returns a pointer to a chunk of size n that contains the same data
|
|
as does chunk p up to the minimum of (n, p's size) bytes, or null
|
|
if no space is available.
|
|
|
|
The returned pointer may or may not be the same as p. The algorithm
|
|
prefers extending p in most cases when possible, otherwise it
|
|
employs the equivalent of a malloc-copy-free sequence.
|
|
|
|
If p is null, realloc is equivalent to malloc.
|
|
|
|
If space is not available, realloc returns null, errno is set (if on
|
|
ANSI) and p is NOT freed.
|
|
|
|
if n is for fewer bytes than already held by p, the newly unused
|
|
space is lopped off and freed if possible. realloc with a size
|
|
argument of zero (re)allocates a minimum-sized chunk.
|
|
|
|
The old unix realloc convention of allowing the last-free'd chunk
|
|
to be used as an argument to realloc is not supported.
|
|
*/
|
|
|
|
void* dlrealloc(void*, size_t);
|
|
|
|
/*
|
|
memalign(size_t alignment, size_t n);
|
|
Returns a pointer to a newly allocated chunk of n bytes, aligned
|
|
in accord with the alignment argument.
|
|
|
|
The alignment argument should be a power of two. If the argument is
|
|
not a power of two, the nearest greater power is used.
|
|
8-byte alignment is guaranteed by normal malloc calls, so don't
|
|
bother calling memalign with an argument of 8 or less.
|
|
|
|
Overreliance on memalign is a sure way to fragment space.
|
|
*/
|
|
void* dlmemalign(size_t, size_t);
|
|
|
|
/*
|
|
valloc(size_t n);
|
|
Equivalent to memalign(pagesize, n), where pagesize is the page
|
|
size of the system. If the pagesize is unknown, 4096 is used.
|
|
*/
|
|
void* dlvalloc(size_t);
|
|
|
|
/*
|
|
mallopt(int parameter_number, int parameter_value)
|
|
Sets tunable parameters The format is to provide a
|
|
(parameter-number, parameter-value) pair. mallopt then sets the
|
|
corresponding parameter to the argument value if it can (i.e., so
|
|
long as the value is meaningful), and returns 1 if successful else
|
|
0. SVID/XPG/ANSI defines four standard param numbers for mallopt,
|
|
normally defined in malloc.h. None of these are use in this malloc,
|
|
so setting them has no effect. But this malloc also supports other
|
|
options in mallopt:
|
|
|
|
Symbol param # default allowed param values
|
|
M_TRIM_THRESHOLD -1 2*1024*1024 any (-1U disables trimming)
|
|
M_GRANULARITY -2 page size any power of 2 >= page size
|
|
M_MMAP_THRESHOLD -3 256*1024 any (or 0 if no MMAP support)
|
|
*/
|
|
int dlmallopt(int, int);
|
|
|
|
#define M_TRIM_THRESHOLD (-1)
|
|
#define M_GRANULARITY (-2)
|
|
#define M_MMAP_THRESHOLD (-3)
|
|
|
|
|
|
/*
|
|
malloc_footprint();
|
|
Returns the number of bytes obtained from the system. The total
|
|
number of bytes allocated by malloc, realloc etc., is less than this
|
|
value. Unlike mallinfo, this function returns only a precomputed
|
|
result, so can be called frequently to monitor memory consumption.
|
|
Even if locks are otherwise defined, this function does not use them,
|
|
so results might not be up to date.
|
|
*/
|
|
size_t dlmalloc_footprint(void);
|
|
|
|
#if !NO_MALLINFO
|
|
/*
|
|
mallinfo()
|
|
Returns (by copy) a struct containing various summary statistics:
|
|
|
|
arena: current total non-mmapped bytes allocated from system
|
|
ordblks: the number of free chunks
|
|
smblks: always zero.
|
|
hblks: current number of mmapped regions
|
|
hblkhd: total bytes held in mmapped regions
|
|
usmblks: the maximum total allocated space. This will be greater
|
|
than current total if trimming has occurred.
|
|
fsmblks: always zero
|
|
uordblks: current total allocated space (normal or mmapped)
|
|
fordblks: total free space
|
|
keepcost: the maximum number of bytes that could ideally be released
|
|
back to system via malloc_trim. ("ideally" means that
|
|
it ignores page restrictions etc.)
|
|
|
|
Because these fields are ints, but internal bookkeeping may
|
|
be kept as longs, the reported values may wrap around zero and
|
|
thus be inaccurate.
|
|
*/
|
|
#ifndef HAVE_USR_INCLUDE_MALLOC_H
|
|
#ifndef _MALLOC_H
|
|
#ifndef MALLINFO_FIELD_TYPE
|
|
#define MALLINFO_FIELD_TYPE size_t
|
|
#endif /* MALLINFO_FIELD_TYPE */
|
|
struct mallinfo {
|
|
MALLINFO_FIELD_TYPE arena; /* non-mmapped space allocated from system */
|
|
MALLINFO_FIELD_TYPE ordblks; /* number of free chunks */
|
|
MALLINFO_FIELD_TYPE smblks; /* always 0 */
|
|
MALLINFO_FIELD_TYPE hblks; /* always 0 */
|
|
MALLINFO_FIELD_TYPE hblkhd; /* space in mmapped regions */
|
|
MALLINFO_FIELD_TYPE usmblks; /* maximum total allocated space */
|
|
MALLINFO_FIELD_TYPE fsmblks; /* always 0 */
|
|
MALLINFO_FIELD_TYPE uordblks; /* total allocated space */
|
|
MALLINFO_FIELD_TYPE fordblks; /* total free space */
|
|
MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */
|
|
};
|
|
#endif /* _MALLOC_H */
|
|
#endif /* HAVE_USR_INCLUDE_MALLOC_H */
|
|
|
|
struct mallinfo dlmallinfo(void);
|
|
#endif /* NO_MALLINFO */
|
|
|
|
/*
|
|
independent_calloc(size_t n_elements, size_t element_size, void* chunks[]);
|
|
|
|
independent_calloc is similar to calloc, but instead of returning a
|
|
single cleared space, it returns an array of pointers to n_elements
|
|
independent elements that can hold contents of size elem_size, each
|
|
of which starts out cleared, and can be independently freed,
|
|
realloc'ed etc. The elements are guaranteed to be adjacently
|
|
allocated (this is not guaranteed to occur with multiple callocs or
|
|
mallocs), which may also improve cache locality in some
|
|
applications.
|
|
|
|
The "chunks" argument is optional (i.e., may be null, which is
|
|
probably the most typical usage). If it is null, the returned array
|
|
is itself dynamically allocated and should also be freed when it is
|
|
no longer needed. Otherwise, the chunks array must be of at least
|
|
n_elements in length. It is filled in with the pointers to the
|
|
chunks.
|
|
|
|
In either case, independent_calloc returns this pointer array, or
|
|
null if the allocation failed. If n_elements is zero and "chunks"
|
|
is null, it returns a chunk representing an array with zero elements
|
|
(which should be freed if not wanted).
|
|
|
|
Each element must be individually freed when it is no longer
|
|
needed. If you'd like to instead be able to free all at once, you
|
|
should instead use regular calloc and assign pointers into this
|
|
space to represent elements. (In this case though, you cannot
|
|
independently free elements.)
|
|
|
|
independent_calloc simplifies and speeds up implementations of many
|
|
kinds of pools. It may also be useful when constructing large data
|
|
structures that initially have a fixed number of fixed-sized nodes,
|
|
but the number is not known at compile time, and some of the nodes
|
|
may later need to be freed. For example:
|
|
|
|
struct Node { int item; struct Node* next; };
|
|
|
|
struct Node* build_list() {
|
|
struct Node** pool;
|
|
int n = read_number_of_nodes_needed();
|
|
if (n <= 0) return 0;
|
|
pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
|
|
if (pool == 0) die();
|
|
// organize into a linked list...
|
|
struct Node* first = pool[0];
|
|
for (i = 0; i < n-1; ++i)
|
|
pool[i]->next = pool[i+1];
|
|
free(pool); // Can now free the array (or not, if it is needed later)
|
|
return first;
|
|
}
|
|
*/
|
|
void** dlindependent_calloc(size_t, size_t, void**);
|
|
|
|
/*
|
|
independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]);
|
|
|
|
independent_comalloc allocates, all at once, a set of n_elements
|
|
chunks with sizes indicated in the "sizes" array. It returns
|
|
an array of pointers to these elements, each of which can be
|
|
independently freed, realloc'ed etc. The elements are guaranteed to
|
|
be adjacently allocated (this is not guaranteed to occur with
|
|
multiple callocs or mallocs), which may also improve cache locality
|
|
in some applications.
|
|
|
|
The "chunks" argument is optional (i.e., may be null). If it is null
|
|
the returned array is itself dynamically allocated and should also
|
|
be freed when it is no longer needed. Otherwise, the chunks array
|
|
must be of at least n_elements in length. It is filled in with the
|
|
pointers to the chunks.
|
|
|
|
In either case, independent_comalloc returns this pointer array, or
|
|
null if the allocation failed. If n_elements is zero and chunks is
|
|
null, it returns a chunk representing an array with zero elements
|
|
(which should be freed if not wanted).
|
|
|
|
Each element must be individually freed when it is no longer
|
|
needed. If you'd like to instead be able to free all at once, you
|
|
should instead use a single regular malloc, and assign pointers at
|
|
particular offsets in the aggregate space. (In this case though, you
|
|
cannot independently free elements.)
|
|
|
|
independent_comallac differs from independent_calloc in that each
|
|
element may have a different size, and also that it does not
|
|
automatically clear elements.
|
|
|
|
independent_comalloc can be used to speed up allocation in cases
|
|
where several structs or objects must always be allocated at the
|
|
same time. For example:
|
|
|
|
struct Head { ... }
|
|
struct Foot { ... }
|
|
|
|
void send_message(char* msg) {
|
|
int msglen = strlen(msg);
|
|
size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
|
|
void* chunks[3];
|
|
if (independent_comalloc(3, sizes, chunks) == 0)
|
|
die();
|
|
struct Head* head = (struct Head*)(chunks[0]);
|
|
char* body = (char*)(chunks[1]);
|
|
struct Foot* foot = (struct Foot*)(chunks[2]);
|
|
// ...
|
|
}
|
|
|
|
In general though, independent_comalloc is worth using only for
|
|
larger values of n_elements. For small values, you probably won't
|
|
detect enough difference from series of malloc calls to bother.
|
|
|
|
Overuse of independent_comalloc can increase overall memory usage,
|
|
since it cannot reuse existing noncontiguous small chunks that
|
|
might be available for some of the elements.
|
|
*/
|
|
void** dlindependent_comalloc(size_t, size_t*, void**);
|
|
|
|
|
|
/*
|
|
pvalloc(size_t n);
|
|
Equivalent to valloc(minimum-page-that-holds(n)), that is,
|
|
round up n to nearest pagesize.
|
|
*/
|
|
void* dlpvalloc(size_t);
|
|
|
|
/*
|
|
malloc_trim(size_t pad);
|
|
|
|
If possible, gives memory back to the system (via negative arguments
|
|
to sbrk) if there is unused memory at the `high' end of the malloc
|
|
pool or in unused MMAP segments. You can call this after freeing
|
|
large blocks of memory to potentially reduce the system-level memory
|
|
requirements of a program. However, it cannot guarantee to reduce
|
|
memory. Under some allocation patterns, some large free blocks of
|
|
memory will be locked between two used chunks, so they cannot be
|
|
given back to the system.
|
|
|
|
The `pad' argument to malloc_trim represents the amount of free
|
|
trailing space to leave untrimmed. If this argument is zero, only
|
|
the minimum amount of memory to maintain internal data structures
|
|
will be left. Non-zero arguments can be supplied to maintain enough
|
|
trailing space to service future expected allocations without having
|
|
to re-obtain memory from the system.
|
|
|
|
Malloc_trim returns 1 if it actually released any memory, else 0.
|
|
*/
|
|
int dlmalloc_trim(size_t);
|
|
|
|
/*
|
|
malloc_usable_size(void* p);
|
|
|
|
Returns the number of bytes you can actually use in
|
|
an allocated chunk, which may be more than you requested (although
|
|
often not) due to alignment and minimum size constraints.
|
|
You can use this many bytes without worrying about
|
|
overwriting other allocated objects. This is not a particularly great
|
|
programming practice. malloc_usable_size can be more useful in
|
|
debugging and assertions, for example:
|
|
|
|
p = malloc(n);
|
|
assert(malloc_usable_size(p) >= 256);
|
|
*/
|
|
size_t dlmalloc_usable_size(void*);
|
|
|
|
/*
|
|
malloc_stats();
|
|
Prints on stderr the amount of space obtained from the system (both
|
|
via sbrk and mmap), the maximum amount (which may be more than
|
|
current if malloc_trim and/or munmap got called), and the current
|
|
number of bytes allocated via malloc (or realloc, etc) but not yet
|
|
freed. Note that this is the number of bytes allocated, not the
|
|
number requested. It will be larger than the number requested
|
|
because of alignment and bookkeeping overhead. Because it includes
|
|
alignment wastage as being in use, this figure may be greater than
|
|
zero even when no user-level chunks are allocated.
|
|
|
|
The reported current and maximum system memory can be inaccurate if
|
|
a program makes other calls to system memory allocation functions
|
|
(normally sbrk) outside of malloc.
|
|
|
|
malloc_stats prints only the most commonly interesting statistics.
|
|
More information can be obtained by calling mallinfo.
|
|
*/
|
|
void dlmalloc_stats(void);
|
|
|
|
#endif /* !ONLY_MSPACES */
|
|
|
|
#if MSPACES
|
|
|
|
/*
|
|
mspace is an opaque type representing an independent
|
|
region of space that supports mspace_malloc, etc.
|
|
*/
|
|
typedef void* mspace;
|
|
|
|
void *global_mspace();
|
|
void *determine_mspace(void *mem);
|
|
|
|
/*
|
|
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);
|
|
|
|
/*
|
|
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 malloc_usable_size.
|
|
*/
|
|
size_t mspace_usable_size(void *mem);
|
|
|
|
/*
|
|
An alias for mallopt.
|
|
*/
|
|
int mspace_mallopt(int, int);
|
|
|
|
#endif /* MSPACES */
|
|
|
|
#ifdef __cplusplus
|
|
}; /* end of extern "C" */
|
|
#endif
|
|
|
|
#endif /* MALLOC_280_H */
|