mirror of https://github.com/Qortal/Brooklyn
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.
3265 lines
100 KiB
3265 lines
100 KiB
/* ---------- To make a malloc.h, start cutting here ------------ */ |
||
|
||
/* |
||
A version of malloc/free/realloc written by Doug Lea and released to the |
||
public domain. Send questions/comments/complaints/performance data |
||
to [email protected] |
||
|
||
* VERSION 2.6.6 Sun Mar 5 19:10:03 2000 Doug Lea (dl at gee) |
||
|
||
Note: There may be an updated version of this malloc obtainable at |
||
ftp://g.oswego.edu/pub/misc/malloc.c |
||
Check before installing! |
||
|
||
* Why use this malloc? |
||
|
||
This is not the fastest, most space-conserving, most portable, or |
||
most tunable malloc ever written. However it is among the fastest |
||
while also being among the most space-conserving, portable and tunable. |
||
Consistent balance across these factors results in a good general-purpose |
||
allocator. For a high-level description, see |
||
http://g.oswego.edu/dl/html/malloc.html |
||
|
||
* Synopsis of public routines |
||
|
||
(Much fuller descriptions are contained in the program documentation below.) |
||
|
||
malloc(size_t n); |
||
Return a pointer to a newly allocated chunk of at least n bytes, or null |
||
if no space is available. |
||
free(Void_t* p); |
||
Release the chunk of memory pointed to by p, or no effect if p is null. |
||
realloc(Void_t* p, size_t n); |
||
Return 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. If p is null, equivalent to malloc. Unless the |
||
#define REALLOC_ZERO_BYTES_FREES below is set, realloc with a |
||
size argument of zero (re)allocates a minimum-sized chunk. |
||
memalign(size_t alignment, size_t n); |
||
Return a pointer to a newly allocated chunk of n bytes, aligned |
||
in accord with the alignment argument, which must be a power of |
||
two. |
||
valloc(size_t n); |
||
Equivalent to memalign(pagesize, n), where pagesize is the page |
||
size of the system (or as near to this as can be figured out from |
||
all the includes/defines below.) |
||
pvalloc(size_t n); |
||
Equivalent to valloc(minimum-page-that-holds(n)), that is, |
||
round up n to nearest pagesize. |
||
calloc(size_t unit, size_t quantity); |
||
Returns a pointer to quantity * unit bytes, with all locations |
||
set to zero. |
||
cfree(Void_t* p); |
||
Equivalent to free(p). |
||
malloc_trim(size_t pad); |
||
Release all but pad bytes of freed top-most memory back |
||
to the system. Return 1 if successful, else 0. |
||
malloc_usable_size(Void_t* p); |
||
Report the number usable allocated bytes associated with allocated |
||
chunk p. This may or may not report more bytes than were requested, |
||
due to alignment and minimum size constraints. |
||
malloc_stats(); |
||
Prints brief summary statistics on stderr. |
||
mallinfo() |
||
Returns (by copy) a struct containing various summary statistics. |
||
mallopt(int parameter_number, int parameter_value) |
||
Changes one of the tunable parameters described below. Returns |
||
1 if successful in changing the parameter, else 0. |
||
|
||
* Vital statistics: |
||
|
||
Alignment: 8-byte |
||
8 byte alignment is currently hardwired into the design. This |
||
seems to suffice for all current machines and C compilers. |
||
|
||
Assumed pointer representation: 4 or 8 bytes |
||
Code for 8-byte pointers is untested by me but has worked |
||
reliably by Wolfram Gloger, who contributed most of the |
||
changes supporting this. |
||
|
||
Assumed size_t representation: 4 or 8 bytes |
||
Note that size_t is allowed to be 4 bytes even if pointers are 8. |
||
|
||
Minimum overhead per allocated chunk: 4 or 8 bytes |
||
Each malloced chunk has a hidden overhead of 4 bytes holding size |
||
and status information. |
||
|
||
Minimum allocated size: 4-byte ptrs: 16 bytes (including 4 overhead) |
||
8-byte ptrs: 24/32 bytes (including, 4/8 overhead) |
||
|
||
When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte |
||
ptrs but 4 byte size) or 24 (for 8/8) additional bytes are |
||
needed; 4 (8) for a trailing size field |
||
and 8 (16) bytes for free list pointers. Thus, the minimum |
||
allocatable size is 16/24/32 bytes. |
||
|
||
Even a request for zero bytes (i.e., malloc(0)) returns a |
||
pointer to something of the minimum allocatable size. |
||
|
||
Maximum allocated size: 4-byte size_t: 2^31 - 8 bytes |
||
8-byte size_t: 2^63 - 16 bytes |
||
|
||
It is assumed that (possibly signed) size_t bit values suffice to |
||
represent chunk sizes. `Possibly signed' is due to the fact |
||
that `size_t' may be defined on a system as either a signed or |
||
an unsigned type. To be conservative, values that would appear |
||
as negative numbers are avoided. |
||
Requests for sizes with a negative sign bit when the request |
||
size is treaded as a long will return null. |
||
|
||
Maximum overhead wastage per allocated chunk: normally 15 bytes |
||
|
||
Alignnment demands, plus the minimum allocatable size restriction |
||
make the normal worst-case wastage 15 bytes (i.e., up to 15 |
||
more bytes will be allocated than were requested in malloc), with |
||
two exceptions: |
||
1. Because requests for zero bytes allocate non-zero space, |
||
the worst case wastage for a request of zero bytes is 24 bytes. |
||
2. For requests >= mmap_threshold that are serviced via |
||
mmap(), the worst case wastage is 8 bytes plus the remainder |
||
from a system page (the minimal mmap unit); typically 4096 bytes. |
||
|
||
* Limitations |
||
|
||
Here are some features that are NOT currently supported |
||
|
||
* No user-definable hooks for callbacks and the like. |
||
* No automated mechanism for fully checking that all accesses |
||
to malloced memory stay within their bounds. |
||
* No support for compaction. |
||
|
||
* Synopsis of compile-time options: |
||
|
||
People have reported using previous versions of this malloc on all |
||
versions of Unix, sometimes by tweaking some of the defines |
||
below. It has been tested most extensively on Solaris and |
||
Linux. It is also reported to work on WIN32 platforms. |
||
People have also reported adapting this malloc for use in |
||
stand-alone embedded systems. |
||
|
||
The implementation is in straight, hand-tuned ANSI C. Among other |
||
consequences, it uses a lot of macros. Because of this, to be at |
||
all usable, this code should be compiled using an optimizing compiler |
||
(for example gcc -O2) that can simplify expressions and control |
||
paths. |
||
|
||
__STD_C (default: derived from C compiler defines) |
||
Nonzero if using ANSI-standard C compiler, a C++ compiler, or |
||
a C compiler sufficiently close to ANSI to get away with it. |
||
DEBUG (default: NOT defined) |
||
Define to enable debugging. Adds fairly extensive assertion-based |
||
checking to help track down memory errors, but noticeably slows down |
||
execution. |
||
REALLOC_ZERO_BYTES_FREES (default: NOT defined) |
||
Define this if you think that realloc(p, 0) should be equivalent |
||
to free(p). Otherwise, since malloc returns a unique pointer for |
||
malloc(0), so does realloc(p, 0). |
||
HAVE_MEMCPY (default: defined) |
||
Define if you are not otherwise using ANSI STD C, but still |
||
have memcpy and memset in your C library and want to use them. |
||
Otherwise, simple internal versions are supplied. |
||
USE_MEMCPY (default: 1 if HAVE_MEMCPY is defined, 0 otherwise) |
||
Define as 1 if you want the C library versions of memset and |
||
memcpy called in realloc and calloc (otherwise macro versions are used). |
||
At least on some platforms, the simple macro versions usually |
||
outperform libc versions. |
||
HAVE_MMAP (default: defined as 1) |
||
Define to non-zero to optionally make malloc() use mmap() to |
||
allocate very large blocks. |
||
HAVE_MREMAP (default: defined as 0 unless Linux libc set) |
||
Define to non-zero to optionally make realloc() use mremap() to |
||
reallocate very large blocks. |
||
malloc_getpagesize (default: derived from system #includes) |
||
Either a constant or routine call returning the system page size. |
||
HAVE_USR_INCLUDE_MALLOC_H (default: NOT defined) |
||
Optionally define if you are on a system with a /usr/include/malloc.h |
||
that declares struct mallinfo. It is not at all necessary to |
||
define this even if you do, but will ensure consistency. |
||
INTERNAL_SIZE_T (default: size_t) |
||
Define to a 32-bit type (probably `unsigned int') if you are on a |
||
64-bit machine, yet do not want or need to allow malloc requests of |
||
greater than 2^31 to be handled. This saves space, especially for |
||
very small chunks. |
||
INTERNAL_LINUX_C_LIB (default: NOT defined) |
||
Defined only when compiled as part of Linux libc. |
||
Also note that there is some odd internal name-mangling via defines |
||
(for example, internally, `malloc' is named `mALLOc') needed |
||
when compiling in this case. These look funny but don't otherwise |
||
affect anything. |
||
WIN32 (default: undefined) |
||
Define this on MS win (95, nt) platforms to compile in sbrk emulation. |
||
LACKS_UNISTD_H (default: undefined if not WIN32) |
||
Define this if your system does not have a <unistd.h>. |
||
LACKS_SYS_PARAM_H (default: undefined if not WIN32) |
||
Define this if your system does not have a <sys/param.h>. |
||
MORECORE (default: sbrk) |
||
The name of the routine to call to obtain more memory from the system. |
||
MORECORE_FAILURE (default: -1) |
||
The value returned upon failure of MORECORE. |
||
MORECORE_CLEARS (default 1) |
||
true (1) if the routine mapped to MORECORE zeroes out memory (which |
||
holds for sbrk). |
||
DEFAULT_TRIM_THRESHOLD |
||
DEFAULT_TOP_PAD |
||
DEFAULT_MMAP_THRESHOLD |
||
DEFAULT_MMAP_MAX |
||
Default values of tunable parameters (described in detail below) |
||
controlling interaction with host system routines (sbrk, mmap, etc). |
||
These values may also be changed dynamically via mallopt(). The |
||
preset defaults are those that give best performance for typical |
||
programs/systems. |
||
USE_DL_PREFIX (default: undefined) |
||
Prefix all public routines with the string 'dl'. Useful to |
||
quickly avoid procedure declaration conflicts and linker symbol |
||
conflicts with existing memory allocation routines. |
||
|
||
|
||
*/ |
||
|
||
|
||
|
||
|
||
/* Preliminaries */ |
||
|
||
#ifndef __STD_C |
||
#ifdef __STDC__ |
||
#define __STD_C 1 |
||
#else |
||
#if __cplusplus |
||
#define __STD_C 1 |
||
#else |
||
#define __STD_C 0 |
||
#endif /*__cplusplus*/ |
||
#endif /*__STDC__*/ |
||
#endif /*__STD_C*/ |
||
|
||
#ifndef Void_t |
||
#if (__STD_C || defined(WIN32)) |
||
#define Void_t void |
||
#else |
||
#define Void_t char |
||
#endif |
||
#endif /*Void_t*/ |
||
|
||
#if __STD_C |
||
#include <stddef.h> /* for size_t */ |
||
#else |
||
#include <sys/types.h> |
||
#endif |
||
|
||
#ifdef __cplusplus |
||
extern "C" { |
||
#endif |
||
|
||
#include <stdio.h> /* needed for malloc_stats */ |
||
|
||
|
||
/* |
||
Compile-time options |
||
*/ |
||
|
||
|
||
/* |
||
Debugging: |
||
|
||
Because freed chunks may be overwritten with link fields, this |
||
malloc will often die when freed memory is overwritten by user |
||
programs. This can be very effective (albeit in an annoying way) |
||
in helping track down dangling pointers. |
||
|
||
If you compile with -DDEBUG, a number of assertion checks are |
||
enabled that will catch more memory errors. You probably won't be |
||
able to make much sense of the actual assertion errors, but they |
||
should help you locate incorrectly overwritten memory. The |
||
checking is fairly extensive, and will slow down execution |
||
noticeably. Calling malloc_stats or mallinfo with DEBUG set will |
||
attempt to check every non-mmapped allocated and free chunk in the |
||
course of computing the summmaries. (By nature, mmapped regions |
||
cannot be checked very much automatically.) |
||
|
||
Setting DEBUG may also be helpful if you are trying to modify |
||
this code. The assertions in the check routines spell out in more |
||
detail the assumptions and invariants underlying the algorithms. |
||
|
||
*/ |
||
|
||
#if DEBUG |
||
#include <assert.h> |
||
#else |
||
#define assert(x) ((void)0) |
||
#endif |
||
|
||
|
||
/* |
||
INTERNAL_SIZE_T is the word-size used for internal bookkeeping |
||
of chunk sizes. On a 64-bit machine, you can reduce malloc |
||
overhead by defining INTERNAL_SIZE_T to be a 32 bit `unsigned int' |
||
at the expense of not being able to handle requests greater than |
||
2^31. This limitation is hardly ever a concern; you are encouraged |
||
to set this. However, the default version is the same as size_t. |
||
*/ |
||
|
||
#ifndef INTERNAL_SIZE_T |
||
#define INTERNAL_SIZE_T size_t |
||
#endif |
||
|
||
/* |
||
REALLOC_ZERO_BYTES_FREES should be set if a call to |
||
realloc with zero bytes should be the same as a call to free. |
||
Some people think it should. Otherwise, since this malloc |
||
returns a unique pointer for malloc(0), so does realloc(p, 0). |
||
*/ |
||
|
||
|
||
/* #define REALLOC_ZERO_BYTES_FREES */ |
||
|
||
|
||
/* |
||
WIN32 causes an emulation of sbrk to be compiled in |
||
mmap-based options are not currently supported in WIN32. |
||
*/ |
||
|
||
/* #define WIN32 */ |
||
#ifdef WIN32 |
||
#define MORECORE wsbrk |
||
#define HAVE_MMAP 0 |
||
|
||
#define LACKS_UNISTD_H |
||
#define LACKS_SYS_PARAM_H |
||
|
||
/* |
||
Include 'windows.h' to get the necessary declarations for the |
||
Microsoft Visual C++ data structures and routines used in the 'sbrk' |
||
emulation. |
||
|
||
Define WIN32_LEAN_AND_MEAN so that only the essential Microsoft |
||
Visual C++ header files are included. |
||
*/ |
||
#define WIN32_LEAN_AND_MEAN |
||
#include <windows.h> |
||
#endif |
||
|
||
|
||
/* |
||
HAVE_MEMCPY should be defined if you are not otherwise using |
||
ANSI STD C, but still have memcpy and memset in your C library |
||
and want to use them in calloc and realloc. Otherwise simple |
||
macro versions are defined here. |
||
|
||
USE_MEMCPY should be defined as 1 if you actually want to |
||
have memset and memcpy called. People report that the macro |
||
versions are often enough faster than libc versions on many |
||
systems that it is better to use them. |
||
|
||
*/ |
||
|
||
#define HAVE_MEMCPY |
||
|
||
#ifndef USE_MEMCPY |
||
#ifdef HAVE_MEMCPY |
||
#define USE_MEMCPY 1 |
||
#else |
||
#define USE_MEMCPY 0 |
||
#endif |
||
#endif |
||
|
||
#if (__STD_C || defined(HAVE_MEMCPY)) |
||
|
||
#if __STD_C |
||
void* memset(void*, int, size_t); |
||
void* memcpy(void*, const void*, size_t); |
||
#else |
||
#ifdef WIN32 |
||
/* On Win32 platforms, 'memset()' and 'memcpy()' are already declared in */ |
||
/* 'windows.h' */ |
||
#else |
||
Void_t* memset(); |
||
Void_t* memcpy(); |
||
#endif |
||
#endif |
||
#endif |
||
|
||
#if USE_MEMCPY |
||
|
||
/* The following macros are only invoked with (2n+1)-multiples of |
||
INTERNAL_SIZE_T units, with a positive integer n. This is exploited |
||
for fast inline execution when n is small. */ |
||
|
||
#define MALLOC_ZERO(charp, nbytes) \ |
||
do { \ |
||
INTERNAL_SIZE_T mzsz = (nbytes); \ |
||
if(mzsz <= 9*sizeof(mzsz)) { \ |
||
INTERNAL_SIZE_T* mz = (INTERNAL_SIZE_T*) (charp); \ |
||
if(mzsz >= 5*sizeof(mzsz)) { *mz++ = 0; \ |
||
*mz++ = 0; \ |
||
if(mzsz >= 7*sizeof(mzsz)) { *mz++ = 0; \ |
||
*mz++ = 0; \ |
||
if(mzsz >= 9*sizeof(mzsz)) { *mz++ = 0; \ |
||
*mz++ = 0; }}} \ |
||
*mz++ = 0; \ |
||
*mz++ = 0; \ |
||
*mz = 0; \ |
||
} else memset((charp), 0, mzsz); \ |
||
} while(0) |
||
|
||
#define MALLOC_COPY(dest,src,nbytes) \ |
||
do { \ |
||
INTERNAL_SIZE_T mcsz = (nbytes); \ |
||
if(mcsz <= 9*sizeof(mcsz)) { \ |
||
INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) (src); \ |
||
INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) (dest); \ |
||
if(mcsz >= 5*sizeof(mcsz)) { *mcdst++ = *mcsrc++; \ |
||
*mcdst++ = *mcsrc++; \ |
||
if(mcsz >= 7*sizeof(mcsz)) { *mcdst++ = *mcsrc++; \ |
||
*mcdst++ = *mcsrc++; \ |
||
if(mcsz >= 9*sizeof(mcsz)) { *mcdst++ = *mcsrc++; \ |
||
*mcdst++ = *mcsrc++; }}} \ |
||
*mcdst++ = *mcsrc++; \ |
||
*mcdst++ = *mcsrc++; \ |
||
*mcdst = *mcsrc ; \ |
||
} else memcpy(dest, src, mcsz); \ |
||
} while(0) |
||
|
||
#else /* !USE_MEMCPY */ |
||
|
||
/* Use Duff's device for good zeroing/copying performance. */ |
||
|
||
#define MALLOC_ZERO(charp, nbytes) \ |
||
do { \ |
||
INTERNAL_SIZE_T* mzp = (INTERNAL_SIZE_T*)(charp); \ |
||
long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T), mcn; \ |
||
if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \ |
||
switch (mctmp) { \ |
||
case 0: for(;;) { *mzp++ = 0; \ |
||
case 7: *mzp++ = 0; \ |
||
case 6: *mzp++ = 0; \ |
||
case 5: *mzp++ = 0; \ |
||
case 4: *mzp++ = 0; \ |
||
case 3: *mzp++ = 0; \ |
||
case 2: *mzp++ = 0; \ |
||
case 1: *mzp++ = 0; if(mcn <= 0) break; mcn--; } \ |
||
} \ |
||
} while(0) |
||
|
||
#define MALLOC_COPY(dest,src,nbytes) \ |
||
do { \ |
||
INTERNAL_SIZE_T* mcsrc = (INTERNAL_SIZE_T*) src; \ |
||
INTERNAL_SIZE_T* mcdst = (INTERNAL_SIZE_T*) dest; \ |
||
long mctmp = (nbytes)/sizeof(INTERNAL_SIZE_T), mcn; \ |
||
if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp %= 8; } \ |
||
switch (mctmp) { \ |
||
case 0: for(;;) { *mcdst++ = *mcsrc++; \ |
||
case 7: *mcdst++ = *mcsrc++; \ |
||
case 6: *mcdst++ = *mcsrc++; \ |
||
case 5: *mcdst++ = *mcsrc++; \ |
||
case 4: *mcdst++ = *mcsrc++; \ |
||
case 3: *mcdst++ = *mcsrc++; \ |
||
case 2: *mcdst++ = *mcsrc++; \ |
||
case 1: *mcdst++ = *mcsrc++; if(mcn <= 0) break; mcn--; } \ |
||
} \ |
||
} while(0) |
||
|
||
#endif |
||
|
||
|
||
/* |
||
Define HAVE_MMAP to optionally make malloc() use mmap() to |
||
allocate very large blocks. These will be returned to the |
||
operating system immediately after a free(). |
||
*/ |
||
|
||
#ifndef HAVE_MMAP |
||
#define HAVE_MMAP 1 |
||
#endif |
||
|
||
/* |
||
Define HAVE_MREMAP to make realloc() use mremap() to re-allocate |
||
large blocks. This is currently only possible on Linux with |
||
kernel versions newer than 1.3.77. |
||
*/ |
||
|
||
#ifndef HAVE_MREMAP |
||
#ifdef INTERNAL_LINUX_C_LIB |
||
#define HAVE_MREMAP 1 |
||
#else |
||
#define HAVE_MREMAP 0 |
||
#endif |
||
#endif |
||
|
||
#if HAVE_MMAP |
||
|
||
#include <unistd.h> |
||
#include <fcntl.h> |
||
#include <sys/mman.h> |
||
|
||
#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON) |
||
#define MAP_ANONYMOUS MAP_ANON |
||
#endif |
||
|
||
#endif /* HAVE_MMAP */ |
||
|
||
/* |
||
Access to system page size. To the extent possible, this malloc |
||
manages memory from the system in page-size units. |
||
|
||
The following mechanics for getpagesize were adapted from |
||
bsd/gnu getpagesize.h |
||
*/ |
||
|
||
#ifndef LACKS_UNISTD_H |
||
# include <unistd.h> |
||
#endif |
||
|
||
#ifndef malloc_getpagesize |
||
# ifdef _SC_PAGESIZE /* some SVR4 systems omit an underscore */ |
||
# ifndef _SC_PAGE_SIZE |
||
# define _SC_PAGE_SIZE _SC_PAGESIZE |
||
# endif |
||
# endif |
||
# ifdef _SC_PAGE_SIZE |
||
# define malloc_getpagesize sysconf(_SC_PAGE_SIZE) |
||
# else |
||
# if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE) |
||
extern size_t getpagesize(); |
||
# define malloc_getpagesize getpagesize() |
||
# else |
||
# ifdef WIN32 |
||
# define malloc_getpagesize (4096) /* TBD: Use 'GetSystemInfo' instead */ |
||
# else |
||
# ifndef LACKS_SYS_PARAM_H |
||
# include <sys/param.h> |
||
# endif |
||
# ifdef EXEC_PAGESIZE |
||
# define malloc_getpagesize EXEC_PAGESIZE |
||
# else |
||
# ifdef NBPG |
||
# ifndef CLSIZE |
||
# define malloc_getpagesize NBPG |
||
# else |
||
# define malloc_getpagesize (NBPG * CLSIZE) |
||
# endif |
||
# else |
||
# ifdef NBPC |
||
# define malloc_getpagesize NBPC |
||
# else |
||
# ifdef PAGESIZE |
||
# define malloc_getpagesize PAGESIZE |
||
# else |
||
# define malloc_getpagesize (4096) /* just guess */ |
||
# endif |
||
# endif |
||
# endif |
||
# endif |
||
# endif |
||
# endif |
||
# endif |
||
#endif |
||
|
||
|
||
/* |
||
|
||
This version of malloc supports the standard SVID/XPG mallinfo |
||
routine that returns a struct containing the same kind of |
||
information you can get from malloc_stats. It should work on |
||
any SVID/XPG compliant system that has a /usr/include/malloc.h |
||
defining struct mallinfo. (If you'd like to install such a thing |
||
yourself, cut out the preliminary declarations as described above |
||
and below and save them in a malloc.h file. But there's no |
||
compelling reason to bother to do this.) |
||
|
||
The main declaration needed is the mallinfo struct that is returned |
||
(by-copy) by mallinfo(). The SVID/XPG malloinfo struct contains a |
||
bunch of fields, most of which are not even meaningful in this |
||
version of malloc. Some of these fields are are instead filled by |
||
mallinfo() with other numbers that might possibly be of interest. |
||
|
||
HAVE_USR_INCLUDE_MALLOC_H should be set if you have a |
||
/usr/include/malloc.h file that includes a declaration of struct |
||
mallinfo. If so, it is included; else an SVID2/XPG2 compliant |
||
version is declared below. These must be precisely the same for |
||
mallinfo() to work. |
||
|
||
*/ |
||
|
||
/* #define HAVE_USR_INCLUDE_MALLOC_H */ |
||
|
||
#if HAVE_USR_INCLUDE_MALLOC_H |
||
#include "/usr/include/malloc.h" |
||
#else |
||
|
||
/* SVID2/XPG mallinfo structure */ |
||
|
||
struct mallinfo { |
||
int arena; /* total space allocated from system */ |
||
int ordblks; /* number of non-inuse chunks */ |
||
int smblks; /* unused -- always zero */ |
||
int hblks; /* number of mmapped regions */ |
||
int hblkhd; /* total space in mmapped regions */ |
||
int usmblks; /* unused -- always zero */ |
||
int fsmblks; /* unused -- always zero */ |
||
int uordblks; /* total allocated space */ |
||
int fordblks; /* total non-inuse space */ |
||
int keepcost; /* top-most, releasable (via malloc_trim) space */ |
||
}; |
||
|
||
/* SVID2/XPG mallopt options */ |
||
|
||
#define M_MXFAST 1 /* UNUSED in this malloc */ |
||
#define M_NLBLKS 2 /* UNUSED in this malloc */ |
||
#define M_GRAIN 3 /* UNUSED in this malloc */ |
||
#define M_KEEP 4 /* UNUSED in this malloc */ |
||
|
||
#endif |
||
|
||
/* mallopt options that actually do something */ |
||
|
||
#define M_TRIM_THRESHOLD -1 |
||
#define M_TOP_PAD -2 |
||
#define M_MMAP_THRESHOLD -3 |
||
#define M_MMAP_MAX -4 |
||
|
||
|
||
#ifndef DEFAULT_TRIM_THRESHOLD |
||
#define DEFAULT_TRIM_THRESHOLD (128 * 1024) |
||
#endif |
||
|
||
/* |
||
M_TRIM_THRESHOLD is the maximum amount of unused top-most memory |
||
to keep before releasing via malloc_trim in free(). |
||
|
||
Automatic trimming is mainly useful in long-lived programs. |
||
Because trimming via sbrk can be slow on some systems, and can |
||
sometimes be wasteful (in cases where programs immediately |
||
afterward allocate more large chunks) the value should be high |
||
enough so that your overall system performance would improve by |
||
releasing. |
||
|
||
The trim threshold and the mmap control parameters (see below) |
||
can be traded off with one another. Trimming and mmapping are |
||
two different ways of releasing unused memory back to the |
||
system. Between these two, it is often possible to keep |
||
system-level demands of a long-lived program down to a bare |
||
minimum. For example, in one test suite of sessions measuring |
||
the XF86 X server on Linux, using a trim threshold of 128K and a |
||
mmap threshold of 192K led to near-minimal long term resource |
||
consumption. |
||
|
||
If you are using this malloc in a long-lived program, it should |
||
pay to experiment with these values. As a rough guide, you |
||
might set to a value close to the average size of a process |
||
(program) running on your system. Releasing this much memory |
||
would allow such a process to run in memory. Generally, it's |
||
worth it to tune for trimming rather tham memory mapping when a |
||
program undergoes phases where several large chunks are |
||
allocated and released in ways that can reuse each other's |
||
storage, perhaps mixed with phases where there are no such |
||
chunks at all. And in well-behaved long-lived programs, |
||
controlling release of large blocks via trimming versus mapping |
||
is usually faster. |
||
|
||
However, in most programs, these parameters serve mainly as |
||
protection against the system-level effects of carrying around |
||
massive amounts of unneeded memory. Since frequent calls to |
||
sbrk, mmap, and munmap otherwise degrade performance, the default |
||
parameters are set to relatively high values that serve only as |
||
safeguards. |
||
|
||
The default trim value is high enough to cause trimming only in |
||
fairly extreme (by current memory consumption standards) cases. |
||
It must be greater than page size to have any useful effect. To |
||
disable trimming completely, you can set to (unsigned long)(-1); |
||
|
||
|
||
*/ |
||
|
||
|
||
#ifndef DEFAULT_TOP_PAD |
||
#define DEFAULT_TOP_PAD (0) |
||
#endif |
||
|
||
/* |
||
M_TOP_PAD is the amount of extra `padding' space to allocate or |
||
retain whenever sbrk is called. It is used in two ways internally: |
||
|
||
* When sbrk is called to extend the top of the arena to satisfy |
||
a new malloc request, this much padding is added to the sbrk |
||
request. |
||
|
||
* When malloc_trim is called automatically from free(), |
||
it is used as the `pad' argument. |
||
|
||
In both cases, the actual amount of padding is rounded |
||
so that the end of the arena is always a system page boundary. |
||
|
||
The main reason for using padding is to avoid calling sbrk so |
||
often. Having even a small pad greatly reduces the likelihood |
||
that nearly every malloc request during program start-up (or |
||
after trimming) will invoke sbrk, which needlessly wastes |
||
time. |
||
|
||
Automatic rounding-up to page-size units is normally sufficient |
||
to avoid measurable overhead, so the default is 0. However, in |
||
systems where sbrk is relatively slow, it can pay to increase |
||
this value, at the expense of carrying around more memory than |
||
the program needs. |
||
|
||
*/ |
||
|
||
|
||
#ifndef DEFAULT_MMAP_THRESHOLD |
||
#define DEFAULT_MMAP_THRESHOLD (128 * 1024) |
||
#endif |
||
|
||
/* |
||
|
||
M_MMAP_THRESHOLD is the request size threshold for using mmap() |
||
to service a request. Requests of at least this size that cannot |
||
be allocated using already-existing space will be serviced via mmap. |
||
(If enough normal freed space already exists it is used instead.) |
||
|
||
Using mmap segregates relatively large chunks of memory so that |
||
they can be individually obtained and released from the host |
||
system. A request serviced through mmap is never reused by any |
||
other request (at least not directly; the system may just so |
||
happen to remap successive requests to the same locations). |
||
|
||
Segregating space in this way has the benefit that mmapped space |
||
can ALWAYS be individually released back to the system, which |
||
helps keep the system level memory demands of a long-lived |
||
program low. Mapped memory can never become `locked' between |
||
other chunks, as can happen with normally allocated chunks, which |
||
menas that even trimming via malloc_trim would not release them. |
||
|
||
However, it has the disadvantages that: |
||
|
||
1. The space cannot be reclaimed, consolidated, and then |
||
used to service later requests, as happens with normal chunks. |
||
2. It can lead to more wastage because of mmap page alignment |
||
requirements |
||
3. It causes malloc performance to be more dependent on host |
||
system memory management support routines which may vary in |
||
implementation quality and may impose arbitrary |
||
limitations. Generally, servicing a request via normal |
||
malloc steps is faster than going through a system's mmap. |
||
|
||
All together, these considerations should lead you to use mmap |
||
only for relatively large requests. |
||
|
||
|
||
*/ |
||
|
||
|
||
#ifndef DEFAULT_MMAP_MAX |
||
#if HAVE_MMAP |
||
#define DEFAULT_MMAP_MAX (64) |
||
#else |
||
#define DEFAULT_MMAP_MAX (0) |
||
#endif |
||
#endif |
||
|
||
/* |
||
M_MMAP_MAX is the maximum number of requests to simultaneously |
||
service using mmap. This parameter exists because: |
||
|
||
1. Some systems have a limited number of internal tables for |
||
use by mmap. |
||
2. In most systems, overreliance on mmap can degrade overall |
||
performance. |
||
3. If a program allocates many large regions, it is probably |
||
better off using normal sbrk-based allocation routines that |
||
can reclaim and reallocate normal heap memory. Using a |
||
small value allows transition into this mode after the |
||
first few allocations. |
||
|
||
Setting to 0 disables all use of mmap. If HAVE_MMAP is not set, |
||
the default value is 0, and attempts to set it to non-zero values |
||
in mallopt will fail. |
||
*/ |
||
|
||
|
||
/* |
||
USE_DL_PREFIX will prefix all public routines with the string 'dl'. |
||
Useful to quickly avoid procedure declaration conflicts and linker |
||
symbol conflicts with existing memory allocation routines. |
||
|
||
*/ |
||
|
||
/* #define USE_DL_PREFIX */ |
||
|
||
|
||
/* |
||
|
||
Special defines for linux libc |
||
|
||
Except when compiled using these special defines for Linux libc |
||
using weak aliases, this malloc is NOT designed to work in |
||
multithreaded applications. No semaphores or other concurrency |
||
control are provided to ensure that multiple malloc or free calls |
||
don't run at the same time, which could be disasterous. A single |
||
semaphore could be used across malloc, realloc, and free (which is |
||
essentially the effect of the linux weak alias approach). It would |
||
be hard to obtain finer granularity. |
||
|
||
*/ |
||
|
||
|
||
#ifdef INTERNAL_LINUX_C_LIB |
||
|
||
#if __STD_C |
||
|
||
Void_t * __default_morecore_init (ptrdiff_t); |
||
Void_t *(*__morecore)(ptrdiff_t) = __default_morecore_init; |
||
|
||
#else |
||
|
||
Void_t * __default_morecore_init (); |
||
Void_t *(*__morecore)() = __default_morecore_init; |
||
|
||
#endif |
||
|
||
#define MORECORE (*__morecore) |
||
#define MORECORE_FAILURE 0 |
||
#define MORECORE_CLEARS 1 |
||
|
||
#else /* INTERNAL_LINUX_C_LIB */ |
||
|
||
#if __STD_C |
||
extern Void_t* sbrk(ptrdiff_t); |
||
#else |
||
extern Void_t* sbrk(); |
||
#endif |
||
|
||
#ifndef MORECORE |
||
#define MORECORE sbrk |
||
#endif |
||
|
||
#ifndef MORECORE_FAILURE |
||
#define MORECORE_FAILURE -1 |
||
#endif |
||
|
||
#ifndef MORECORE_CLEARS |
||
#define MORECORE_CLEARS 1 |
||
#endif |
||
|
||
#endif /* INTERNAL_LINUX_C_LIB */ |
||
|
||
#if defined(INTERNAL_LINUX_C_LIB) && defined(__ELF__) |
||
|
||
#define cALLOc __libc_calloc |
||
#define fREe __libc_free |
||
#define mALLOc __libc_malloc |
||
#define mEMALIGn __libc_memalign |
||
#define rEALLOc __libc_realloc |
||
#define vALLOc __libc_valloc |
||
#define pvALLOc __libc_pvalloc |
||
#define mALLINFo __libc_mallinfo |
||
#define mALLOPt __libc_mallopt |
||
|
||
#pragma weak calloc = __libc_calloc |
||
#pragma weak free = __libc_free |
||
#pragma weak cfree = __libc_free |
||
#pragma weak malloc = __libc_malloc |
||
#pragma weak memalign = __libc_memalign |
||
#pragma weak realloc = __libc_realloc |
||
#pragma weak valloc = __libc_valloc |
||
#pragma weak pvalloc = __libc_pvalloc |
||
#pragma weak mallinfo = __libc_mallinfo |
||
#pragma weak mallopt = __libc_mallopt |
||
|
||
#else |
||
|
||
#ifdef USE_DL_PREFIX |
||
#define cALLOc dlcalloc |
||
#define fREe dlfree |
||
#define mALLOc dlmalloc |
||
#define mEMALIGn dlmemalign |
||
#define rEALLOc dlrealloc |
||
#define vALLOc dlvalloc |
||
#define pvALLOc dlpvalloc |
||
#define mALLINFo dlmallinfo |
||
#define mALLOPt dlmallopt |
||
#else /* USE_DL_PREFIX */ |
||
#define cALLOc calloc |
||
#define fREe free |
||
#define mALLOc malloc |
||
#define mEMALIGn memalign |
||
#define rEALLOc realloc |
||
#define vALLOc valloc |
||
#define pvALLOc pvalloc |
||
#define mALLINFo mallinfo |
||
#define mALLOPt mallopt |
||
#endif /* USE_DL_PREFIX */ |
||
|
||
#endif |
||
|
||
/* Public routines */ |
||
|
||
#if __STD_C |
||
|
||
Void_t* mALLOc(size_t); |
||
void fREe(Void_t*); |
||
Void_t* rEALLOc(Void_t*, size_t); |
||
Void_t* mEMALIGn(size_t, size_t); |
||
Void_t* vALLOc(size_t); |
||
Void_t* pvALLOc(size_t); |
||
Void_t* cALLOc(size_t, size_t); |
||
void cfree(Void_t*); |
||
int malloc_trim(size_t); |
||
size_t malloc_usable_size(Void_t*); |
||
void malloc_stats(); |
||
int mALLOPt(int, int); |
||
struct mallinfo mALLINFo(void); |
||
#else |
||
Void_t* mALLOc(); |
||
void fREe(); |
||
Void_t* rEALLOc(); |
||
Void_t* mEMALIGn(); |
||
Void_t* vALLOc(); |
||
Void_t* pvALLOc(); |
||
Void_t* cALLOc(); |
||
void cfree(); |
||
int malloc_trim(); |
||
size_t malloc_usable_size(); |
||
void malloc_stats(); |
||
int mALLOPt(); |
||
struct mallinfo mALLINFo(); |
||
#endif |
||
|
||
|
||
#ifdef __cplusplus |
||
}; /* end of extern "C" */ |
||
#endif |
||
|
||
/* ---------- To make a malloc.h, end cutting here ------------ */ |
||
|
||
|
||
/* |
||
Emulation of sbrk for WIN32 |
||
All code within the ifdef WIN32 is untested by me. |
||
|
||
Thanks to Martin Fong and others for supplying this. |
||
*/ |
||
|
||
|
||
#ifdef WIN32 |
||
|
||
#define AlignPage(add) (((add) + (malloc_getpagesize-1)) & \ |
||
~(malloc_getpagesize-1)) |
||
#define AlignPage64K(add) (((add) + (0x10000 - 1)) & ~(0x10000 - 1)) |
||
|
||
/* resrve 64MB to insure large contiguous space */ |
||
#define RESERVED_SIZE (1024*1024*64) |
||
#define NEXT_SIZE (2048*1024) |
||
#define TOP_MEMORY ((unsigned long)2*1024*1024*1024) |
||
|
||
struct GmListElement; |
||
typedef struct GmListElement GmListElement; |
||
|
||
struct GmListElement |
||
{ |
||
GmListElement* next; |
||
void* base; |
||
}; |
||
|
||
static GmListElement* head = 0; |
||
static unsigned int gNextAddress = 0; |
||
static unsigned int gAddressBase = 0; |
||
static unsigned int gAllocatedSize = 0; |
||
|
||
static |
||
GmListElement* makeGmListElement (void* bas) |
||
{ |
||
GmListElement* this; |
||
this = (GmListElement*)(void*)LocalAlloc (0, sizeof (GmListElement)); |
||
assert (this); |
||
if (this) |
||
{ |
||
this->base = bas; |
||
this->next = head; |
||
head = this; |
||
} |
||
return this; |
||
} |
||
|
||
void gcleanup () |
||
{ |
||
BOOL rval; |
||
assert ( (head == NULL) || (head->base == (void*)gAddressBase)); |
||
if (gAddressBase && (gNextAddress - gAddressBase)) |
||
{ |
||
rval = VirtualFree ((void*)gAddressBase, |
||
gNextAddress - gAddressBase, |
||
MEM_DECOMMIT); |
||
assert (rval); |
||
} |
||
while (head) |
||
{ |
||
GmListElement* next = head->next; |
||
rval = VirtualFree (head->base, 0, MEM_RELEASE); |
||
assert (rval); |
||
LocalFree (head); |
||
head = next; |
||
} |
||
} |
||
|
||
static |
||
void* findRegion (void* start_address, unsigned long size) |
||
{ |
||
MEMORY_BASIC_INFORMATION info; |
||
if (size >= TOP_MEMORY) return NULL; |
||
|
||
while ((unsigned long)start_address + size < TOP_MEMORY) |
||
{ |
||
VirtualQuery (start_address, &info, sizeof (info)); |
||
if ((info.State == MEM_FREE) && (info.RegionSize >= size)) |
||
return start_address; |
||
else |
||
{ |
||
/* Requested region is not available so see if the */ |
||
/* next region is available. Set 'start_address' */ |
||
/* to the next region and call 'VirtualQuery()' */ |
||
/* again. */ |
||
|
||
start_address = (char*)info.BaseAddress + info.RegionSize; |
||
|
||
/* Make sure we start looking for the next region */ |
||
/* on the *next* 64K boundary. Otherwise, even if */ |
||
/* the new region is free according to */ |
||
/* 'VirtualQuery()', the subsequent call to */ |
||
/* 'VirtualAlloc()' (which follows the call to */ |
||
/* this routine in 'wsbrk()') will round *down* */ |
||
/* the requested address to a 64K boundary which */ |
||
/* we already know is an address in the */ |
||
/* unavailable region. Thus, the subsequent call */ |
||
/* to 'VirtualAlloc()' will fail and bring us back */ |
||
/* here, causing us to go into an infinite loop. */ |
||
|
||
start_address = |
||
(void *) AlignPage64K((unsigned long) start_address); |
||
} |
||
} |
||
return NULL; |
||
|
||
} |
||
|
||
|
||
void* wsbrk (long size) |
||
{ |
||
void* tmp; |
||
if (size > 0) |
||
{ |
||
if (gAddressBase == 0) |
||
{ |
||
gAllocatedSize = max (RESERVED_SIZE, AlignPage (size)); |
||
gNextAddress = gAddressBase = |
||
(unsigned int)VirtualAlloc (NULL, gAllocatedSize, |
||
MEM_RESERVE, PAGE_NOACCESS); |
||
} else if (AlignPage (gNextAddress + size) > (gAddressBase + |
||
gAllocatedSize)) |
||
{ |
||
long new_size = max (NEXT_SIZE, AlignPage (size)); |
||
void* new_address = (void*)(gAddressBase+gAllocatedSize); |
||
do |
||
{ |
||
new_address = findRegion (new_address, new_size); |
||
|
||
if (new_address == 0) |
||
return (void*)-1; |
||
|
||
gAddressBase = gNextAddress = |
||
(unsigned int)VirtualAlloc (new_address, new_size, |
||
MEM_RESERVE, PAGE_NOACCESS); |
||
/* repeat in case of race condition */ |
||
/* The region that we found has been snagged */ |
||
/* by another thread */ |
||
} |
||
while (gAddressBase == 0); |
||
|
||
assert (new_address == (void*)gAddressBase); |
||
|
||
gAllocatedSize = new_size; |
||
|
||
if (!makeGmListElement ((void*)gAddressBase)) |
||
return (void*)-1; |
||
} |
||
if ((size + gNextAddress) > AlignPage (gNextAddress)) |
||
{ |
||
void* res; |
||
res = VirtualAlloc ((void*)AlignPage (gNextAddress), |
||
(size + gNextAddress - |
||
AlignPage (gNextAddress)), |
||
MEM_COMMIT, PAGE_READWRITE); |
||
if (res == 0) |
||
return (void*)-1; |
||
} |
||
tmp = (void*)gNextAddress; |
||
gNextAddress = (unsigned int)tmp + size; |
||
return tmp; |
||
} |
||
else if (size < 0) |
||
{ |
||
unsigned int alignedGoal = AlignPage (gNextAddress + size); |
||
/* Trim by releasing the virtual memory */ |
||
if (alignedGoal >= gAddressBase) |
||
{ |
||
VirtualFree ((void*)alignedGoal, gNextAddress - alignedGoal, |
||
MEM_DECOMMIT); |
||
gNextAddress = gNextAddress + size; |
||
return (void*)gNextAddress; |
||
} |
||
else |
||
{ |
||
VirtualFree ((void*)gAddressBase, gNextAddress - gAddressBase, |
||
MEM_DECOMMIT); |
||
gNextAddress = gAddressBase; |
||
return (void*)-1; |
||
} |
||
} |
||
else |
||
{ |
||
return (void*)gNextAddress; |
||
} |
||
} |
||
|
||
#endif |
||
|
||
|
||
|
||
/* |
||
Type declarations |
||
*/ |
||
|
||
|
||
struct malloc_chunk |
||
{ |
||
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */ |
||
INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */ |
||
struct malloc_chunk* fd; /* double links -- used only if free. */ |
||
struct malloc_chunk* bk; |
||
}; |
||
|
||
typedef struct malloc_chunk* mchunkptr; |
||
|
||
/* |
||
|
||
malloc_chunk details: |
||
|
||
(The following includes lightly edited explanations by Colin Plumb.) |
||
|
||
Chunks of memory are maintained using a `boundary tag' method as |
||
described in e.g., Knuth or Standish. (See the paper by Paul |
||
Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a |
||
survey of such techniques.) Sizes of free chunks are stored both |
||
in the front of each chunk and at the end. This makes |
||
consolidating fragmented chunks into bigger chunks very fast. The |
||
size fields also hold bits representing whether chunks are free or |
||
in use. |
||
|
||
An allocated chunk looks like this: |
||
|
||
|
||
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
| Size of previous chunk, if allocated | | |
||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
| Size of chunk, in bytes |P| |
||
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
| User data starts here... . |
||
. . |
||
. (malloc_usable_space() bytes) . |
||
. | |
||
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
| Size of chunk | |
||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
|
||
|
||
Where "chunk" is the front of the chunk for the purpose of most of |
||
the malloc code, but "mem" is the pointer that is returned to the |
||
user. "Nextchunk" is the beginning of the next contiguous chunk. |
||
|
||
Chunks always begin on even word boundries, so the mem portion |
||
(which is returned to the user) is also on an even word boundary, and |
||
thus double-word aligned. |
||
|
||
Free chunks are stored in circular doubly-linked lists, and look like this: |
||
|
||
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
| Size of previous chunk | |
||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
`head:' | Size of chunk, in bytes |P| |
||
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
| Forward pointer to next chunk in list | |
||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
| Back pointer to previous chunk in list | |
||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
| Unused space (may be 0 bytes long) . |
||
. . |
||
. | |
||
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
`foot:' | Size of chunk, in bytes | |
||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
||
|
||
The P (PREV_INUSE) bit, stored in the unused low-order bit of the |
||
chunk size (which is always a multiple of two words), is an in-use |
||
bit for the *previous* chunk. If that bit is *clear*, then the |
||
word before the current chunk size contains the previous chunk |
||
size, and can be used to find the front of the previous chunk. |
||
(The very first chunk allocated always has this bit set, |
||
preventing access to non-existent (or non-owned) memory.) |
||
|
||
Note that the `foot' of the current chunk is actually represented |
||
as the prev_size of the NEXT chunk. (This makes it easier to |
||
deal with alignments etc). |
||
|
||
The two exceptions to all this are |
||
|
||
1. The special chunk `top', which doesn't bother using the |
||
trailing size field since there is no |
||
next contiguous chunk that would have to index off it. (After |
||
initialization, `top' is forced to always exist. If it would |
||
become less than MINSIZE bytes long, it is replenished via |
||
malloc_extend_top.) |
||
|
||
2. Chunks allocated via mmap, which have the second-lowest-order |
||
bit (IS_MMAPPED) set in their size fields. Because they are |
||
never merged or traversed from any other chunk, they have no |
||
foot size or inuse information. |
||
|
||
Available chunks are kept in any of several places (all declared below): |
||
|
||
* `av': An array of chunks serving as bin headers for consolidated |
||
chunks. Each bin is doubly linked. The bins are approximately |
||
proportionally (log) spaced. There are a lot of these bins |
||
(128). This may look excessive, but works very well in |
||
practice. All procedures maintain the invariant that no |
||
consolidated chunk physically borders another one. Chunks in |
||
bins are kept in size order, with ties going to the |
||
approximately least recently used chunk. |
||
|
||
The chunks in each bin are maintained in decreasing sorted order by |
||
size. This is irrelevant for the small bins, which all contain |
||
the same-sized chunks, but facilitates best-fit allocation for |
||
larger chunks. (These lists are just sequential. Keeping them in |
||
order almost never requires enough traversal to warrant using |
||
fancier ordered data structures.) Chunks of the same size are |
||
linked with the most recently freed at the front, and allocations |
||
are taken from the back. This results in LRU or FIFO allocation |
||
order, which tends to give each chunk an equal opportunity to be |
||
consolidated with adjacent freed chunks, resulting in larger free |
||
chunks and less fragmentation. |
||
|
||
* `top': The top-most available chunk (i.e., the one bordering the |
||
end of available memory) is treated specially. It is never |
||
included in any bin, is used only if no other chunk is |
||
available, and is released back to the system if it is very |
||
large (see M_TRIM_THRESHOLD). |
||
|
||
* `last_remainder': A bin holding only the remainder of the |
||
most recently split (non-top) chunk. This bin is checked |
||
before other non-fitting chunks, so as to provide better |
||
locality for runs of sequentially allocated chunks. |
||
|
||
* Implicitly, through the host system's memory mapping tables. |
||
If supported, requests greater than a threshold are usually |
||
serviced via calls to mmap, and then later released via munmap. |
||
|
||
*/ |
||
|
||
|
||
|
||
|
||
|
||
/* sizes, alignments */ |
||
|
||
#define SIZE_SZ (sizeof(INTERNAL_SIZE_T)) |
||
#define MALLOC_ALIGNMENT (SIZE_SZ + SIZE_SZ) |
||
#define MALLOC_ALIGN_MASK (MALLOC_ALIGNMENT - 1) |
||
#define MINSIZE (sizeof(struct malloc_chunk)) |
||
|
||
/* conversion from malloc headers to user pointers, and back */ |
||
|
||
#define chunk2mem(p) ((Void_t*)((char*)(p) + 2*SIZE_SZ)) |
||
#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - 2*SIZE_SZ)) |
||
|
||
/* pad request bytes into a usable size */ |
||
|
||
#define request2size(req) \ |
||
(((long)((req) + (SIZE_SZ + MALLOC_ALIGN_MASK)) < \ |
||
(long)(MINSIZE + MALLOC_ALIGN_MASK)) ? MINSIZE : \ |
||
(((req) + (SIZE_SZ + MALLOC_ALIGN_MASK)) & ~(MALLOC_ALIGN_MASK))) |
||
|
||
/* Check if m has acceptable alignment */ |
||
|
||
#define aligned_OK(m) (((unsigned long)((m)) & (MALLOC_ALIGN_MASK)) == 0) |
||
|
||
|
||
|
||
|
||
/* |
||
Physical chunk operations |
||
*/ |
||
|
||
|
||
/* size field is or'ed with PREV_INUSE when previous adjacent chunk in use */ |
||
|
||
#define PREV_INUSE 0x1 |
||
|
||
/* size field is or'ed with IS_MMAPPED if the chunk was obtained with mmap() */ |
||
|
||
#define IS_MMAPPED 0x2 |
||
|
||
/* Bits to mask off when extracting size */ |
||
|
||
#define SIZE_BITS (PREV_INUSE|IS_MMAPPED) |
||
|
||
|
||
/* Ptr to next physical malloc_chunk. */ |
||
|
||
#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->size & ~PREV_INUSE) )) |
||
|
||
/* Ptr to previous physical malloc_chunk */ |
||
|
||
#define prev_chunk(p)\ |
||
((mchunkptr)( ((char*)(p)) - ((p)->prev_size) )) |
||
|
||
|
||
/* Treat space at ptr + offset as a chunk */ |
||
|
||
#define chunk_at_offset(p, s) ((mchunkptr)(((char*)(p)) + (s))) |
||
|
||
|
||
|
||
|
||
/* |
||
Dealing with use bits |
||
*/ |
||
|
||
/* extract p's inuse bit */ |
||
|
||
#define inuse(p)\ |
||
((((mchunkptr)(((char*)(p))+((p)->size & ~PREV_INUSE)))->size) & PREV_INUSE) |
||
|
||
/* extract inuse bit of previous chunk */ |
||
|
||
#define prev_inuse(p) ((p)->size & PREV_INUSE) |
||
|
||
/* check for mmap()'ed chunk */ |
||
|
||
#define chunk_is_mmapped(p) ((p)->size & IS_MMAPPED) |
||
|
||
/* set/clear chunk as in use without otherwise disturbing */ |
||
|
||
#define set_inuse(p)\ |
||
((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size |= PREV_INUSE |
||
|
||
#define clear_inuse(p)\ |
||
((mchunkptr)(((char*)(p)) + ((p)->size & ~PREV_INUSE)))->size &= ~(PREV_INUSE) |
||
|
||
/* check/set/clear inuse bits in known places */ |
||
|
||
#define inuse_bit_at_offset(p, s)\ |
||
(((mchunkptr)(((char*)(p)) + (s)))->size & PREV_INUSE) |
||
|
||
#define set_inuse_bit_at_offset(p, s)\ |
||
(((mchunkptr)(((char*)(p)) + (s)))->size |= PREV_INUSE) |
||
|
||
#define clear_inuse_bit_at_offset(p, s)\ |
||
(((mchunkptr)(((char*)(p)) + (s)))->size &= ~(PREV_INUSE)) |
||
|
||
|
||
|
||
|
||
/* |
||
Dealing with size fields |
||
*/ |
||
|
||
/* Get size, ignoring use bits */ |
||
|
||
#define chunksize(p) ((p)->size & ~(SIZE_BITS)) |
||
|
||
/* Set size at head, without disturbing its use bit */ |
||
|
||
#define set_head_size(p, s) ((p)->size = (((p)->size & PREV_INUSE) | (s))) |
||
|
||
/* Set size/use ignoring previous bits in header */ |
||
|
||
#define set_head(p, s) ((p)->size = (s)) |
||
|
||
/* Set size at footer (only when chunk is not in use) */ |
||
|
||
#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_size = (s)) |
||
|
||
|
||
|
||
|
||
|
||
/* |
||
Bins |
||
|
||
The bins, `av_' are an array of pairs of pointers serving as the |
||
heads of (initially empty) doubly-linked lists of chunks, laid out |
||
in a way so that each pair can be treated as if it were in a |
||
malloc_chunk. (This way, the fd/bk offsets for linking bin heads |
||
and chunks are the same). |
||
|
||
Bins for sizes < 512 bytes contain chunks of all the same size, spaced |
||
8 bytes apart. Larger bins are approximately logarithmically |
||
spaced. (See the table below.) The `av_' array is never mentioned |
||
directly in the code, but instead via bin access macros. |
||
|
||
Bin layout: |
||
|
||
64 bins of size 8 |
||
32 bins of size 64 |
||
16 bins of size 512 |
||
8 bins of size 4096 |
||
4 bins of size 32768 |
||
2 bins of size 262144 |
||
1 bin of size what's left |
||
|
||
There is actually a little bit of slop in the numbers in bin_index |
||
for the sake of speed. This makes no difference elsewhere. |
||
|
||
The special chunks `top' and `last_remainder' get their own bins, |
||
(this is implemented via yet more trickery with the av_ array), |
||
although `top' is never properly linked to its bin since it is |
||
always handled specially. |
||
|
||
*/ |
||
|
||
#define NAV 128 /* number of bins */ |
||
|
||
typedef struct malloc_chunk* mbinptr; |
||
|
||
/* access macros */ |
||
|
||
#define bin_at(i) ((mbinptr)((char*)&(av_[2*(i) + 2]) - 2*SIZE_SZ)) |
||
#define next_bin(b) ((mbinptr)((char*)(b) + 2 * sizeof(mbinptr))) |
||
#define prev_bin(b) ((mbinptr)((char*)(b) - 2 * sizeof(mbinptr))) |
||
|
||
/* |
||
The first 2 bins are never indexed. The corresponding av_ cells are instead |
||
used for bookkeeping. This is not to save space, but to simplify |
||
indexing, maintain locality, and avoid some initialization tests. |
||
*/ |
||
|
||
#define top (bin_at(0)->fd) /* The topmost chunk */ |
||
#define last_remainder (bin_at(1)) /* remainder from last split */ |
||
|
||
|
||
/* |
||
Because top initially points to its own bin with initial |
||
zero size, thus forcing extension on the first malloc request, |
||
we avoid having any special code in malloc to check whether |
||
it even exists yet. But we still need to in malloc_extend_top. |
||
*/ |
||
|
||
#define initial_top ((mchunkptr)(bin_at(0))) |
||
|
||
/* Helper macro to initialize bins */ |
||
|
||
#define IAV(i) bin_at(i), bin_at(i) |
||
|
||
static mbinptr av_[NAV * 2 + 2] = { |
||
0, 0, |
||
IAV(0), IAV(1), IAV(2), IAV(3), IAV(4), IAV(5), IAV(6), IAV(7), |
||
IAV(8), IAV(9), IAV(10), IAV(11), IAV(12), IAV(13), IAV(14), IAV(15), |
||
IAV(16), IAV(17), IAV(18), IAV(19), IAV(20), IAV(21), IAV(22), IAV(23), |
||
IAV(24), IAV(25), IAV(26), IAV(27), IAV(28), IAV(29), IAV(30), IAV(31), |
||
IAV(32), IAV(33), IAV(34), IAV(35), IAV(36), IAV(37), IAV(38), IAV(39), |
||
IAV(40), IAV(41), IAV(42), IAV(43), IAV(44), IAV(45), IAV(46), IAV(47), |
||
IAV(48), IAV(49), IAV(50), IAV(51), IAV(52), IAV(53), IAV(54), IAV(55), |
||
IAV(56), IAV(57), IAV(58), IAV(59), IAV(60), IAV(61), IAV(62), IAV(63), |
||
IAV(64), IAV(65), IAV(66), IAV(67), IAV(68), IAV(69), IAV(70), IAV(71), |
||
IAV(72), IAV(73), IAV(74), IAV(75), IAV(76), IAV(77), IAV(78), IAV(79), |
||
IAV(80), IAV(81), IAV(82), IAV(83), IAV(84), IAV(85), IAV(86), IAV(87), |
||
IAV(88), IAV(89), IAV(90), IAV(91), IAV(92), IAV(93), IAV(94), IAV(95), |
||
IAV(96), IAV(97), IAV(98), IAV(99), IAV(100), IAV(101), IAV(102), IAV(103), |
||
IAV(104), IAV(105), IAV(106), IAV(107), IAV(108), IAV(109), IAV(110), IAV(111), |
||
IAV(112), IAV(113), IAV(114), IAV(115), IAV(116), IAV(117), IAV(118), IAV(119), |
||
IAV(120), IAV(121), IAV(122), IAV(123), IAV(124), IAV(125), IAV(126), IAV(127) |
||
}; |
||
|
||
|
||
|
||
/* field-extraction macros */ |
||
|
||
#define first(b) ((b)->fd) |
||
#define last(b) ((b)->bk) |
||
|
||
/* |
||
Indexing into bins |
||
*/ |
||
|
||
#define bin_index(sz) \ |
||
(((((unsigned long)(sz)) >> 9) == 0) ? (((unsigned long)(sz)) >> 3): \ |
||
((((unsigned long)(sz)) >> 9) <= 4) ? 56 + (((unsigned long)(sz)) >> 6): \ |
||
((((unsigned long)(sz)) >> 9) <= 20) ? 91 + (((unsigned long)(sz)) >> 9): \ |
||
((((unsigned long)(sz)) >> 9) <= 84) ? 110 + (((unsigned long)(sz)) >> 12): \ |
||
((((unsigned long)(sz)) >> 9) <= 340) ? 119 + (((unsigned long)(sz)) >> 15): \ |
||
((((unsigned long)(sz)) >> 9) <= 1364) ? 124 + (((unsigned long)(sz)) >> 18): \ |
||
126) |
||
/* |
||
bins for chunks < 512 are all spaced 8 bytes apart, and hold |
||
identically sized chunks. This is exploited in malloc. |
||
*/ |
||
|
||
#define MAX_SMALLBIN 63 |
||
#define MAX_SMALLBIN_SIZE 512 |
||
#define SMALLBIN_WIDTH 8 |
||
|
||
#define smallbin_index(sz) (((unsigned long)(sz)) >> 3) |
||
|
||
/* |
||
Requests are `small' if both the corresponding and the next bin are small |
||
*/ |
||
|
||
#define is_small_request(nb) (nb < MAX_SMALLBIN_SIZE - SMALLBIN_WIDTH) |
||
|
||
|
||
|
||
/* |
||
To help compensate for the large number of bins, a one-level index |
||
structure is used for bin-by-bin searching. `binblocks' is a |
||
one-word bitvector recording whether groups of BINBLOCKWIDTH bins |
||
have any (possibly) non-empty bins, so they can be skipped over |
||
all at once during during traversals. The bits are NOT always |
||
cleared as soon as all bins in a block are empty, but instead only |
||
when all are noticed to be empty during traversal in malloc. |
||
*/ |
||
|
||
#define BINBLOCKWIDTH 4 /* bins per block */ |
||
|
||
#define binblocks (bin_at(0)->size) /* bitvector of nonempty blocks */ |
||
|
||
/* bin<->block macros */ |
||
|
||
#define idx2binblock(ix) ((unsigned)1 << (ix / BINBLOCKWIDTH)) |
||
#define mark_binblock(ii) (binblocks |= idx2binblock(ii)) |
||
#define clear_binblock(ii) (binblocks &= ~(idx2binblock(ii))) |
||
|
||
|
||
|
||
|
||
|
||
/* Other static bookkeeping data */ |
||
|
||
/* variables holding tunable values */ |
||
|
||
static unsigned long trim_threshold = DEFAULT_TRIM_THRESHOLD; |
||
static unsigned long top_pad = DEFAULT_TOP_PAD; |
||
static unsigned int n_mmaps_max = DEFAULT_MMAP_MAX; |
||
static unsigned long mmap_threshold = DEFAULT_MMAP_THRESHOLD; |
||
|
||
/* The first value returned from sbrk */ |
||
static char* sbrk_base = (char*)(-1); |
||
|
||
/* The maximum memory obtained from system via sbrk */ |
||
static unsigned long max_sbrked_mem = 0; |
||
|
||
/* The maximum via either sbrk or mmap */ |
||
static unsigned long max_total_mem = 0; |
||
|
||
/* internal working copy of mallinfo */ |
||
static struct mallinfo current_mallinfo = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
||
|
||
/* The total memory obtained from system via sbrk */ |
||
#define sbrked_mem (current_mallinfo.arena) |
||
|
||
/* Tracking mmaps */ |
||
|
||
static unsigned int n_mmaps = 0; |
||
static unsigned int max_n_mmaps = 0; |
||
static unsigned long mmapped_mem = 0; |
||
static unsigned long max_mmapped_mem = 0; |
||
|
||
|
||
|
||
/* |
||
Debugging support |
||
*/ |
||
|
||
#if DEBUG |
||
|
||
|
||
/* |
||
These routines make a number of assertions about the states |
||
of data structures that should be true at all times. If any |
||
are not true, it's very likely that a user program has somehow |
||
trashed memory. (It's also possible that there is a coding error |
||
in malloc. In which case, please report it!) |
||
*/ |
||
|
||
#if __STD_C |
||
static void do_check_chunk(mchunkptr p) |
||
#else |
||
static void do_check_chunk(p) mchunkptr p; |
||
#endif |
||
{ |
||
INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE; |
||
|
||
/* No checkable chunk is mmapped */ |
||
assert(!chunk_is_mmapped(p)); |
||
|
||
/* Check for legal address ... */ |
||
assert((char*)p >= sbrk_base); |
||
if (p != top) |
||
assert((char*)p + sz <= (char*)top); |
||
else |
||
assert((char*)p + sz <= sbrk_base + sbrked_mem); |
||
|
||
} |
||
|
||
|
||
#if __STD_C |
||
static void do_check_free_chunk(mchunkptr p) |
||
#else |
||
static void do_check_free_chunk(p) mchunkptr p; |
||
#endif |
||
{ |
||
INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE; |
||
mchunkptr next = chunk_at_offset(p, sz); |
||
|
||
do_check_chunk(p); |
||
|
||
/* Check whether it claims to be free ... */ |
||
assert(!inuse(p)); |
||
|
||
/* Unless a special marker, must have OK fields */ |
||
if ((long)sz >= (long)MINSIZE) |
||
{ |
||
assert((sz & MALLOC_ALIGN_MASK) == 0); |
||
assert(aligned_OK(chunk2mem(p))); |
||
/* ... matching footer field */ |
||
assert(next->prev_size == sz); |
||
/* ... and is fully consolidated */ |
||
assert(prev_inuse(p)); |
||
assert (next == top || inuse(next)); |
||
|
||
/* ... and has minimally sane links */ |
||
assert(p->fd->bk == p); |
||
assert(p->bk->fd == p); |
||
} |
||
else /* markers are always of size SIZE_SZ */ |
||
assert(sz == SIZE_SZ); |
||
} |
||
|
||
#if __STD_C |
||
static void do_check_inuse_chunk(mchunkptr p) |
||
#else |
||
static void do_check_inuse_chunk(p) mchunkptr p; |
||
#endif |
||
{ |
||
mchunkptr next = next_chunk(p); |
||
do_check_chunk(p); |
||
|
||
/* Check whether it claims to be in use ... */ |
||
assert(inuse(p)); |
||
|
||
/* ... and is surrounded by OK chunks. |
||
Since more things can be checked with free chunks than inuse ones, |
||
if an inuse chunk borders them and debug is on, it's worth doing them. |
||
*/ |
||
if (!prev_inuse(p)) |
||
{ |
||
mchunkptr prv = prev_chunk(p); |
||
assert(next_chunk(prv) == p); |
||
do_check_free_chunk(prv); |
||
} |
||
if (next == top) |
||
{ |
||
assert(prev_inuse(next)); |
||
assert(chunksize(next) >= MINSIZE); |
||
} |
||
else if (!inuse(next)) |
||
do_check_free_chunk(next); |
||
|
||
} |
||
|
||
#if __STD_C |
||
static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s) |
||
#else |
||
static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s; |
||
#endif |
||
{ |
||
INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE; |
||
long room = sz - s; |
||
|
||
do_check_inuse_chunk(p); |
||
|
||
/* Legal size ... */ |
||
assert((long)sz >= (long)MINSIZE); |
||
assert((sz & MALLOC_ALIGN_MASK) == 0); |
||
assert(room >= 0); |
||
assert(room < (long)MINSIZE); |
||
|
||
/* ... and alignment */ |
||
assert(aligned_OK(chunk2mem(p))); |
||
|
||
|
||
/* ... and was allocated at front of an available chunk */ |
||
assert(prev_inuse(p)); |
||
|
||
} |
||
|
||
|
||
#define check_free_chunk(P) do_check_free_chunk(P) |
||
#define check_inuse_chunk(P) do_check_inuse_chunk(P) |
||
#define check_chunk(P) do_check_chunk(P) |
||
#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N) |
||
#else |
||
#define check_free_chunk(P) |
||
#define check_inuse_chunk(P) |
||
#define check_chunk(P) |
||
#define check_malloced_chunk(P,N) |
||
#endif |
||
|
||
|
||
|
||
/* |
||
Macro-based internal utilities |
||
*/ |
||
|
||
|
||
/* |
||
Linking chunks in bin lists. |
||
Call these only with variables, not arbitrary expressions, as arguments. |
||
*/ |
||
|
||
/* |
||
Place chunk p of size s in its bin, in size order, |
||
putting it ahead of others of same size. |
||
*/ |
||
|
||
|
||
#define frontlink(P, S, IDX, BK, FD) \ |
||
{ \ |
||
if (S < MAX_SMALLBIN_SIZE) \ |
||
{ \ |
||
IDX = smallbin_index(S); \ |
||
mark_binblock(IDX); \ |
||
BK = bin_at(IDX); \ |
||
FD = BK->fd; \ |
||
P->bk = BK; \ |
||
P->fd = FD; \ |
||
FD->bk = BK->fd = P; \ |
||
} \ |
||
else \ |
||
{ \ |
||
IDX = bin_index(S); \ |
||
BK = bin_at(IDX); \ |
||
FD = BK->fd; \ |
||
if (FD == BK) mark_binblock(IDX); \ |
||
else \ |
||
{ \ |
||
while (FD != BK && S < chunksize(FD)) FD = FD->fd; \ |
||
BK = FD->bk; \ |
||
} \ |
||
P->bk = BK; \ |
||
P->fd = FD; \ |
||
FD->bk = BK->fd = P; \ |
||
} \ |
||
} |
||
|
||
|
||
/* take a chunk off a list */ |
||
|
||
#define unlink(P, BK, FD) \ |
||
{ \ |
||
BK = P->bk; \ |
||
FD = P->fd; \ |
||
FD->bk = BK; \ |
||
BK->fd = FD; \ |
||
} \ |
||
|
||
/* Place p as the last remainder */ |
||
|
||
#define link_last_remainder(P) \ |
||
{ \ |
||
last_remainder->fd = last_remainder->bk = P; \ |
||
P->fd = P->bk = last_remainder; \ |
||
} |
||
|
||
/* Clear the last_remainder bin */ |
||
|
||
#define clear_last_remainder \ |
||
(last_remainder->fd = last_remainder->bk = last_remainder) |
||
|
||
|
||
|
||
|
||
|
||
/* Routines dealing with mmap(). */ |
||
|
||
#if HAVE_MMAP |
||
|
||
#if __STD_C |
||
static mchunkptr mmap_chunk(size_t size) |
||
#else |
||
static mchunkptr mmap_chunk(size) size_t size; |
||
#endif |
||
{ |
||
size_t page_mask = malloc_getpagesize - 1; |
||
mchunkptr p; |
||
|
||
#ifndef MAP_ANONYMOUS |
||
static int fd = -1; |
||
#endif |
||
|
||
if(n_mmaps >= n_mmaps_max) return 0; /* too many regions */ |
||
|
||
/* For mmapped chunks, the overhead is one SIZE_SZ unit larger, because |
||
* there is no following chunk whose prev_size field could be used. |
||
*/ |
||
size = (size + SIZE_SZ + page_mask) & ~page_mask; |
||
|
||
#ifdef MAP_ANONYMOUS |
||
p = (mchunkptr)mmap(0, size, PROT_READ|PROT_WRITE, |
||
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); |
||
#else /* !MAP_ANONYMOUS */ |
||
if (fd < 0) |
||
{ |
||
fd = open("/dev/zero", O_RDWR); |
||
if(fd < 0) return 0; |
||
} |
||
p = (mchunkptr)mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); |
||
#endif |
||
|
||
if(p == (mchunkptr)-1) return 0; |
||
|
||
n_mmaps++; |
||
if (n_mmaps > max_n_mmaps) max_n_mmaps = n_mmaps; |
||
|
||
/* We demand that eight bytes into a page must be 8-byte aligned. */ |
||
assert(aligned_OK(chunk2mem(p))); |
||
|
||
/* The offset to the start of the mmapped region is stored |
||
* in the prev_size field of the chunk; normally it is zero, |
||
* but that can be changed in memalign(). |
||
*/ |
||
p->prev_size = 0; |
||
set_head(p, size|IS_MMAPPED); |
||
|
||
mmapped_mem += size; |
||
if ((unsigned long)mmapped_mem > (unsigned long)max_mmapped_mem) |
||
max_mmapped_mem = mmapped_mem; |
||
if ((unsigned long)(mmapped_mem + sbrked_mem) > (unsigned long)max_total_mem) |
||
max_total_mem = mmapped_mem + sbrked_mem; |
||
return p; |
||
} |
||
|
||
#if __STD_C |
||
static void munmap_chunk(mchunkptr p) |
||
#else |
||
static void munmap_chunk(p) mchunkptr p; |
||
#endif |
||
{ |
||
INTERNAL_SIZE_T size = chunksize(p); |
||
int ret; |
||
|
||
assert (chunk_is_mmapped(p)); |
||
assert(! ((char*)p >= sbrk_base && (char*)p < sbrk_base + sbrked_mem)); |
||
assert((n_mmaps > 0)); |
||
assert(((p->prev_size + size) & (malloc_getpagesize-1)) == 0); |
||
|
||
n_mmaps--; |
||
mmapped_mem -= (size + p->prev_size); |
||
|
||
ret = munmap((char *)p - p->prev_size, size + p->prev_size); |
||
|
||
/* munmap returns non-zero on failure */ |
||
assert(ret == 0); |
||
} |
||
|
||
#if HAVE_MREMAP |
||
|
||
#if __STD_C |
||
static mchunkptr mremap_chunk(mchunkptr p, size_t new_size) |
||
#else |
||
static mchunkptr mremap_chunk(p, new_size) mchunkptr p; size_t new_size; |
||
#endif |
||
{ |
||
size_t page_mask = malloc_getpagesize - 1; |
||
INTERNAL_SIZE_T offset = p->prev_size; |
||
INTERNAL_SIZE_T size = chunksize(p); |
||
char *cp; |
||
|
||
assert (chunk_is_mmapped(p)); |
||
assert(! ((char*)p >= sbrk_base && (char*)p < sbrk_base + sbrked_mem)); |
||
assert((n_mmaps > 0)); |
||
assert(((size + offset) & (malloc_getpagesize-1)) == 0); |
||
|
||
/* Note the extra SIZE_SZ overhead as in mmap_chunk(). */ |
||
new_size = (new_size + offset + SIZE_SZ + page_mask) & ~page_mask; |
||
|
||
cp = (char *)mremap((char *)p - offset, size + offset, new_size, 1); |
||
|
||
if (cp == (char *)-1) return 0; |
||
|
||
p = (mchunkptr)(cp + offset); |
||
|
||
assert(aligned_OK(chunk2mem(p))); |
||
|
||
assert((p->prev_size == offset)); |
||
set_head(p, (new_size - offset)|IS_MMAPPED); |
||
|
||
mmapped_mem -= size + offset; |
||
mmapped_mem += new_size; |
||
if ((unsigned long)mmapped_mem > (unsigned long)max_mmapped_mem) |
||
max_mmapped_mem = mmapped_mem; |
||
if ((unsigned long)(mmapped_mem + sbrked_mem) > (unsigned long)max_total_mem) |
||
max_total_mem = mmapped_mem + sbrked_mem; |
||
return p; |
||
} |
||
|
||
#endif /* HAVE_MREMAP */ |
||
|
||
#endif /* HAVE_MMAP */ |
||
|
||
|
||
|
||
|
||
/* |
||
Extend the top-most chunk by obtaining memory from system. |
||
Main interface to sbrk (but see also malloc_trim). |
||
*/ |
||
|
||
#if __STD_C |
||
static void malloc_extend_top(INTERNAL_SIZE_T nb) |
||
#else |
||
static void malloc_extend_top(nb) INTERNAL_SIZE_T nb; |
||
#endif |
||
{ |
||
char* brk; /* return value from sbrk */ |
||
INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of sbrked space */ |
||
INTERNAL_SIZE_T correction; /* bytes for 2nd sbrk call */ |
||
char* new_brk; /* return of 2nd sbrk call */ |
||
INTERNAL_SIZE_T top_size; /* new size of top chunk */ |
||
|
||
mchunkptr old_top = top; /* Record state of old top */ |
||
INTERNAL_SIZE_T old_top_size = chunksize(old_top); |
||
char* old_end = (char*)(chunk_at_offset(old_top, old_top_size)); |
||
|
||
/* Pad request with top_pad plus minimal overhead */ |
||
|
||
INTERNAL_SIZE_T sbrk_size = nb + top_pad + MINSIZE; |
||
unsigned long pagesz = malloc_getpagesize; |
||
|
||
/* If not the first time through, round to preserve page boundary */ |
||
/* Otherwise, we need to correct to a page size below anyway. */ |
||
/* (We also correct below if an intervening foreign sbrk call.) */ |
||
|
||
if (sbrk_base != (char*)(-1)) |
||
sbrk_size = (sbrk_size + (pagesz - 1)) & ~(pagesz - 1); |
||
|
||
brk = (char*)(MORECORE (sbrk_size)); |
||
|
||
/* Fail if sbrk failed or if a foreign sbrk call killed our space */ |
||
if (brk == (char*)(MORECORE_FAILURE) || |
||
(brk < old_end && old_top != initial_top)) |
||
return; |
||
|
||
sbrked_mem += sbrk_size; |
||
|
||
if (brk == old_end) /* can just add bytes to current top */ |
||
{ |
||
top_size = sbrk_size + old_top_size; |
||
set_head(top, top_size | PREV_INUSE); |
||
} |
||
else |
||
{ |
||
if (sbrk_base == (char*)(-1)) /* First time through. Record base */ |
||
sbrk_base = brk; |
||
else /* Someone else called sbrk(). Count those bytes as sbrked_mem. */ |
||
sbrked_mem += brk - (char*)old_end; |
||
|
||
/* Guarantee alignment of first new chunk made from this space */ |
||
front_misalign = (unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK; |
||
if (front_misalign > 0) |
||
{ |
||
correction = (MALLOC_ALIGNMENT) - front_misalign; |
||
brk += correction; |
||
} |
||
else |
||
correction = 0; |
||
|
||
/* Guarantee the next brk will be at a page boundary */ |
||
|
||
correction += ((((unsigned long)(brk + sbrk_size))+(pagesz-1)) & |
||
~(pagesz - 1)) - ((unsigned long)(brk + sbrk_size)); |
||
|
||
/* Allocate correction */ |
||
new_brk = (char*)(MORECORE (correction)); |
||
if (new_brk == (char*)(MORECORE_FAILURE)) return; |
||
|
||
sbrked_mem += correction; |
||
|
||
top = (mchunkptr)brk; |
||
top_size = new_brk - brk + correction; |
||
set_head(top, top_size | PREV_INUSE); |
||
|
||
if (old_top != initial_top) |
||
{ |
||
|
||
/* There must have been an intervening foreign sbrk call. */ |
||
/* A double fencepost is necessary to prevent consolidation */ |
||
|
||
/* If not enough space to do this, then user did something very wrong */ |
||
if (old_top_size < MINSIZE) |
||
{ |
||
set_head(top, PREV_INUSE); /* will force null return from malloc */ |
||
return; |
||
} |
||
|
||
/* Also keep size a multiple of MALLOC_ALIGNMENT */ |
||
old_top_size = (old_top_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK; |
||
set_head_size(old_top, old_top_size); |
||
chunk_at_offset(old_top, old_top_size )->size = |
||
SIZE_SZ|PREV_INUSE; |
||
chunk_at_offset(old_top, old_top_size + SIZE_SZ)->size = |
||
SIZE_SZ|PREV_INUSE; |
||
/* If possible, release the rest. */ |
||
if (old_top_size >= MINSIZE) |
||
fREe(chunk2mem(old_top)); |
||
} |
||
} |
||
|
||
if ((unsigned long)sbrked_mem > (unsigned long)max_sbrked_mem) |
||
max_sbrked_mem = sbrked_mem; |
||
if ((unsigned long)(mmapped_mem + sbrked_mem) > (unsigned long)max_total_mem) |
||
max_total_mem = mmapped_mem + sbrked_mem; |
||
|
||
/* We always land on a page boundary */ |
||
assert(((unsigned long)((char*)top + top_size) & (pagesz - 1)) == 0); |
||
} |
||
|
||
|
||
|
||
|
||
/* Main public routines */ |
||
|
||
|
||
/* |
||
Malloc Algorthim: |
||
|
||
The requested size is first converted into a usable form, `nb'. |
||
This currently means to add 4 bytes overhead plus possibly more to |
||
obtain 8-byte alignment and/or to obtain a size of at least |
||
MINSIZE (currently 16 bytes), the smallest allocatable size. |
||
(All fits are considered `exact' if they are within MINSIZE bytes.) |
||
|
||
From there, the first successful of the following steps is taken: |
||
|
||
1. The bin corresponding to the request size is scanned, and if |
||
a chunk of exactly the right size is found, it is taken. |
||
|
||
2. The most recently remaindered chunk is used if it is big |
||
enough. This is a form of (roving) first fit, used only in |
||
the absence of exact fits. Runs of consecutive requests use |
||
the remainder of the chunk used for the previous such request |
||
whenever possible. This limited use of a first-fit style |
||
allocation strategy tends to give contiguous chunks |
||
coextensive lifetimes, which improves locality and can reduce |
||
fragmentation in the long run. |
||
|
||
3. Other bins are scanned in increasing size order, using a |
||
chunk big enough to fulfill the request, and splitting off |
||
any remainder. This search is strictly by best-fit; i.e., |
||
the smallest (with ties going to approximately the least |
||
recently used) chunk that fits is selected. |
||
|
||
4. If large enough, the chunk bordering the end of memory |
||
(`top') is split off. (This use of `top' is in accord with |
||
the best-fit search rule. In effect, `top' is treated as |
||
larger (and thus less well fitting) than any other available |
||
chunk since it can be extended to be as large as necessary |
||
(up to system limitations). |
||
|
||
5. If the request size meets the mmap threshold and the |
||
system supports mmap, and there are few enough currently |
||
allocated mmapped regions, and a call to mmap succeeds, |
||
the request is allocated via direct memory mapping. |
||
|
||
6. Otherwise, the top of memory is extended by |
||
obtaining more space from the system (normally using sbrk, |
||
but definable to anything else via the MORECORE macro). |
||
Memory is gathered from the system (in system page-sized |
||
units) in a way that allows chunks obtained across different |
||
sbrk calls to be consolidated, but does not require |
||
contiguous memory. Thus, it should be safe to intersperse |
||
mallocs with other sbrk calls. |
||
|
||
|
||
All allocations are made from the the `lowest' part of any found |
||
chunk. (The implementation invariant is that prev_inuse is |
||
always true of any allocated chunk; i.e., that each allocated |
||
chunk borders either a previously allocated and still in-use chunk, |
||
or the base of its memory arena.) |
||
|
||
*/ |
||
|
||
#if __STD_C |
||
Void_t* mALLOc(size_t bytes) |
||
#else |
||
Void_t* mALLOc(bytes) size_t bytes; |
||
#endif |
||
{ |
||
mchunkptr victim; /* inspected/selected chunk */ |
||
INTERNAL_SIZE_T victim_size; /* its size */ |
||
int idx; /* index for bin traversal */ |
||
mbinptr bin; /* associated bin */ |
||
mchunkptr remainder; /* remainder from a split */ |
||
long remainder_size; /* its size */ |
||
int remainder_index; /* its bin index */ |
||
unsigned long block; /* block traverser bit */ |
||
int startidx; /* first bin of a traversed block */ |
||
mchunkptr fwd; /* misc temp for linking */ |
||
mchunkptr bck; /* misc temp for linking */ |
||
mbinptr q; /* misc temp */ |
||
|
||
INTERNAL_SIZE_T nb; |
||
|
||
if ((long)bytes < 0) return 0; |
||
|
||
nb = request2size(bytes); /* padded request size; */ |
||
|
||
/* Check for exact match in a bin */ |
||
|
||
if (is_small_request(nb)) /* Faster version for small requests */ |
||
{ |
||
idx = smallbin_index(nb); |
||
|
||
/* No traversal or size check necessary for small bins. */ |
||
|
||
q = bin_at(idx); |
||
victim = last(q); |
||
|
||
/* Also scan the next one, since it would have a remainder < MINSIZE */ |
||
if (victim == q) |
||
{ |
||
q = next_bin(q); |
||
victim = last(q); |
||
} |
||
if (victim != q) |
||
{ |
||
victim_size = chunksize(victim); |
||
unlink(victim, bck, fwd); |
||
set_inuse_bit_at_offset(victim, victim_size); |
||
check_malloced_chunk(victim, nb); |
||
return chunk2mem(victim); |
||
} |
||
|
||
idx += 2; /* Set for bin scan below. We've already scanned 2 bins. */ |
||
|
||
} |
||
else |
||
{ |
||
idx = bin_index(nb); |
||
bin = bin_at(idx); |
||
|
||
for (victim = last(bin); victim != bin; victim = victim->bk) |
||
{ |
||
victim_size = chunksize(victim); |
||
remainder_size = victim_size - nb; |
||
|
||
if (remainder_size >= (long)MINSIZE) /* too big */ |
||
{ |
||
--idx; /* adjust to rescan below after checking last remainder */ |
||
break; |
||
} |
||
|
||
else if (remainder_size >= 0) /* exact fit */ |
||
{ |
||
unlink(victim, bck, fwd); |
||
set_inuse_bit_at_offset(victim, victim_size); |
||
check_malloced_chunk(victim, nb); |
||
return chunk2mem(victim); |
||
} |
||
} |
||
|
||
++idx; |
||
|
||
} |
||
|
||
/* Try to use the last split-off remainder */ |
||
|
||
if ( (victim = last_remainder->fd) != last_remainder) |
||
{ |
||
victim_size = chunksize(victim); |
||
remainder_size = victim_size - nb; |
||
|
||
if (remainder_size >= (long)MINSIZE) /* re-split */ |
||
{ |
||
remainder = chunk_at_offset(victim, nb); |
||
set_head(victim, nb | PREV_INUSE); |
||
link_last_remainder(remainder); |
||
set_head(remainder, remainder_size | PREV_INUSE); |
||
set_foot(remainder, remainder_size); |
||
check_malloced_chunk(victim, nb); |
||
return chunk2mem(victim); |
||
} |
||
|
||
clear_last_remainder; |
||
|
||
if (remainder_size >= 0) /* exhaust */ |
||
{ |
||
set_inuse_bit_at_offset(victim, victim_size); |
||
check_malloced_chunk(victim, nb); |
||
return chunk2mem(victim); |
||
} |
||
|
||
/* Else place in bin */ |
||
|
||
frontlink(victim, victim_size, remainder_index, bck, fwd); |
||
} |
||
|
||
/* |
||
If there are any possibly nonempty big-enough blocks, |
||
search for best fitting chunk by scanning bins in blockwidth units. |
||
*/ |
||
|
||
if ( (block = idx2binblock(idx)) <= binblocks) |
||
{ |
||
|
||
/* Get to the first marked block */ |
||
|
||
if ( (block & binblocks) == 0) |
||
{ |
||
/* force to an even block boundary */ |
||
idx = (idx & ~(BINBLOCKWIDTH - 1)) + BINBLOCKWIDTH; |
||
block <<= 1; |
||
while ((block & binblocks) == 0) |
||
{ |
||
idx += BINBLOCKWIDTH; |
||
block <<= 1; |
||
} |
||
} |
||
|
||
/* For each possibly nonempty block ... */ |
||
for (;;) |
||
{ |
||
startidx = idx; /* (track incomplete blocks) */ |
||
q = bin = bin_at(idx); |
||
|
||
/* For each bin in this block ... */ |
||
do |
||
{ |
||
/* Find and use first big enough chunk ... */ |
||
|
||
for (victim = last(bin); victim != bin; victim = victim->bk) |
||
{ |
||
victim_size = chunksize(victim); |
||
remainder_size = victim_size - nb; |
||
|
||
if (remainder_size >= (long)MINSIZE) /* split */ |
||
{ |
||
remainder = chunk_at_offset(victim, nb); |
||
set_head(victim, nb | PREV_INUSE); |
||
unlink(victim, bck, fwd); |
||
link_last_remainder(remainder); |
||
set_head(remainder, remainder_size | PREV_INUSE); |
||
set_foot(remainder, remainder_size); |
||
check_malloced_chunk(victim, nb); |
||
return chunk2mem(victim); |
||
} |
||
|
||
else if (remainder_size >= 0) /* take */ |
||
{ |
||
set_inuse_bit_at_offset(victim, victim_size); |
||
unlink(victim, bck, fwd); |
||
check_malloced_chunk(victim, nb); |
||
return chunk2mem(victim); |
||
} |
||
|
||
} |
||
|
||
bin = next_bin(bin); |
||
|
||
} while ((++idx & (BINBLOCKWIDTH - 1)) != 0); |
||
|
||
/* Clear out the block bit. */ |
||
|
||
do /* Possibly backtrack to try to clear a partial block */ |
||
{ |
||
if ((startidx & (BINBLOCKWIDTH - 1)) == 0) |
||
{ |
||
binblocks &= ~block; |
||
break; |
||
} |
||
--startidx; |
||
q = prev_bin(q); |
||
} while (first(q) == q); |
||
|
||
/* Get to the next possibly nonempty block */ |
||
|
||
if ( (block <<= 1) <= binblocks && (block != 0) ) |
||
{ |
||
while ((block & binblocks) == 0) |
||
{ |
||
idx += BINBLOCKWIDTH; |
||
block <<= 1; |
||
} |
||
} |
||
else |
||
break; |
||
} |
||
} |
||
|
||
|
||
/* Try to use top chunk */ |
||
|
||
/* Require that there be a remainder, ensuring top always exists */ |
||
if ( (remainder_size = chunksize(top) - nb) < (long)MINSIZE) |
||
{ |
||
|
||
#if HAVE_MMAP |
||
/* If big and would otherwise need to extend, try to use mmap instead */ |
||
if ((unsigned long)nb >= (unsigned long)mmap_threshold && |
||
(victim = mmap_chunk(nb)) != 0) |
||
return chunk2mem(victim); |
||
#endif |
||
|
||
/* Try to extend */ |
||
malloc_extend_top(nb); |
||
if ( (remainder_size = chunksize(top) - nb) < (long)MINSIZE) |
||
return 0; /* propagate failure */ |
||
} |
||
|
||
victim = top; |
||
set_head(victim, nb | PREV_INUSE); |
||
top = chunk_at_offset(victim, nb); |
||
set_head(top, remainder_size | PREV_INUSE); |
||
check_malloced_chunk(victim, nb); |
||
return chunk2mem(victim); |
||
|
||
} |
||
|
||
|
||
|
||
|
||
/* |
||
|
||
free() algorithm : |
||
|
||
cases: |
||
|
||
1. free(0) has no effect. |
||
|
||
2. If the chunk was allocated via mmap, it is release via munmap(). |
||
|
||
3. If a returned chunk borders the current high end of memory, |
||
it is consolidated into the top, and if the total unused |
||
topmost memory exceeds the trim threshold, malloc_trim is |
||
called. |
||
|
||
4. Other chunks are consolidated as they arrive, and |
||
placed in corresponding bins. (This includes the case of |
||
consolidating with the current `last_remainder'). |
||
|
||
*/ |
||
|
||
|
||
#if __STD_C |
||
void fREe(Void_t* mem) |
||
#else |
||
void fREe(mem) Void_t* mem; |
||
#endif |
||
{ |
||
mchunkptr p; /* chunk corresponding to mem */ |
||
INTERNAL_SIZE_T hd; /* its head field */ |
||
INTERNAL_SIZE_T sz; /* its size */ |
||
int idx; /* its bin index */ |
||
mchunkptr next; /* next contiguous chunk */ |
||
INTERNAL_SIZE_T nextsz; /* its size */ |
||
INTERNAL_SIZE_T prevsz; /* size of previous contiguous chunk */ |
||
mchunkptr bck; /* misc temp for linking */ |
||
mchunkptr fwd; /* misc temp for linking */ |
||
int islr; /* track whether merging with last_remainder */ |
||
|
||
if (mem == 0) /* free(0) has no effect */ |
||
return; |
||
|
||
p = mem2chunk(mem); |
||
hd = p->size; |
||
|
||
#if HAVE_MMAP |
||
if (hd & IS_MMAPPED) /* release mmapped memory. */ |
||
{ |
||
munmap_chunk(p); |
||
return; |
||
} |
||
#endif |
||
|
||
check_inuse_chunk(p); |
||
|
||
sz = hd & ~PREV_INUSE; |
||
next = chunk_at_offset(p, sz); |
||
nextsz = chunksize(next); |
||
|
||
if (next == top) /* merge with top */ |
||
{ |
||
sz += nextsz; |
||
|
||
if (!(hd & PREV_INUSE)) /* consolidate backward */ |
||
{ |
||
prevsz = p->prev_size; |
||
p = chunk_at_offset(p, -((long) prevsz)); |
||
sz += prevsz; |
||
unlink(p, bck, fwd); |
||
} |
||
|
||
set_head(p, sz | PREV_INUSE); |
||
top = p; |
||
if ((unsigned long)(sz) >= (unsigned long)trim_threshold) |
||
malloc_trim(top_pad); |
||
return; |
||
} |
||
|
||
set_head(next, nextsz); /* clear inuse bit */ |
||
|
||
islr = 0; |
||
|
||
if (!(hd & PREV_INUSE)) /* consolidate backward */ |
||
{ |
||
prevsz = p->prev_size; |
||
p = chunk_at_offset(p, -((long) prevsz)); |
||
sz += prevsz; |
||
|
||
if (p->fd == last_remainder) /* keep as last_remainder */ |
||
islr = 1; |
||
else |
||
unlink(p, bck, fwd); |
||
} |
||
|
||
if (!(inuse_bit_at_offset(next, nextsz))) /* consolidate forward */ |
||
{ |
||
sz += nextsz; |
||
|
||
if (!islr && next->fd == last_remainder) /* re-insert last_remainder */ |
||
{ |
||
islr = 1; |
||
link_last_remainder(p); |
||
} |
||
else |
||
unlink(next, bck, fwd); |
||
} |
||
|
||
|
||
set_head(p, sz | PREV_INUSE); |
||
set_foot(p, sz); |
||
if (!islr) |
||
frontlink(p, sz, idx, bck, fwd); |
||
} |
||
|
||
|
||
|
||
|
||
|
||
/* |
||
|
||
Realloc algorithm: |
||
|
||
Chunks that were obtained via mmap cannot be extended or shrunk |
||
unless HAVE_MREMAP is defined, in which case mremap is used. |
||
Otherwise, if their reallocation is for additional space, they are |
||
copied. If for less, they are just left alone. |
||
|
||
Otherwise, if the reallocation is for additional space, and the |
||
chunk can be extended, it is, else a malloc-copy-free sequence is |
||
taken. There are several different ways that a chunk could be |
||
extended. All are tried: |
||
|
||
* Extending forward into following adjacent free chunk. |
||
* Shifting backwards, joining preceding adjacent space |
||
* Both shifting backwards and extending forward. |
||
* Extending into newly sbrked space |
||
|
||
Unless the #define REALLOC_ZERO_BYTES_FREES is set, realloc with a |
||
size argument of zero (re)allocates a minimum-sized chunk. |
||
|
||
If the reallocation is for less space, and the new request is for |
||
a `small' (<512 bytes) size, then the newly unused space is lopped |
||
off and freed. |
||
|
||
The old unix realloc convention of allowing the last-free'd chunk |
||
to be used as an argument to realloc is no longer supported. |
||
I don't know of any programs still relying on this feature, |
||
and allowing it would also allow too many other incorrect |
||
usages of realloc to be sensible. |
||
|
||
|
||
*/ |
||
|
||
|
||
#if __STD_C |
||
Void_t* rEALLOc(Void_t* oldmem, size_t bytes) |
||
#else |
||
Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes; |
||
#endif |
||
{ |
||
INTERNAL_SIZE_T nb; /* padded request size */ |
||
|
||
mchunkptr oldp; /* chunk corresponding to oldmem */ |
||
INTERNAL_SIZE_T oldsize; /* its size */ |
||
|
||
mchunkptr newp; /* chunk to return */ |
||
INTERNAL_SIZE_T newsize; /* its size */ |
||
Void_t* newmem; /* corresponding user mem */ |
||
|
||
mchunkptr next; /* next contiguous chunk after oldp */ |
||
INTERNAL_SIZE_T nextsize; /* its size */ |
||
|
||
mchunkptr prev; /* previous contiguous chunk before oldp */ |
||
INTERNAL_SIZE_T prevsize; /* its size */ |
||
|
||
mchunkptr remainder; /* holds split off extra space from newp */ |
||
INTERNAL_SIZE_T remainder_size; /* its size */ |
||
|
||
mchunkptr bck; /* misc temp for linking */ |
||
mchunkptr fwd; /* misc temp for linking */ |
||
|
||
#ifdef REALLOC_ZERO_BYTES_FREES |
||
if (bytes == 0) { fREe(oldmem); return 0; } |
||
#endif |
||
|
||
if ((long)bytes < 0) return 0; |
||
|
||
/* realloc of null is supposed to be same as malloc */ |
||
if (oldmem == 0) return mALLOc(bytes); |
||
|
||
newp = oldp = mem2chunk(oldmem); |
||
newsize = oldsize = chunksize(oldp); |
||
|
||
|
||
nb = request2size(bytes); |
||
|
||
#if HAVE_MMAP |
||
if (chunk_is_mmapped(oldp)) |
||
{ |
||
#if HAVE_MREMAP |
||
newp = mremap_chunk(oldp, nb); |
||
if(newp) return chunk2mem(newp); |
||
#endif |
||
/* Note the extra SIZE_SZ overhead. */ |
||
if(oldsize - SIZE_SZ >= nb) return oldmem; /* do nothing */ |
||
/* Must alloc, copy, free. */ |
||
newmem = mALLOc(bytes); |
||
if (newmem == 0) return 0; /* propagate failure */ |
||
MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ); |
||
munmap_chunk(oldp); |
||
return newmem; |
||
} |
||
#endif |
||
|
||
check_inuse_chunk(oldp); |
||
|
||
if ((long)(oldsize) < (long)(nb)) |
||
{ |
||
|
||
/* Try expanding forward */ |
||
|
||
next = chunk_at_offset(oldp, oldsize); |
||
if (next == top || !inuse(next)) |
||
{ |
||
nextsize = chunksize(next); |
||
|
||
/* Forward into top only if a remainder */ |
||
if (next == top) |
||
{ |
||
if ((long)(nextsize + newsize) >= (long)(nb + MINSIZE)) |
||
{ |
||
newsize += nextsize; |
||
top = chunk_at_offset(oldp, nb); |
||
set_head(top, (newsize - nb) | PREV_INUSE); |
||
set_head_size(oldp, nb); |
||
return chunk2mem(oldp); |
||
} |
||
} |
||
|
||
/* Forward into next chunk */ |
||
else if (((long)(nextsize + newsize) >= (long)(nb))) |
||
{ |
||
unlink(next, bck, fwd); |
||
newsize += nextsize; |
||
goto split; |
||
} |
||
} |
||
else |
||
{ |
||
next = 0; |
||
nextsize = 0; |
||
} |
||
|
||
/* Try shifting backwards. */ |
||
|
||
if (!prev_inuse(oldp)) |
||
{ |
||
prev = prev_chunk(oldp); |
||
prevsize = chunksize(prev); |
||
|
||
/* try forward + backward first to save a later consolidation */ |
||
|
||
if (next != 0) |
||
{ |
||
/* into top */ |
||
if (next == top) |
||
{ |
||
if ((long)(nextsize + prevsize + newsize) >= (long)(nb + MINSIZE)) |
||
{ |
||
unlink(prev, bck, fwd); |
||
newp = prev; |
||
newsize += prevsize + nextsize; |
||
newmem = chunk2mem(newp); |
||
MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ); |
||
top = chunk_at_offset(newp, nb); |
||
set_head(top, (newsize - nb) | PREV_INUSE); |
||
set_head_size(newp, nb); |
||
return newmem; |
||
} |
||
} |
||
|
||
/* into next chunk */ |
||
else if (((long)(nextsize + prevsize + newsize) >= (long)(nb))) |
||
{ |
||
unlink(next, bck, fwd); |
||
unlink(prev, bck, fwd); |
||
newp = prev; |
||
newsize += nextsize + prevsize; |
||
newmem = chunk2mem(newp); |
||
MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ); |
||
goto split; |
||
} |
||
} |
||
|
||
/* backward only */ |
||
if (prev != 0 && (long)(prevsize + newsize) >= (long)nb) |
||
{ |
||
unlink(prev, bck, fwd); |
||
newp = prev; |
||
newsize += prevsize; |
||
newmem = chunk2mem(newp); |
||
MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ); |
||
goto split; |
||
} |
||
} |
||
|
||
/* Must allocate */ |
||
|
||
newmem = mALLOc (bytes); |
||
|
||
if (newmem == 0) /* propagate failure */ |
||
return 0; |
||
|
||
/* Avoid copy if newp is next chunk after oldp. */ |
||
/* (This can only happen when new chunk is sbrk'ed.) */ |
||
|
||
if ( (newp = mem2chunk(newmem)) == next_chunk(oldp)) |
||
{ |
||
newsize += chunksize(newp); |
||
newp = oldp; |
||
goto split; |
||
} |
||
|
||
/* Otherwise copy, free, and exit */ |
||
MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ); |
||
fREe(oldmem); |
||
return newmem; |
||
} |
||
|
||
|
||
split: /* split off extra room in old or expanded chunk */ |
||
|
||
if (newsize - nb >= MINSIZE) /* split off remainder */ |
||
{ |
||
remainder = chunk_at_offset(newp, nb); |
||
remainder_size = newsize - nb; |
||
set_head_size(newp, nb); |
||
set_head(remainder, remainder_size | PREV_INUSE); |
||
set_inuse_bit_at_offset(remainder, remainder_size); |
||
fREe(chunk2mem(remainder)); /* let free() deal with it */ |
||
} |
||
else |
||
{ |
||
set_head_size(newp, newsize); |
||
set_inuse_bit_at_offset(newp, newsize); |
||
} |
||
|
||
check_inuse_chunk(newp); |
||
return chunk2mem(newp); |
||
} |
||
|
||
|
||
|
||
|
||
/* |
||
|
||
memalign algorithm: |
||
|
||
memalign requests more than enough space from malloc, finds a spot |
||
within that chunk that meets the alignment request, and then |
||
possibly frees the leading and trailing space. |
||
|
||
The alignment argument must be a power of two. This property is not |
||
checked by memalign, so misuse may result in random runtime errors. |
||
|
||
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. |
||
|
||
*/ |
||
|
||
|
||
#if __STD_C |
||
Void_t* mEMALIGn(size_t alignment, size_t bytes) |
||
#else |
||
Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes; |
||
#endif |
||
{ |
||
INTERNAL_SIZE_T nb; /* padded request size */ |
||
char* m; /* memory returned by malloc call */ |
||
mchunkptr p; /* corresponding chunk */ |
||
char* brk; /* alignment point within p */ |
||
mchunkptr newp; /* chunk to return */ |
||
INTERNAL_SIZE_T newsize; /* its size */ |
||
INTERNAL_SIZE_T leadsize; /* leading space befor alignment point */ |
||
mchunkptr remainder; /* spare room at end to split off */ |
||
long remainder_size; /* its size */ |
||
|
||
if ((long)bytes < 0) return 0; |
||
|
||
/* If need less alignment than we give anyway, just relay to malloc */ |
||
|
||
if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes); |
||
|
||
/* Otherwise, ensure that it is at least a minimum chunk size */ |
||
|
||
if (alignment < MINSIZE) alignment = MINSIZE; |
||
|
||
/* Call malloc with worst case padding to hit alignment. */ |
||
|
||
nb = request2size(bytes); |
||
m = (char*)(mALLOc(nb + alignment + MINSIZE)); |
||
|
||
if (m == 0) return 0; /* propagate failure */ |
||
|
||
p = mem2chunk(m); |
||
|
||
if ((((unsigned long)(m)) % alignment) == 0) /* aligned */ |
||
{ |
||
#if HAVE_MMAP |
||
if(chunk_is_mmapped(p)) |
||
return chunk2mem(p); /* nothing more to do */ |
||
#endif |
||
} |
||
else /* misaligned */ |
||
{ |
||
/* |
||
Find an aligned spot inside chunk. |
||
Since we need to give back leading space in a chunk of at |
||
least MINSIZE, if the first calculation places us at |
||
a spot with less than MINSIZE leader, we can move to the |
||
next aligned spot -- we've allocated enough total room so that |
||
this is always possible. |
||
*/ |
||
|
||
brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) & -((signed) alignment)); |
||
if ((long)(brk - (char*)(p)) < MINSIZE) brk = brk + alignment; |
||
|
||
newp = (mchunkptr)brk; |
||
leadsize = brk - (char*)(p); |
||
newsize = chunksize(p) - leadsize; |
||
|
||
#if HAVE_MMAP |
||
if(chunk_is_mmapped(p)) |
||
{ |
||
newp->prev_size = p->prev_size + leadsize; |
||
set_head(newp, newsize|IS_MMAPPED); |
||
return chunk2mem(newp); |
||
} |
||
#endif |
||
|
||
/* give back leader, use the rest */ |
||
|
||
set_head(newp, newsize | PREV_INUSE); |
||
set_inuse_bit_at_offset(newp, newsize); |
||
set_head_size(p, leadsize); |
||
fREe(chunk2mem(p)); |
||
p = newp; |
||
|
||
assert (newsize >= nb && (((unsigned long)(chunk2mem(p))) % alignment) == 0); |
||
} |
||
|
||
/* Also give back spare room at the end */ |
||
|
||
remainder_size = chunksize(p) - nb; |
||
|
||
if (remainder_size >= (long)MINSIZE) |
||
{ |
||
remainder = chunk_at_offset(p, nb); |
||
set_head(remainder, remainder_size | PREV_INUSE); |
||
set_head_size(p, nb); |
||
fREe(chunk2mem(remainder)); |
||
} |
||
|
||
check_inuse_chunk(p); |
||
return chunk2mem(p); |
||
|
||
} |
||
|
||
|
||
|
||
|
||
/* |
||
valloc just invokes memalign with alignment argument equal |
||
to the page size of the system (or as near to this as can |
||
be figured out from all the includes/defines above.) |
||
*/ |
||
|
||
#if __STD_C |
||
Void_t* vALLOc(size_t bytes) |
||
#else |
||
Void_t* vALLOc(bytes) size_t bytes; |
||
#endif |
||
{ |
||
return mEMALIGn (malloc_getpagesize, bytes); |
||
} |
||
|
||
/* |
||
pvalloc just invokes valloc for the nearest pagesize |
||
that will accommodate request |
||
*/ |
||
|
||
|
||
#if __STD_C |
||
Void_t* pvALLOc(size_t bytes) |
||
#else |
||
Void_t* pvALLOc(bytes) size_t bytes; |
||
#endif |
||
{ |
||
size_t pagesize = malloc_getpagesize; |
||
return mEMALIGn (pagesize, (bytes + pagesize - 1) & ~(pagesize - 1)); |
||
} |
||
|
||
/* |
||
|
||
calloc calls malloc, then zeroes out the allocated chunk. |
||
|
||
*/ |
||
|
||
#if __STD_C |
||
Void_t* cALLOc(size_t n, size_t elem_size) |
||
#else |
||
Void_t* cALLOc(n, elem_size) size_t n; size_t elem_size; |
||
#endif |
||
{ |
||
mchunkptr p; |
||
INTERNAL_SIZE_T csz; |
||
|
||
INTERNAL_SIZE_T sz = n * elem_size; |
||
|
||
|
||
/* check if expand_top called, in which case don't need to clear */ |
||
#if MORECORE_CLEARS |
||
mchunkptr oldtop = top; |
||
INTERNAL_SIZE_T oldtopsize = chunksize(top); |
||
#endif |
||
Void_t* mem = mALLOc (sz); |
||
|
||
if ((long)n < 0) return 0; |
||
|
||
if (mem == 0) |
||
return 0; |
||
else |
||
{ |
||
p = mem2chunk(mem); |
||
|
||
/* Two optional cases in which clearing not necessary */ |
||
|
||
|
||
#if HAVE_MMAP |
||
if (chunk_is_mmapped(p)) return mem; |
||
#endif |
||
|
||
csz = chunksize(p); |
||
|
||
#if MORECORE_CLEARS |
||
if (p == oldtop && csz > oldtopsize) |
||
{ |
||
/* clear only the bytes from non-freshly-sbrked memory */ |
||
csz = oldtopsize; |
||
} |
||
#endif |
||
|
||
MALLOC_ZERO(mem, csz - SIZE_SZ); |
||
return mem; |
||
} |
||
} |
||
|
||
/* |
||
|
||
cfree just calls free. It is needed/defined on some systems |
||
that pair it with calloc, presumably for odd historical reasons. |
||
|
||
*/ |
||
|
||
#if !defined(INTERNAL_LINUX_C_LIB) || !defined(__ELF__) |
||
#if __STD_C |
||
void cfree(Void_t *mem) |
||
#else |
||
void cfree(mem) Void_t *mem; |
||
#endif |
||
{ |
||
fREe(mem); |
||
} |
||
#endif |
||
|
||
|
||
|
||
/* |
||
|
||
Malloc_trim gives memory back to the system (via negative |
||
arguments to sbrk) if there is unused memory at the `high' end of |
||
the malloc pool. 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 (one page or less). 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. |
||
|
||
*/ |
||
|
||
#if __STD_C |
||
int malloc_trim(size_t pad) |
||
#else |
||
int malloc_trim(pad) size_t pad; |
||
#endif |
||
{ |
||
long top_size; /* Amount of top-most memory */ |
||
long extra; /* Amount to release */ |
||
char* current_brk; /* address returned by pre-check sbrk call */ |
||
char* new_brk; /* address returned by negative sbrk call */ |
||
|
||
unsigned long pagesz = malloc_getpagesize; |
||
|
||
top_size = chunksize(top); |
||
extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz; |
||
|
||
if (extra < (long)pagesz) /* Not enough memory to release */ |
||
return 0; |
||
|
||
else |
||
{ |
||
/* Test to make sure no one else called sbrk */ |
||
current_brk = (char*)(MORECORE (0)); |
||
if (current_brk != (char*)(top) + top_size) |
||
return 0; /* Apparently we don't own memory; must fail */ |
||
|
||
else |
||
{ |
||
new_brk = (char*)(MORECORE (-extra)); |
||
|
||
if (new_brk == (char*)(MORECORE_FAILURE)) /* sbrk failed? */ |
||
{ |
||
/* Try to figure out what we have */ |
||
current_brk = (char*)(MORECORE (0)); |
||
top_size = current_brk - (char*)top; |
||
if (top_size >= (long)MINSIZE) /* if not, we are very very dead! */ |
||
{ |
||
sbrked_mem = current_brk - sbrk_base; |
||
set_head(top, top_size | PREV_INUSE); |
||
} |
||
check_chunk(top); |
||
return 0; |
||
} |
||
|
||
else |
||
{ |
||
/* Success. Adjust top accordingly. */ |
||
set_head(top, (top_size - extra) | PREV_INUSE); |
||
sbrked_mem -= extra; |
||
check_chunk(top); |
||
return 1; |
||
} |
||
} |
||
} |
||
} |
||
|
||
|
||
|
||
/* |
||
malloc_usable_size: |
||
|
||
This routine tells you how many bytes you can actually use in an |
||
allocated chunk, which may be more than you requested (although |
||
often not). You can use this many bytes without worrying about |
||
overwriting other allocated objects. Not a particularly great |
||
programming practice, but still sometimes useful. |
||
|
||
*/ |
||
|
||
#if __STD_C |
||
size_t malloc_usable_size(Void_t* mem) |
||
#else |
||
size_t malloc_usable_size(mem) Void_t* mem; |
||
#endif |
||
{ |
||
mchunkptr p; |
||
if (mem == 0) |
||
return 0; |
||
else |
||
{ |
||
p = mem2chunk(mem); |
||
if(!chunk_is_mmapped(p)) |
||
{ |
||
if (!inuse(p)) return 0; |
||
check_inuse_chunk(p); |
||
return chunksize(p) - SIZE_SZ; |
||
} |
||
return chunksize(p) - 2*SIZE_SZ; |
||
} |
||
} |
||
|
||
|
||
|
||
|
||
/* Utility to update current_mallinfo for malloc_stats and mallinfo() */ |
||
|
||
static void malloc_update_mallinfo() |
||
{ |
||
int i; |
||
mbinptr b; |
||
mchunkptr p; |
||
#if DEBUG |
||
mchunkptr q; |
||
#endif |
||
|
||
INTERNAL_SIZE_T avail = chunksize(top); |
||
int navail = ((long)(avail) >= (long)MINSIZE)? 1 : 0; |
||
|
||
for (i = 1; i < NAV; ++i) |
||
{ |
||
b = bin_at(i); |
||
for (p = last(b); p != b; p = p->bk) |
||
{ |
||
#if DEBUG |
||
check_free_chunk(p); |
||
for (q = next_chunk(p); |
||
q < top && inuse(q) && (long)(chunksize(q)) >= (long)MINSIZE; |
||
q = next_chunk(q)) |
||
check_inuse_chunk(q); |
||
#endif |
||
avail += chunksize(p); |
||
navail++; |
||
} |
||
} |
||
|
||
current_mallinfo.ordblks = navail; |
||
current_mallinfo.uordblks = sbrked_mem - avail; |
||
current_mallinfo.fordblks = avail; |
||
current_mallinfo.hblks = n_mmaps; |
||
current_mallinfo.hblkhd = mmapped_mem; |
||
current_mallinfo.keepcost = chunksize(top); |
||
|
||
} |
||
|
||
|
||
|
||
/* |
||
|
||
malloc_stats: |
||
|
||
Prints on stderr the amount of space obtain 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), the maximum |
||
number of simultaneous mmap regions used, 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.) |
||
|
||
*/ |
||
|
||
void malloc_stats() |
||
{ |
||
malloc_update_mallinfo(); |
||
fprintf(stderr, "max system bytes = %10u\n", |
||
(unsigned int)(max_total_mem)); |
||
fprintf(stderr, "system bytes = %10u\n", |
||
(unsigned int)(sbrked_mem + mmapped_mem)); |
||
fprintf(stderr, "in use bytes = %10u\n", |
||
(unsigned int)(current_mallinfo.uordblks + mmapped_mem)); |
||
#if HAVE_MMAP |
||
fprintf(stderr, "max mmap regions = %10u\n", |
||
(unsigned int)max_n_mmaps); |
||
#endif |
||
} |
||
|
||
/* |
||
mallinfo returns a copy of updated current mallinfo. |
||
*/ |
||
|
||
struct mallinfo mALLINFo() |
||
{ |
||
malloc_update_mallinfo(); |
||
return current_mallinfo; |
||
} |
||
|
||
|
||
|
||
|
||
/* |
||
mallopt: |
||
|
||
mallopt is the general SVID/XPG interface to 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. |
||
|
||
See descriptions of tunable parameters above. |
||
|
||
*/ |
||
|
||
#if __STD_C |
||
int mALLOPt(int param_number, int value) |
||
#else |
||
int mALLOPt(param_number, value) int param_number; int value; |
||
#endif |
||
{ |
||
switch(param_number) |
||
{ |
||
case M_TRIM_THRESHOLD: |
||
trim_threshold = value; return 1; |
||
case M_TOP_PAD: |
||
top_pad = value; return 1; |
||
case M_MMAP_THRESHOLD: |
||
mmap_threshold = value; return 1; |
||
case M_MMAP_MAX: |
||
#if HAVE_MMAP |
||
n_mmaps_max = value; return 1; |
||
#else |
||
if (value != 0) return 0; else n_mmaps_max = value; return 1; |
||
#endif |
||
|
||
default: |
||
return 0; |
||
} |
||
} |
||
|
||
/* |
||
|
||
History: |
||
|
||
V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee) |
||
* return null for negative arguments |
||
* Added Several WIN32 cleanups from Martin C. Fong <[email protected]> |
||
* Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h' |
||
(e.g. WIN32 platforms) |
||
* Cleanup up header file inclusion for WIN32 platforms |
||
* Cleanup code to avoid Microsoft Visual C++ compiler complaints |
||
* Add 'USE_DL_PREFIX' to quickly allow co-existence with existing |
||
memory allocation routines |
||
* Set 'malloc_getpagesize' for WIN32 platforms (needs more work) |
||
* Use 'assert' rather than 'ASSERT' in WIN32 code to conform to |
||
usage of 'assert' in non-WIN32 code |
||
* Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to |
||
avoid infinite loop |
||
* Always call 'fREe()' rather than 'free()' |
||
|
||
V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee) |
||
* Fixed ordering problem with boundary-stamping |
||
|
||
V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee) |
||
* Added pvalloc, as recommended by H.J. Liu |
||
* Added 64bit pointer support mainly from Wolfram Gloger |
||
* Added anonymously donated WIN32 sbrk emulation |
||
* Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen |
||
* malloc_extend_top: fix mask error that caused wastage after |
||
foreign sbrks |
||
* Add linux mremap support code from HJ Liu |
||
|
||
V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee) |
||
* Integrated most documentation with the code. |
||
* Add support for mmap, with help from |
||
Wolfram Gloger ([email protected]). |
||
* Use last_remainder in more cases. |
||
* Pack bins using idea from [email protected] |
||
* Use ordered bins instead of best-fit threshhold |
||
* Eliminate block-local decls to simplify tracing and debugging. |
||
* Support another case of realloc via move into top |
||
* Fix error occuring when initial sbrk_base not word-aligned. |
||
* Rely on page size for units instead of SBRK_UNIT to |
||
avoid surprises about sbrk alignment conventions. |
||
* Add mallinfo, mallopt. Thanks to Raymond Nijssen |
||
([email protected]) for the suggestion. |
||
* Add `pad' argument to malloc_trim and top_pad mallopt parameter. |
||
* More precautions for cases where other routines call sbrk, |
||
courtesy of Wolfram Gloger ([email protected]). |
||
* Added macros etc., allowing use in linux libc from |
||
H.J. Lu ([email protected]) |
||
* Inverted this history list |
||
|
||
V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee) |
||
* Re-tuned and fixed to behave more nicely with V2.6.0 changes. |
||
* Removed all preallocation code since under current scheme |
||
the work required to undo bad preallocations exceeds |
||
the work saved in good cases for most test programs. |
||
* No longer use return list or unconsolidated bins since |
||
no scheme using them consistently outperforms those that don't |
||
given above changes. |
||
* Use best fit for very large chunks to prevent some worst-cases. |
||
* Added some support for debugging |
||
|
||
V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee) |
||
* Removed footers when chunks are in use. Thanks to |
||
Paul Wilson ([email protected]) for the suggestion. |
||
|
||
V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee) |
||
* Added malloc_trim, with help from Wolfram Gloger |
||
([email protected]). |
||
|
||
V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g) |
||
|
||
V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g) |
||
* realloc: try to expand in both directions |
||
* malloc: swap order of clean-bin strategy; |
||
* realloc: only conditionally expand backwards |
||
* Try not to scavenge used bins |
||
* Use bin counts as a guide to preallocation |
||
* Occasionally bin return list chunks in first scan |
||
* Add a few optimizations from [email protected] |
||
|
||
V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g) |
||
* faster bin computation & slightly different binning |
||
* merged all consolidations to one part of malloc proper |
||
(eliminating old malloc_find_space & malloc_clean_bin) |
||
* Scan 2 returns chunks (not just 1) |
||
* Propagate failure in realloc if malloc returns 0 |
||
* Add stuff to allow compilation on non-ANSI compilers |
||
from [email protected] |
||
|
||
V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu) |
||
* removed potential for odd address access in prev_chunk |
||
* removed dependency on getpagesize.h |
||
* misc cosmetics and a bit more internal documentation |
||
* anticosmetics: mangled names in macros to evade debugger strangeness |
||
* tested on sparc, hp-700, dec-mips, rs6000 |
||
with gcc & native cc (hp, dec only) allowing |
||
Detlefs & Zorn comparison study (in SIGPLAN Notices.) |
||
|
||
Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu) |
||
* Based loosely on libg++-1.2X malloc. (It retains some of the overall |
||
structure of old version, but most details differ.) |
||
|
||
*/
|
||
|