/*  Default header file for malloc-2.7.2, written by Doug Lea  and released to the public domain.  Use, modify, and redistribute  this code without permission or acknowledgement in any way you wish.  Send questions, comments, complaints, performance data, etc to  dl@cs.oswego.edu.   last update: Sun Feb 25 18:38:11 2001  Doug Lea  (dl at gee)  This header is for ANSI C/C++ only.  You can set either of  the following #defines before including:  * If USE_DL_PREFIX is defined, it is assumed that malloc.c     was also compiled with this option, so all routines    have names starting with "dl".  * If HAVE_USR_INCLUDE_MALLOC_H is defined, it is assumed that this    file will be #included AFTER <malloc.h>. This is needed only if    your system defines a struct mallinfo that is incompatible with the    standard one declared here.  Otherwise, you can include this file    INSTEAD of your system system <malloc.h>.  At least on ANSI, all    declarations should be compatible with system versions*/#ifndef MALLOC_270_H#define MALLOC_270_H#ifdef __cplusplusextern "C" {#endif#include <stddef.h>   /* for size_t *//*  malloc(size_t n)  Returns a pointer to a newly allocated chunk of at least n bytes, or  null if no space is available. Additionally, on failure, errno is  set to ENOMEM on ANSI C systems.  If n is zero, malloc returns a minimum-sized chunk. The minimum size  is 16 bytes on most 32bit systems, and either 24 or 32 bytes on  64bit systems, depending on internal size and alignment restrictions.  On most systems, size_t is an unsigned type.  Calls with values of n  that appear "negative" when signed are interpreted as requests for  huge amounts of space, which will most often fail.  The maximum allowed value of n differs across systems, but is in all  cases less (typically by 8K) than the maximum representable value of  a size_t. Requests greater than this value result in failure.*/#ifndef USE_DL_PREFIXvoid*  malloc(size_t);#elsevoid*  dlmalloc(size_t);#endif/*  free(void* p)  Releases the chunk of memory pointed to by p, that had been previously  allocated using malloc or a related routine such as realloc.  It has no effect if p is null. It can have arbitrary (and bad!)  effects if p has already been freed or was not obtained via malloc.  Unless disabled using mallopt, freeing very large spaces will,  when possible, automatically trigger operations that give  back unused memory to the system, thus reducing program footprint.*/#ifndef USE_DL_PREFIXvoid     free(void*);#elsevoid     dlfree(void*);#endif/*  calloc(size_t n_elements, size_t element_size);  Returns a pointer to n_elements * element_size bytes, with all locations  set to zero.*/#ifndef USE_DL_PREFIXvoid*  calloc(size_t, size_t);#elsevoid*  dlcalloc(size_t, size_t);#endif/*  realloc(void* p, size_t n)  Returns a pointer to a chunk of size n that contains the same data  as does chunk p up to the minimum of (n, p's size) bytes.  The returned pointer may or may not be the same as p. The algorithm  prefers extending p when possible, otherwise it employs the  equivalent of a malloc-copy-free sequence.  If p is null, realloc is equivalent to malloc.    If space is not available, realloc returns null, errno is set (if on  ANSI) and p is NOT freed.  if n is for fewer bytes than already held by p, the newly unused  space is lopped off and freed if possible.  Unless the #define  REALLOC_ZERO_BYTES_FREES is set, realloc with a size argument of  zero (re)allocates a minimum-sized chunk.  Large chunks that were internally obtained via mmap will always  be reallocated using malloc-copy-free sequences unless  the system supports MREMAP (currently only linux).  The old unix realloc convention of allowing the last-free'd chunk  to be used as an argument to realloc is not supported.*/#ifndef USE_DL_PREFIXvoid*  realloc(void*, size_t);#elsevoid*  dlrealloc(void*, size_t);#endif/*  memalign(size_t alignment, size_t n);  Returns a pointer to a newly allocated chunk of n bytes, aligned  in accord with the alignment argument.  The alignment argument should be a power of two. If the argument is  not a power of two, the nearest greater power is used.  8-byte alignment is guaranteed by normal malloc calls, so don't  bother calling memalign with an argument of 8 or less.  Overreliance on memalign is a sure way to fragment space.*/#ifndef USE_DL_PREFIXvoid*  memalign(size_t, size_t);#elsevoid*  dlmemalign(size_t, size_t);#endif/*  valloc(size_t n);  Allocates a page-aligned chunk of at least n bytes.  Equivalent to memalign(pagesize, n), where pagesize is the page  size of the system. If the pagesize is unknown, 4096 is used.*/#ifndef USE_DL_PREFIXvoid*  valloc(size_t);#elsevoid*  dlvalloc(size_t);#endif/*  independent_calloc(size_t n_elements, size_t element_size, void* chunks[]);  independent_calloc is similar to calloc, but instead of returning a  single cleared space, it returns an array of pointers to n_elements  independent elements, each of which can hold contents of size  elem_size.  Each element starts out cleared, and can be  independently freed, realloc'ed etc. The elements are guaranteed to  be adjacently allocated (this is not guaranteed to occur with  multiple callocs or mallocs), which may also improve cache locality  in some applications.  The "chunks" argument is optional (i.e., may be null, which is  probably the most typical usage). If it is null, the returned array  is itself dynamically allocated and should also be freed when it is  no longer needed. Otherwise, the chunks array must be of at least  n_elements in length. It is filled in with the pointers to the  chunks.  In either case, independent_calloc returns this pointer array, or  null if the allocation failed.  If n_elements is zero and "chunks"  is null, it returns a chunk representing an array with zero elements  (which should be freed if not wanted).  Each element must be individually freed when it is no longer  needed. If you'd like to instead be able to free all at once, you  should instead use regular calloc and assign pointers into this  space to represent elements.  (In this case though, you cannot  independently free elements.)    independent_calloc simplifies and speeds up implementations of many  kinds of pools.  It may also be useful when constructing large data  structures that initially have a fixed number of fixed-sized nodes,  but the number is not known at compile time, and some of the nodes  may later need to be freed. For example:  struct Node { int item; struct Node* next; };    struct Node* build_list() {    struct Node** pool;    int n = read_number_of_nodes_needed();    if (n <= 0) return 0;    pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);    if (pool == 0) return 0; // failure    // organize into a linked list...     struct Node* first = pool[0];    for (i = 0; i < n-1; ++i)       pool[i]->next = pool[i+1];    free(pool);     // Can now free the array (or not, if it is needed later)    return first;  }*/#ifndef USE_DL_PREFIXvoid** independent_calloc(size_t, size_t, void**);#elsevoid** dlindependent_calloc(size_t, size_t, void**);#endif/*  independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]);  independent_comalloc allocates, all at once, a set of n_elements  chunks with sizes indicated in the "sizes" array.    It returns  an array of pointers to these elements, each of which can be  independently freed, realloc'ed etc. The elements are guaranteed to  be adjacently allocated (this is not guaranteed to occur with  multiple callocs or mallocs), which may also improve cache locality  in some applications.  The "chunks" argument is optional (i.e., may be null). If it is null  the returned array is itself dynamically allocated and should also  be freed when it is no longer needed. Otherwise, the chunks array  must be of at least n_elements in length. It is filled in with the  pointers to the chunks.  In either case, independent_comalloc returns this pointer array, or  null if the allocation failed.  If n_elements is zero and chunks is  null, it returns a chunk representing an array with zero elements  (which should be freed if not wanted).    Each element must be individually freed when it is no longer  needed. If you'd like to instead be able to free all at once, you  should instead use a single regular malloc, and assign pointers at  particular offsets in the aggregate space. (In this case though, you   cannot independently free elements.)  independent_comallac differs from independent_calloc in that each  element may have a different size, and also that it does not  automatically clear elements.  independent_comalloc can be used to speed up allocation in cases  where several structs or objects must always be allocated at the  same time.  For example:  struct Head { ... }  struct Foot { ... }  void send_message(char* msg) {    int msglen = strlen(msg);    size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };    void* chunks[3];    if (independent_comalloc(3, sizes, chunks) == 0)      die();    struct Head* head = (struct Head*)(chunks[0]);    char*        body = (char*)(chunks[1]);    struct Foot* foot = (struct Foot*)(chunks[2]);    // ...  }  In general though, independent_comalloc is worth using only for  larger values of n_elements. For small values, you probably won't  detect enough difference from series of malloc calls to bother.  Overuse of independent_comalloc can increase overall memory usage,  since it cannot reuse existing noncontiguous small chunks that  might be available for some of the elements.*/#ifndef USE_DL_PREFIXvoid** independent_comalloc(size_t, size_t*, void**);#elsevoid** dlindependent_comalloc(size_t, size_t*, void**);#endif/*  pvalloc(size_t n);  Equivalent to valloc(minimum-page-that-holds(n)), that is,  round up n to nearest pagesize. */#ifndef USE_DL_PREFIXvoid*  pvalloc(size_t);#elsevoid*  dlpvalloc(size_t);#endif/*  cfree(void* p);  Equivalent to free(p).  cfree is needed/defined on some systems that pair it with calloc,  for odd historical reasons (such as: cfree is used in example   code in the first edition of K&R).*/#ifndef USE_DL_PREFIXvoid     cfree(void*);#elsevoid     dlcfree(void*);#endif/*  malloc_trim(size_t pad);  If possible, gives memory back to the system (via negative  arguments to sbrk) if there is unused memory at the `high' end of  the malloc pool. 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.  On systems that do not support "negative sbrks", it will always  return 0.*/#ifndef USE_DL_PREFIXint      malloc_trim(size_t);#elseint      dlmalloc_trim(size_t);#endif/*