Subversion Repositories or1k

#ifdef MALLOC_PROVIDED

int _dummy_mallocr = 1;

#else

/* ---------- 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 dl@cs.oswego.edu

* VERSION 2.6.4  Thu Nov 28 07:54:55 1996  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 will return a

       minimum-sized chunk.

  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.

  SEPARATE_OBJECTS         (default: NOT defined)

     Define this to compile into separate .o files.  You must then

     compile malloc.c several times, defining a DEFINE_* macro each

     time.  The list of DEFINE_* macros appears below.

  MALLOC_LOCK              (default: NOT defined)

  MALLOC_UNLOCK            (default: NOT defined)

     Define these to C expressions which are run to lock and unlock

     the malloc data structures.  Calls may be nested; that is,

     MALLOC_LOCK may be called more than once before the corresponding

     MALLOC_UNLOCK calls.  MALLOC_LOCK must avoid waiting for a lock

     that it already holds.

  MALLOC_ALIGNMENT          (default: NOT defined)

     Define this to 16 if you need 16 byte alignment instead of 8 byte alignment

     which is the normal default.

  SIZE_T_SMALLER_THAN_LONG (default: NOT defined)

     Define this when the platform you are compiling has sizeof(long) > sizeof(size_t).

     The option causes some extra code to be generated to handle operations

     that use size_t operands and have long results.

  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.

  INTERNAL_NEWLIB           (default: NOT defined)

     Defined only when compiled as part of the Cygnus newlib

     distribution.

  WIN32                     (default: undefined)

     Define this on MS win (95, nt) platforms to compile in sbrk emulation.

  LACKS_UNISTD_H            (default: undefined)

     Define this if your system does not have a <unistd.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.

*/

/* 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

#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

*/

/*

  Special defines for Cygnus newlib distribution.

 */

#ifdef INTERNAL_NEWLIB

#include <sys/config.h>

/*

  In newlib, all the publically visible routines take a reentrancy

  pointer.  We don't currently do anything much with it, but we do

  pass it to the lock routine.

 */

#include <reent.h>

#define POINTER_UINT unsigned _POINTER_INT

#define SEPARATE_OBJECTS

#define HAVE_MMAP 0

#define MORECORE(size) _sbrk_r(reent_ptr, (size))

#define MORECORE_CLEARS 0

#define MALLOC_LOCK __malloc_lock(reent_ptr)

#define MALLOC_UNLOCK __malloc_unlock(reent_ptr)

#ifndef _WIN32

#ifdef SMALL_MEMORY

#define malloc_getpagesize (128)

#else

#define malloc_getpagesize (4096)

#endif

#endif

#if __STD_C

extern void __malloc_lock(struct _reent *);

extern void __malloc_unlock(struct _reent *);

#else

extern void __malloc_lock();

extern void __malloc_unlock();

#endif

#if __STD_C

#define RARG struct _reent *reent_ptr,

#define RONEARG struct _reent *reent_ptr

#else

#define RARG reent_ptr

#define RONEARG reent_ptr

#define RDECL struct _reent *reent_ptr;

#endif

#define RCALL reent_ptr,

#define RONECALL reent_ptr

#else /* ! INTERNAL_NEWLIB */

#define POINTER_UINT unsigned long

#define RARG

#define RONEARG

#define RDECL

#define RCALL

#define RONECALL

#endif /* ! INTERNAL_NEWLIB */

/*

    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

/*

  SEPARATE_OBJECTS should be defined if you want each function to go

  into a separate .o file.  You must then compile malloc.c once per

  function, defining the appropriate DEFINE_ macro.  See below for the

  list of macros.

 */

#ifndef SEPARATE_OBJECTS

#define DEFINE_MALLOC

#define DEFINE_FREE

#define DEFINE_REALLOC

#define DEFINE_CALLOC

#define DEFINE_CFREE

#define DEFINE_MEMALIGN

#define DEFINE_VALLOC

#define DEFINE_PVALLOC

#define DEFINE_MALLINFO

#define DEFINE_MALLOC_STATS

#define DEFINE_MALLOC_USABLE_SIZE

#define DEFINE_MALLOPT

#define STATIC static

#else

#define STATIC

#endif

/*

   Define MALLOC_LOCK and MALLOC_UNLOCK to C expressions to run to

   lock and unlock the malloc data structures.  MALLOC_LOCK may be

   called recursively.

 */

#ifndef MALLOC_LOCK

#define MALLOC_LOCK

#endif

#ifndef MALLOC_UNLOCK

#define MALLOC_UNLOCK

#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

/*

  Following is needed on implementations whereby long > size_t.

  The problem is caused because the code performs subtractions of

  size_t values and stores the result in long values.  In the case

  where long > size_t and the first value is actually less than

  the second value, the resultant value is positive.  For example,

  (long)(x - y) where x = 0 and y is 1 ends up being 0x00000000FFFFFFFF

  which is 2*31 - 1 instead of 0xFFFFFFFFFFFFFFFF.  This is due to the

  fact that assignment from unsigned to signed won't sign extend.

*/

#ifdef SIZE_T_SMALLER_THAN_LONG

#define long_sub_size_t(x, y) ( (x < y) ? -((long)(y - x)) : (x - y) );

#else

#define long_sub_size_t(x, y) ( (long)(x - y) )

#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

#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

Void_t* memset();

Void_t* memcpy();

#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

#      include <sys/param.h>

#      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

/*

  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 (128L * 1024L)

#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