1 /*

     2   $Id: malloc.c,v 1.4 2006/03/30 16:47:29 wg Exp $

     3 

     4   This version of malloc.c was adapted for ptmalloc3 by Wolfram Gloger

     5   <wg@malloc.de>.  Therefore, some of the comments below do not apply

     6   for this modified version.  However, it is the intention to keep

     7   differences to Doug Lea's original version minimal, hence the

     8   comments were mostly left unchanged.

     9 

    10  -----------------------------------------------------------------------

    11 

    12   This is a version (aka dlmalloc) of malloc/free/realloc written by

    13   Doug Lea and released to the public domain, as explained at

    14   http://creativecommons.org/licenses/publicdomain.  Send questions,

    15   comments, complaints, performance data, etc to dl@cs.oswego.edu

    16 

    17 * Version pre-2.8.4 Wed Mar 29 19:46:29 2006    (dl at gee)

    18 

    19    Note: There may be an updated version of this malloc obtainable at

    20            ftp://gee.cs.oswego.edu/pub/misc/malloc.c

    21          Check before installing!

    22 

    23 * Quickstart

    24 

    25   This library is all in one file to simplify the most common usage:

    26   ftp it, compile it (-O3), and link it into another program. All of

    27   the compile-time options default to reasonable values for use on

    28   most platforms.  You might later want to step through various

    29   compile-time and dynamic tuning options.

    30 

    31   For convenience, an include file for code using this malloc is at:

    32      ftp://gee.cs.oswego.edu/pub/misc/malloc-2.8.3.h

    33   You don't really need this .h file unless you call functions not

    34   defined in your system include files.  The .h file contains only the

    35   excerpts from this file needed for using this malloc on ANSI C/C++

    36   systems, so long as you haven't changed compile-time options about

    37   naming and tuning parameters.  If you do, then you can create your

    38   own malloc.h that does include all settings by cutting at the point

    39   indicated below. Note that you may already by default be using a C

    40   library containing a malloc that is based on some version of this

    41   malloc (for example in linux). You might still want to use the one

    42   in this file to customize settings or to avoid overheads associated

    43   with library versions.

    44 

    45 * Vital statistics:

    46 

    47   Supported pointer/size_t representation:       4 or 8 bytes

    48        size_t MUST be an unsigned type of the same width as

    49        pointers. (If you are using an ancient system that declares

    50        size_t as a signed type, or need it to be a different width

    51        than pointers, you can use a previous release of this malloc

    52        (e.g. 2.7.2) supporting these.)

    53 

    54   Alignment:                                     8 bytes (default)

    55        This suffices for nearly all current machines and C compilers.

    56        However, you can define MALLOC_ALIGNMENT to be wider than this

    57        if necessary (up to 128bytes), at the expense of using more space.

    58 

    59   Minimum overhead per allocated chunk:   4 or  8 bytes (if 4byte sizes)

    60                                           8 or 16 bytes (if 8byte sizes)

    61        Each malloced chunk has a hidden word of overhead holding size

    62        and status information, and additional cross-check word

    63        if FOOTERS is defined.

    64 

    65   Minimum allocated size: 4-byte ptrs:  16 bytes    (including overhead)

    66                           8-byte ptrs:  32 bytes    (including overhead)

    67 

    68        Even a request for zero bytes (i.e., malloc(0)) returns a

    69        pointer to something of the minimum allocatable size.

    70        The maximum overhead wastage (i.e., number of extra bytes

    71        allocated than were requested in malloc) is less than or equal

    72        to the minimum size, except for requests >= mmap_threshold that

    73        are serviced via mmap(), where the worst case wastage is about

    74        32 bytes plus the remainder from a system page (the minimal

    75        mmap unit); typically 4096 or 8192 bytes.

    76 

    77   Security: static-safe; optionally more or less

    78        The "security" of malloc refers to the ability of malicious

    79        code to accentuate the effects of errors (for example, freeing

    80        space that is not currently malloc'ed or overwriting past the

    81        ends of chunks) in code that calls malloc.  This malloc

    82        guarantees not to modify any memory locations below the base of

    83        heap, i.e., static variables, even in the presence of usage

    84        errors.  The routines additionally detect most improper frees

    85        and reallocs.  All this holds as long as the static bookkeeping

    86        for malloc itself is not corrupted by some other means.  This

    87        is only one aspect of security -- these checks do not, and

    88        cannot, detect all possible programming errors.

    89 

    90        If FOOTERS is defined nonzero, then each allocated chunk

    91        carries an additional check word to verify that it was malloced

    92        from its space.  These check words are the same within each

    93        execution of a program using malloc, but differ across

    94        executions, so externally crafted fake chunks cannot be

    95        freed. This improves security by rejecting frees/reallocs that

    96        could corrupt heap memory, in addition to the checks preventing

    97        writes to statics that are always on.  This may further improve

    98        security at the expense of time and space overhead.  (Note that

    99        FOOTERS may also be worth using with MSPACES.)

   100 

   101        By default detected errors cause the program to abort (calling

   102        "abort()"). You can override this to instead proceed past

   103        errors by defining PROCEED_ON_ERROR.  In this case, a bad free

   104        has no effect, and a malloc that encounters a bad address

   105        caused by user overwrites will ignore the bad address by

   106        dropping pointers and indices to all known memory. This may

   107        be appropriate for programs that should continue if at all

   108        possible in the face of programming errors, although they may

   109        run out of memory because dropped memory is never reclaimed.

   110 

   111        If you don't like either of these options, you can define

   112        CORRUPTION_ERROR_ACTION and USAGE_ERROR_ACTION to do anything

   113        else. And if if you are sure that your program using malloc has

   114        no errors or vulnerabilities, you can define INSECURE to 1,

   115        which might (or might not) provide a small performance improvement.

   116 

   117   Thread-safety: NOT thread-safe unless USE_LOCKS defined

   118        When USE_LOCKS is defined, each public call to malloc, free,

   119        etc is surrounded with either a pthread mutex or a win32

   120        spinlock (depending on WIN32). This is not especially fast, and

   121        can be a major bottleneck.  It is designed only to provide

   122        minimal protection in concurrent environments, and to provide a

   123        basis for extensions.  If you are using malloc in a concurrent

   124        program, consider instead using nedmalloc

   125        (http://www.nedprod.com/programs/portable/nedmalloc/) or

   126        ptmalloc (See http://www.malloc.de), which are derived

   127        from versions of this malloc.

   128 

   129   System requirements: Any combination of MORECORE and/or MMAP/MUNMAP

   130        This malloc can use unix sbrk or any emulation (invoked using

   131        the CALL_MORECORE macro) and/or mmap/munmap or any emulation

   132        (invoked using CALL_MMAP/CALL_MUNMAP) to get and release system

   133        memory.  On most unix systems, it tends to work best if both

   134        MORECORE and MMAP are enabled.  On Win32, it uses emulations

   135        based on VirtualAlloc. It also uses common C library functions

   136        like memset.

   137 

   138   Compliance: I believe it is compliant with the Single Unix Specification

   139        (See http://www.unix.org). Also SVID/XPG, ANSI C, and probably

   140        others as well.

   141 

   142 * Overview of algorithms

   143 

   144   This is not the fastest, most space-conserving, most portable, or

   145   most tunable malloc ever written. However it is among the fastest

   146   while also being among the most space-conserving, portable and

   147   tunable.  Consistent balance across these factors results in a good

   148   general-purpose allocator for malloc-intensive programs.

   149 

   150   In most ways, this malloc is a best-fit allocator. Generally, it

   151   chooses the best-fitting existing chunk for a request, with ties

   152   broken in approximately least-recently-used order. (This strategy

   153   normally maintains low fragmentation.) However, for requests less

   154   than 256bytes, it deviates from best-fit when there is not an

   155   exactly fitting available chunk by preferring to use space adjacent

   156   to that used for the previous small request, as well as by breaking

   157   ties in approximately most-recently-used order. (These enhance

   158   locality of series of small allocations.)  And for very large requests

   159   (>= 256Kb by default), it relies on system memory mapping

   160   facilities, if supported.  (This helps avoid carrying around and

   161   possibly fragmenting memory used only for large chunks.)

   162 

   163   All operations (except malloc_stats and mallinfo) have execution

   164   times that are bounded by a constant factor of the number of bits in

   165   a size_t, not counting any clearing in calloc or copying in realloc,

   166   or actions surrounding MORECORE and MMAP that have times

   167   proportional to the number of non-contiguous regions returned by

   168   system allocation routines, which is often just 1. In real-time

   169   applications, you can optionally suppress segment traversals using

   170   NO_SEGMENT_TRAVERSAL, which assures bounded execution even when

   171   system allocators return non-contiguous spaces, at the typical

   172   expense of carrying around more memory and increased fragmentation.

   173 

   174   The implementation is not very modular and seriously overuses

   175   macros. Perhaps someday all C compilers will do as good a job

   176   inlining modular code as can now be done by brute-force expansion,

   177   but now, enough of them seem not to.

   178 

   179   Some compilers issue a lot of warnings about code that is

   180   dead/unreachable only on some platforms, and also about intentional

   181   uses of negation on unsigned types. All known cases of each can be

   182   ignored.

   183 

   184   For a longer but out of date high-level description, see

   185      http://gee.cs.oswego.edu/dl/html/malloc.html

   186 

   187 * MSPACES

   188   If MSPACES is defined, then in addition to malloc, free, etc.,

   189   this file also defines mspace_malloc, mspace_free, etc. These

   190   are versions of malloc routines that take an "mspace" argument

   191   obtained using create_mspace, to control all internal bookkeeping.

   192   If ONLY_MSPACES is defined, only these versions are compiled.

   193   So if you would like to use this allocator for only some allocations,

   194   and your system malloc for others, you can compile with

   195   ONLY_MSPACES and then do something like...

   196     static mspace mymspace = create_mspace(0,0); // for example

   197     #define mymalloc(bytes)  mspace_malloc(mymspace, bytes)

   198 

   199   (Note: If you only need one instance of an mspace, you can instead

   200   use "USE_DL_PREFIX" to relabel the global malloc.)

   201 

   202   You can similarly create thread-local allocators by storing

   203   mspaces as thread-locals. For example:

   204     static __thread mspace tlms = 0;

   205     void*  tlmalloc(size_t bytes) {

   206       if (tlms == 0) tlms = create_mspace(0, 0);

   207       return mspace_malloc(tlms, bytes);

   208     }

   209     void  tlfree(void* mem) { mspace_free(tlms, mem); }

   210 

   211   Unless FOOTERS is defined, each mspace is completely independent.

   212   You cannot allocate from one and free to another (although

   213   conformance is only weakly checked, so usage errors are not always

   214   caught). If FOOTERS is defined, then each chunk carries around a tag

   215   indicating its originating mspace, and frees are directed to their

   216   originating spaces.

   217 

   218  -------------------------  Compile-time options ---------------------------

   219 

   220 Be careful in setting #define values for numerical constants of type

   221 size_t. On some systems, literal values are not automatically extended

   222 to size_t precision unless they are explicitly casted. You can also

   223 use the symbolic values MAX_SIZE_T, SIZE_T_ONE, etc below.

   224 

   225 WIN32                    default: defined if _WIN32 defined

   226   Defining WIN32 sets up defaults for MS environment and compilers.

   227   Otherwise defaults are for unix.

   228 

   229 MALLOC_ALIGNMENT         default: (size_t)8

   230   Controls the minimum alignment for malloc'ed chunks.  It must be a

   231   power of two and at least 8, even on machines for which smaller

   232   alignments would suffice. It may be defined as larger than this

   233   though. Note however that code and data structures are optimized for

   234   the case of 8-byte alignment.

   235 

   236 MSPACES                  default: 0 (false)

   237   If true, compile in support for independent allocation spaces.

   238   This is only supported if HAVE_MMAP is true.

   239 

   240 ONLY_MSPACES             default: 0 (false)

   241   If true, only compile in mspace versions, not regular versions.

   242 

   243 USE_LOCKS                default: 0 (false)

   244   Causes each call to each public routine to be surrounded with

   245   pthread or WIN32 mutex lock/unlock. (If set true, this can be

   246   overridden on a per-mspace basis for mspace versions.) If set to a

   247   non-zero value other than 1, locks are used, but their

   248   implementation is left out, so lock functions must be supplied manually.

   249 

   250 USE_SPIN_LOCKS           default: 1 iff USE_LOCKS and on x86 using gcc or MSC

   251   If true, uses custom spin locks for locking. This is currently

   252   supported only for x86 platforms using gcc or recent MS compilers.

   253   Otherwise, posix locks or win32 critical sections are used.

   254 

   255 FOOTERS                  default: 0

   256   If true, provide extra checking and dispatching by placing

   257   information in the footers of allocated chunks. This adds

   258   space and time overhead.

   259 

   260 INSECURE                 default: 0

   261   If true, omit checks for usage errors and heap space overwrites.

   262 

   263 USE_DL_PREFIX            default: NOT defined

   264   Causes compiler to prefix all public routines with the string 'dl'.

   265   This can be useful when you only want to use this malloc in one part

   266   of a program, using your regular system malloc elsewhere.

   267 

   268 ABORT                    default: defined as abort()

   269   Defines how to abort on failed checks.  On most systems, a failed

   270   check cannot die with an "assert" or even print an informative

   271   message, because the underlying print routines in turn call malloc,

   272   which will fail again.  Generally, the best policy is to simply call

   273   abort(). It's not very useful to do more than this because many

   274   errors due to overwriting will show up as address faults (null, odd

   275   addresses etc) rather than malloc-triggered checks, so will also

   276   abort.  Also, most compilers know that abort() does not return, so

   277   can better optimize code conditionally calling it.

   278 

   279 PROCEED_ON_ERROR           default: defined as 0 (false)

   280   Controls whether detected bad addresses cause them to bypassed

   281   rather than aborting. If set, detected bad arguments to free and

   282   realloc are ignored. And all bookkeeping information is zeroed out

   283   upon a detected overwrite of freed heap space, thus losing the

   284   ability to ever return it from malloc again, but enabling the

   285   application to proceed. If PROCEED_ON_ERROR is defined, the

   286   static variable malloc_corruption_error_count is compiled in

   287   and can be examined to see if errors have occurred. This option

   288   generates slower code than the default abort policy.

   289 

   290 DEBUG                    default: NOT defined

   291   The DEBUG setting is mainly intended for people trying to modify

   292   this code or diagnose problems when porting to new platforms.

   293   However, it may also be able to better isolate user errors than just

   294   using runtime checks.  The assertions in the check routines spell

   295   out in more detail the assumptions and invariants underlying the

   296   algorithms.  The checking is fairly extensive, and will slow down

   297   execution noticeably. Calling malloc_stats or mallinfo with DEBUG

   298   set will attempt to check every non-mmapped allocated and free chunk

   299   in the course of computing the summaries.

   300 

   301 ABORT_ON_ASSERT_FAILURE   default: defined as 1 (true)

   302   Debugging assertion failures can be nearly impossible if your

   303   version of the assert macro causes malloc to be called, which will

   304   lead to a cascade of further failures, blowing the runtime stack.

   305   ABORT_ON_ASSERT_FAILURE cause assertions failures to call abort(),

   306   which will usually make debugging easier.

   307 

   308 MALLOC_FAILURE_ACTION     default: sets errno to ENOMEM, or no-op on win32

   309   The action to take before "return 0" when malloc fails to be able to

   310   return memory because there is none available.

   311 

   312 HAVE_MORECORE             default: 1 (true) unless win32 or ONLY_MSPACES

   313   True if this system supports sbrk or an emulation of it.

   314 

   315 MORECORE                  default: sbrk

   316   The name of the sbrk-style system routine to call to obtain more

   317   memory.  See below for guidance on writing custom MORECORE

   318   functions. The type of the argument to sbrk/MORECORE varies across

   319   systems.  It cannot be size_t, because it supports negative

   320   arguments, so it is normally the signed type of the same width as

   321   size_t (sometimes declared as "intptr_t").  It doesn't much matter

   322   though. Internally, we only call it with arguments less than half

   323   the max value of a size_t, which should work across all reasonable

   324   possibilities, although sometimes generating compiler warnings.  See

   325   near the end of this file for guidelines for creating a custom

   326   version of MORECORE.

   327 

   328 MORECORE_CONTIGUOUS       default: 1 (true) if HAVE_MORECORE

   329   If true, take advantage of fact that consecutive calls to MORECORE

   330   with positive arguments always return contiguous increasing

   331   addresses.  This is true of unix sbrk. It does not hurt too much to

   332   set it true anyway, since malloc copes with non-contiguities.

   333   Setting it false when definitely non-contiguous saves time

   334   and possibly wasted space it would take to discover this though.

   335 

   336 MORECORE_CANNOT_TRIM      default: NOT defined

   337   True if MORECORE cannot release space back to the system when given

   338   negative arguments. This is generally necessary only if you are

   339   using a hand-crafted MORECORE function that cannot handle negative

   340   arguments.

   341 

   342 NO_SEGMENT_TRAVERSAL       default: 0

   343   If non-zero, suppresses traversals of memory segments

   344   returned by either MORECORE or CALL_MMAP. This disables

   345   merging of segments that are contiguous, and selectively

   346   releasing them to the OS if unused, but bounds execution times.

   347 

   348 HAVE_MMAP                 default: 1 (true)

   349   True if this system supports mmap or an emulation of it.  If so, and

   350   HAVE_MORECORE is not true, MMAP is used for all system

   351   allocation. If set and HAVE_MORECORE is true as well, MMAP is

   352   primarily used to directly allocate very large blocks. It is also

   353   used as a backup strategy in cases where MORECORE fails to provide

   354   space from system. Note: A single call to MUNMAP is assumed to be

   355   able to unmap memory that may have be allocated using multiple calls

   356   to MMAP, so long as they are adjacent.

   357 

   358 HAVE_MREMAP               default: 1 on linux, else 0

   359   If true realloc() uses mremap() to re-allocate large blocks and

   360   extend or shrink allocation spaces.

   361 

   362 MMAP_CLEARS               default: 1 except on WINCE.

   363   True if mmap clears memory so calloc doesn't need to. This is true

   364   for standard unix mmap using /dev/zero and on WIN32 except for WINCE.

   365 

   366 USE_BUILTIN_FFS            default: 0 (i.e., not used)

   367   Causes malloc to use the builtin ffs() function to compute indices.

   368   Some compilers may recognize and intrinsify ffs to be faster than the

   369   supplied C version. Also, the case of x86 using gcc is special-cased

   370   to an asm instruction, so is already as fast as it can be, and so

   371   this setting has no effect. Similarly for Win32 under recent MS compilers.

   372   (On most x86s, the asm version is only slightly faster than the C version.)

   373 

   374 malloc_getpagesize         default: derive from system includes, or 4096.

   375   The system page size. To the extent possible, this malloc manages

   376   memory from the system in page-size units.  This may be (and

   377   usually is) a function rather than a constant. This is ignored

   378   if WIN32, where page size is determined using getSystemInfo during

   379   initialization.

   380 

   381 USE_DEV_RANDOM             default: 0 (i.e., not used)

   382   Causes malloc to use /dev/random to initialize secure magic seed for

   383   stamping footers. Otherwise, the current time is used.

   384 

   385 NO_MALLINFO                default: 0

   386   If defined, don't compile "mallinfo". This can be a simple way

   387   of dealing with mismatches between system declarations and

   388   those in this file.

   389 

   390 MALLINFO_FIELD_TYPE        default: size_t

   391   The type of the fields in the mallinfo struct. This was originally

   392   defined as "int" in SVID etc, but is more usefully defined as

   393   size_t. The value is used only if  HAVE_USR_INCLUDE_MALLOC_H is not set

   394 

   395 REALLOC_ZERO_BYTES_FREES    default: not defined

   396   This should be set if a call to realloc with zero bytes should

   397   be the same as a call to free. Some people think it should. Otherwise,

   398   since this malloc returns a unique pointer for malloc(0), so does

   399   realloc(p, 0).

   400 

   401 LACKS_UNISTD_H, LACKS_FCNTL_H, LACKS_SYS_PARAM_H, LACKS_SYS_MMAN_H

   402 LACKS_STRINGS_H, LACKS_STRING_H, LACKS_SYS_TYPES_H,  LACKS_ERRNO_H

   403 LACKS_STDLIB_H                default: NOT defined unless on WIN32

   404   Define these if your system does not have these header files.

   405   You might need to manually insert some of the declarations they provide.

   406 

   407 DEFAULT_GRANULARITY        default: page size if MORECORE_CONTIGUOUS,

   408                                 system_info.dwAllocationGranularity in WIN32,

   409                                 otherwise 64K.

   410       Also settable using mallopt(M_GRANULARITY, x)

   411   The unit for allocating and deallocating memory from the system.  On

   412   most systems with contiguous MORECORE, there is no reason to

   413   make this more than a page. However, systems with MMAP tend to

   414   either require or encourage larger granularities.  You can increase

   415   this value to prevent system allocation functions to be called so

   416   often, especially if they are slow.  The value must be at least one

   417   page and must be a power of two.  Setting to 0 causes initialization

   418   to either page size or win32 region size.  (Note: In previous

   419   versions of malloc, the equivalent of this option was called

   420   "TOP_PAD")

   421 

   422 DEFAULT_TRIM_THRESHOLD    default: 2MB

   423       Also settable using mallopt(M_TRIM_THRESHOLD, x)

   424   The maximum amount of unused top-most memory to keep before

   425   releasing via malloc_trim in free().  Automatic trimming is mainly

   426   useful in long-lived programs using contiguous MORECORE.  Because

   427   trimming via sbrk can be slow on some systems, and can sometimes be

   428   wasteful (in cases where programs immediately afterward allocate

   429   more large chunks) the value should be high enough so that your

   430   overall system performance would improve by releasing this much

   431   memory.  As a rough guide, you might set to a value close to the

   432   average size of a process (program) running on your system.

   433   Releasing this much memory would allow such a process to run in

   434   memory.  Generally, it is worth tuning trim thresholds when a

   435   program undergoes phases where several large chunks are allocated

   436   and released in ways that can reuse each other's storage, perhaps

   437   mixed with phases where there are no such chunks at all. The trim

   438   value must be greater than page size to have any useful effect.  To

   439   disable trimming completely, you can set to MAX_SIZE_T. Note that the trick

   440   some people use of mallocing a huge space and then freeing it at

   441   program startup, in an attempt to reserve system memory, doesn't

   442   have the intended effect under automatic trimming, since that memory

   443   will immediately be returned to the system.

   444 

   445 DEFAULT_MMAP_THRESHOLD       default: 256K

   446       Also settable using mallopt(M_MMAP_THRESHOLD, x)

   447   The request size threshold for using MMAP to directly service a

   448   request. Requests of at least this size that cannot be allocated

   449   using already-existing space will be serviced via mmap.  (If enough

   450   normal freed space already exists it is used instead.)  Using mmap

   451   segregates relatively large chunks of memory so that they can be

   452   individually obtained and released from the host system. A request

   453   serviced through mmap is never reused by any other request (at least

   454   not directly; the system may just so happen to remap successive

   455   requests to the same locations).  Segregating space in this way has

   456   the benefits that: Mmapped space can always be individually released

   457   back to the system, which helps keep the system level memory demands

   458   of a long-lived program low.  Also, mapped memory doesn't become

   459   `locked' between other chunks, as can happen with normally allocated

   460   chunks, which means that even trimming via malloc_trim would not

   461   release them.  However, it has the disadvantage that the space

   462   cannot be reclaimed, consolidated, and then used to service later

   463   requests, as happens with normal chunks.  The advantages of mmap

   464   nearly always outweigh disadvantages for "large" chunks, but the

   465   value of "large" may vary across systems.  The default is an

   466   empirically derived value that works well in most systems. You can

   467   disable mmap by setting to MAX_SIZE_T.

   468 

   469 MAX_RELEASE_CHECK_RATE   default: 255 unless not HAVE_MMAP

   470   The number of consolidated frees between checks to release

   471   unused segments when freeing. When using non-contiguous segments,

   472   especially with multiple mspaces, checking only for topmost space

   473   doesn't always suffice to trigger trimming. To compensate for this,

   474   free() will, with a period of MAX_RELEASE_CHECK_RATE (or the

   475   current number of segments, if greater) try to release unused

   476   segments to the OS when freeing chunks that result in

   477   consolidation. The best value for this parameter is a compromise

   478   between slowing down frees with relatively costly checks that

   479   rarely trigger versus holding on to unused memory. To effectively

   480   disable, set to MAX_SIZE_T. This may lead to a very slight speed

   481   improvement at the expense of carrying around more memory.

   482 */

   483 

   484 #ifndef WIN32

   485 #ifdef _WIN32

   486 #define WIN32 1

   487 #endif  /* _WIN32 */

   488 #endif  /* WIN32 */

   489 #ifdef WIN32

   490 #define WIN32_LEAN_AND_MEAN

   491 #include <windows.h>

   492 #define HAVE_MMAP 1

   493 #define HAVE_MORECORE 0

   494 #define LACKS_UNISTD_H

   495 #define LACKS_SYS_PARAM_H

   496 #define LACKS_SYS_MMAN_H

   497 #define LACKS_STRING_H

   498 #define LACKS_STRINGS_H

   499 #define LACKS_SYS_TYPES_H

   500 #define LACKS_ERRNO_H

   501 #define MALLOC_FAILURE_ACTION

   502 #ifdef _WIN32_WCE /* WINCE reportedly does not clear */

   503 #define MMAP_CLEARS 0

   504 #else

   505 #define MMAP_CLEARS 1

   506 #endif /* _WIN32_WCE */

   507 #endif  /* WIN32 */

   508 

   509 #if defined(DARWIN) || defined(_DARWIN)

   510 /* Mac OSX docs advise not to use sbrk; it seems better to use mmap */

   511 #ifndef HAVE_MORECORE

   512 #define HAVE_MORECORE 0

   513 #define HAVE_MMAP 1

   514 #endif  /* HAVE_MORECORE */

   515 #endif  /* DARWIN */

   516 

   517 #ifndef LACKS_SYS_TYPES_H

   518 #include <sys/types.h>  /* For size_t */

   519 #endif  /* LACKS_SYS_TYPES_H */

   520 

   521 /* The maximum possible size_t value has all bits set */

   522 #define MAX_SIZE_T           (~(size_t)0)

   523 

   524 #ifndef ONLY_MSPACES

   525 #define ONLY_MSPACES 0

   526 #endif  /* ONLY_MSPACES */

   527 #ifndef MSPACES

   528 #if ONLY_MSPACES

   529 #define MSPACES 1

   530 #else   /* ONLY_MSPACES */

   531 #define MSPACES 0

   532 #endif  /* ONLY_MSPACES */

   533 #endif  /* MSPACES */

   534 #ifndef MALLOC_ALIGNMENT

   535 #define MALLOC_ALIGNMENT ((size_t)8U)

   536 #endif  /* MALLOC_ALIGNMENT */

   537 #ifndef FOOTERS

   538 #define FOOTERS 0

   539 #endif  /* FOOTERS */

   540 #ifndef ABORT

   541 #define ABORT  abort()

   542 #endif  /* ABORT */

   543 #ifndef ABORT_ON_ASSERT_FAILURE

   544 #define ABORT_ON_ASSERT_FAILURE 1

   545 #endif  /* ABORT_ON_ASSERT_FAILURE */

   546 #ifndef PROCEED_ON_ERROR

   547 #define PROCEED_ON_ERROR 0

   548 #endif  /* PROCEED_ON_ERROR */

   549 #ifndef USE_LOCKS

   550 #define USE_LOCKS 0

   551 #endif  /* USE_LOCKS */

   552 #ifndef USE_SPIN_LOCKS

   553 #if USE_LOCKS && (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))) || (defined(_MSC_VER) && _MSC_VER>=1310)

   554 #define USE_SPIN_LOCKS 1

   555 #else

   556 #define USE_SPIN_LOCKS 0

   557 #endif /* USE_LOCKS && ... */

   558 #endif /* USE_SPIN_LOCKS */

   559 #ifndef INSECURE

   560 #define INSECURE 0

   561 #endif  /* INSECURE */

   562 #ifndef HAVE_MMAP

   563 #define HAVE_MMAP 1

   564 #endif  /* HAVE_MMAP */

   565 #ifndef MMAP_CLEARS

   566 #define MMAP_CLEARS 1

   567 #endif  /* MMAP_CLEARS */

   568 #ifndef HAVE_MREMAP

   569 #ifdef linux

   570 #define HAVE_MREMAP 1

   571 #else   /* linux */

   572 #define HAVE_MREMAP 0

   573 #endif  /* linux */

   574 #endif  /* HAVE_MREMAP */

   575 #ifndef MALLOC_FAILURE_ACTION

   576 #define MALLOC_FAILURE_ACTION  errno = ENOMEM;

   577 #endif  /* MALLOC_FAILURE_ACTION */

   578 #ifndef HAVE_MORECORE

   579 #if ONLY_MSPACES

   580 #define HAVE_MORECORE 0

   581 #else   /* ONLY_MSPACES */

   582 #define HAVE_MORECORE 1

   583 #endif  /* ONLY_MSPACES */

   584 #endif  /* HAVE_MORECORE */

   585 #if !HAVE_MORECORE

   586 #define MORECORE_CONTIGUOUS 0

   587 #else   /* !HAVE_MORECORE */

   588 #ifndef MORECORE

   589 #define MORECORE sbrk

   590 #endif  /* MORECORE */

   591 #ifndef MORECORE_CONTIGUOUS

   592 #define MORECORE_CONTIGUOUS 1

   593 #endif  /* MORECORE_CONTIGUOUS */

   594 #endif  /* HAVE_MORECORE */

   595 #ifndef DEFAULT_GRANULARITY

   596 #if MORECORE_CONTIGUOUS

   597 #define DEFAULT_GRANULARITY (0)  /* 0 means to compute in init_mparams */

   598 #else   /* MORECORE_CONTIGUOUS */

   599 #define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)

   600 #endif  /* MORECORE_CONTIGUOUS */

   601 #endif  /* DEFAULT_GRANULARITY */

   602 #ifndef DEFAULT_TRIM_THRESHOLD

   603 #ifndef MORECORE_CANNOT_TRIM

   604 #define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)

   605 #else   /* MORECORE_CANNOT_TRIM */

   606 #define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T

   607 #endif  /* MORECORE_CANNOT_TRIM */

   608 #endif  /* DEFAULT_TRIM_THRESHOLD */

   609 #ifndef DEFAULT_MMAP_THRESHOLD

   610 #if HAVE_MMAP

   611 #define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)

   612 #else   /* HAVE_MMAP */

   613 #define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T

   614 #endif  /* HAVE_MMAP */

   615 #endif  /* DEFAULT_MMAP_THRESHOLD */

   616 #ifndef MAX_RELEASE_CHECK_RATE

   617 #if HAVE_MMAP

   618 #define MAX_RELEASE_CHECK_RATE 255

   619 #else

   620 #define MAX_RELEASE_CHECK_RATE MAX_SIZE_T

   621 #endif /* HAVE_MMAP */

   622 #endif /* MAX_RELEASE_CHECK_RATE */

   623 #ifndef USE_BUILTIN_FFS

   624 #define USE_BUILTIN_FFS 0

   625 #endif  /* USE_BUILTIN_FFS */

   626 #ifndef USE_DEV_RANDOM

   627 #define USE_DEV_RANDOM 0

   628 #endif  /* USE_DEV_RANDOM */

   629 #ifndef NO_MALLINFO

   630 #define NO_MALLINFO 0

   631 #endif  /* NO_MALLINFO */

   632 #ifndef MALLINFO_FIELD_TYPE

   633 #define MALLINFO_FIELD_TYPE size_t

   634 #endif  /* MALLINFO_FIELD_TYPE */

   635 #ifndef NO_SEGMENT_TRAVERSAL

   636 #define NO_SEGMENT_TRAVERSAL 0

   637 #endif /* NO_SEGMENT_TRAVERSAL */

   638 

   639 /*

   640   mallopt tuning options.  SVID/XPG defines four standard parameter

   641   numbers for mallopt, normally defined in malloc.h.  None of these

   642   are used in this malloc, so setting them has no effect. But this

   643   malloc does support the following options.

   644 */

   645 

   646 #define M_TRIM_THRESHOLD     (-1)

   647 #define M_GRANULARITY        (-2)

   648 #define M_MMAP_THRESHOLD     (-3)

   649 

   650 /* ------------------------ Mallinfo declarations ------------------------ */

   651 

   652 #if !NO_MALLINFO

   653 /*

   654   This version of malloc supports the standard SVID/XPG mallinfo

   655   routine that returns a struct containing usage properties and

   656   statistics. It should work on any system that has a

   657   /usr/include/malloc.h defining struct mallinfo.  The main

   658   declaration needed is the mallinfo struct that is returned (by-copy)

   659   by mallinfo().  The malloinfo struct contains a bunch of fields that

   660   are not even meaningful in this version of malloc.  These fields are

   661   are instead filled by mallinfo() with other numbers that might be of

   662   interest.

   663 

   664   HAVE_USR_INCLUDE_MALLOC_H should be set if you have a

   665   /usr/include/malloc.h file that includes a declaration of struct

   666   mallinfo.  If so, it is included; else a compliant version is

   667   declared below.  These must be precisely the same for mallinfo() to

   668   work.  The original SVID version of this struct, defined on most

   669   systems with mallinfo, declares all fields as ints. But some others

   670   define as unsigned long. If your system defines the fields using a

   671   type of different width than listed here, you MUST #include your

   672   system version and #define HAVE_USR_INCLUDE_MALLOC_H.

   673 */

   674 

   675 /* #define HAVE_USR_INCLUDE_MALLOC_H */

   676 

   677 #ifdef HAVE_USR_INCLUDE_MALLOC_H

   678 #include "/usr/include/malloc.h"

   679 #else /* HAVE_USR_INCLUDE_MALLOC_H */

   680 

   681 struct mallinfo {

   682   MALLINFO_FIELD_TYPE arena;    /* non-mmapped space allocated from system */

   683   MALLINFO_FIELD_TYPE ordblks;  /* number of free chunks */

   684   MALLINFO_FIELD_TYPE smblks;   /* always 0 */

   685   MALLINFO_FIELD_TYPE hblks;    /* always 0 */

   686   MALLINFO_FIELD_TYPE hblkhd;   /* space in mmapped regions */

   687   MALLINFO_FIELD_TYPE usmblks;  /* maximum total allocated space */

   688   MALLINFO_FIELD_TYPE fsmblks;  /* always 0 */

   689   MALLINFO_FIELD_TYPE uordblks; /* total allocated space */

   690   MALLINFO_FIELD_TYPE fordblks; /* total free space */

   691   MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */

   692 };

   693 

   694 #endif /* HAVE_USR_INCLUDE_MALLOC_H */

   695 #endif /* NO_MALLINFO */

   696 

   697 /*

   698   Try to persuade compilers to inline. The most critical functions for

   699   inlining are defined as macros, so these aren't used for them.

   700 */

   701 

   702 #ifndef FORCEINLINE

   703   #if defined(__GNUC__)

   704 #define FORCEINLINE __inline __attribute__ ((always_inline))

   705   #elif defined(_MSC_VER)

   706     #define FORCEINLINE __forceinline

   707   #endif

   708 #endif

   709 #ifndef NOINLINE

   710   #if defined(__GNUC__)

   711     #define NOINLINE __attribute__ ((noinline))

   712   #elif defined(_MSC_VER)

   713     #define NOINLINE __declspec(noinline)

   714   #else

   715     #define NOINLINE

   716   #endif

   717 #endif

   718 

   719 #ifdef __cplusplus

   720 extern "C" {

   721 #ifndef FORCEINLINE

   722  #define FORCEINLINE inline

   723 #endif

   724 #endif /* __cplusplus */

   725 #ifndef FORCEINLINE

   726  #define FORCEINLINE

   727 #endif

   728 

   729 #if !ONLY_MSPACES

   730 

   731 /* ------------------- Declarations of public routines ------------------- */

   732 

   733 #ifndef USE_DL_PREFIX

   734 #define dlcalloc               calloc

   735 #define dlfree                 free

   736 #define dlmalloc               malloc

   737 #define dlmemalign             memalign

   738 #define dlrealloc              realloc

   739 #define dlvalloc               valloc

   740 #define dlpvalloc              pvalloc

   741 #define dlmallinfo             mallinfo

   742 #define dlmallopt              mallopt

   743 #define dlmalloc_trim          malloc_trim

   744 #define dlmalloc_stats         malloc_stats

   745 #define dlmalloc_usable_size   malloc_usable_size

   746 #define dlmalloc_footprint     malloc_footprint

   747 #define dlmalloc_max_footprint malloc_max_footprint

   748 #define dlindependent_calloc   independent_calloc

   749 #define dlindependent_comalloc independent_comalloc

   750 #endif /* USE_DL_PREFIX */

   751 

   752 

   753 /*

   754   malloc(size_t n)

   755   Returns a pointer to a newly allocated chunk of at least n bytes, or

   756   null if no space is available, in which case errno is set to ENOMEM

   757   on ANSI C systems.

   758 

   759   If n is zero, malloc returns a minimum-sized chunk. (The minimum

   760   size is 16 bytes on most 32bit systems, and 32 bytes on 64bit

   761   systems.)  Note that size_t is an unsigned type, so calls with

   762   arguments that would be negative if signed are interpreted as

   763   requests for huge amounts of space, which will often fail. The

   764   maximum supported value of n differs across systems, but is in all

   765   cases less than the maximum representable value of a size_t.

   766 */

   767 void* dlmalloc(size_t);

   768 

   769 /*

   770   free(void* p)

   771   Releases the chunk of memory pointed to by p, that had been previously

   772   allocated using malloc or a related routine such as realloc.

   773   It has no effect if p is null. If p was not malloced or already

   774   freed, free(p) will by default cause the current program to abort.

   775 */

   776 void  dlfree(void*);

   777 

   778 /*

   779   calloc(size_t n_elements, size_t element_size);

   780   Returns a pointer to n_elements * element_size bytes, with all locations

   781   set to zero.

   782 */

   783 void* dlcalloc(size_t, size_t);

   784 

   785 /*

   786   realloc(void* p, size_t n)

   787   Returns a pointer to a chunk of size n that contains the same data

   788   as does chunk p up to the minimum of (n, p's size) bytes, or null

   789   if no space is available.

   790 

   791   The returned pointer may or may not be the same as p. The algorithm

   792   prefers extending p in most cases when possible, otherwise it

   793   employs the equivalent of a malloc-copy-free sequence.

   794 

   795   If p is null, realloc is equivalent to malloc.

   796 

   797   If space is not available, realloc returns null, errno is set (if on

   798   ANSI) and p is NOT freed.

   799 

   800   if n is for fewer bytes than already held by p, the newly unused

   801   space is lopped off and freed if possible.  realloc with a size

   802   argument of zero (re)allocates a minimum-sized chunk.

   803 

   804   The old unix realloc convention of allowing the last-free'd chunk

   805   to be used as an argument to realloc is not supported.

   806 */

   807 

   808 void* dlrealloc(void*, size_t);

   809 

   810 /*

   811   memalign(size_t alignment, size_t n);

   812   Returns a pointer to a newly allocated chunk of n bytes, aligned

   813   in accord with the alignment argument.

   814 

   815   The alignment argument should be a power of two. If the argument is

   816   not a power of two, the nearest greater power is used.

   817   8-byte alignment is guaranteed by normal malloc calls, so don't

   818   bother calling memalign with an argument of 8 or less.

   819 

   820   Overreliance on memalign is a sure way to fragment space.

   821 */

   822 void* dlmemalign(size_t, size_t);

   823 

   824 /*

   825   valloc(size_t n);

   826   Equivalent to memalign(pagesize, n), where pagesize is the page

   827   size of the system. If the pagesize is unknown, 4096 is used.

   828 */

   829 void* dlvalloc(size_t);

   830 

   831 /*

   832   mallopt(int parameter_number, int parameter_value)

   833   Sets tunable parameters The format is to provide a

   834   (parameter-number, parameter-value) pair.  mallopt then sets the

   835   corresponding parameter to the argument value if it can (i.e., so

   836   long as the value is meaningful), and returns 1 if successful else

   837   0.  SVID/XPG/ANSI defines four standard param numbers for mallopt,

   838   normally defined in malloc.h.  None of these are use in this malloc,

   839   so setting them has no effect. But this malloc also supports other

   840   options in mallopt. See below for details.  Briefly, supported

   841   parameters are as follows (listed defaults are for "typical"

   842   configurations).

   843 

   844   Symbol            param #  default    allowed param values

   845   M_TRIM_THRESHOLD     -1   2*1024*1024   any   (MAX_SIZE_T disables)

   846   M_GRANULARITY        -2     page size   any power of 2 >= page size

   847   M_MMAP_THRESHOLD     -3      256*1024   any   (or 0 if no MMAP support)

   848 */

   849 int dlmallopt(int, int);

   850 

   851 /*

   852   malloc_footprint();

   853   Returns the number of bytes obtained from the system.  The total

   854   number of bytes allocated by malloc, realloc etc., is less than this

   855   value. Unlike mallinfo, this function returns only a precomputed

   856   result, so can be called frequently to monitor memory consumption.

   857   Even if locks are otherwise defined, this function does not use them,

   858   so results might not be up to date.

   859 */

   860 size_t dlmalloc_footprint(void);

   861 

   862 /*

   863   malloc_max_footprint();

   864   Returns the maximum number of bytes obtained from the system. This

   865   value will be greater than current footprint if deallocated space

   866   has been reclaimed by the system. The peak number of bytes allocated

   867   by malloc, realloc etc., is less than this value. Unlike mallinfo,

   868   this function returns only a precomputed result, so can be called

   869   frequently to monitor memory consumption.  Even if locks are

   870   otherwise defined, this function does not use them, so results might

   871   not be up to date.

   872 */

   873 size_t dlmalloc_max_footprint(void);

   874 

   875 #if !NO_MALLINFO

   876 /*

   877   mallinfo()

   878   Returns (by copy) a struct containing various summary statistics:

   879 

   880   arena:     current total non-mmapped bytes allocated from system

   881   ordblks:   the number of free chunks

   882   smblks:    always zero.

   883   hblks:     current number of mmapped regions

   884   hblkhd:    total bytes held in mmapped regions

   885   usmblks:   the maximum total allocated space. This will be greater

   886                 than current total if trimming has occurred.

   887   fsmblks:   always zero

   888   uordblks:  current total allocated space (normal or mmapped)

   889   fordblks:  total free space

   890   keepcost:  the maximum number of bytes that could ideally be released

   891                back to system via malloc_trim. ("ideally" means that

   892                it ignores page restrictions etc.)

   893 

   894   Because these fields are ints, but internal bookkeeping may

   895   be kept as longs, the reported values may wrap around zero and

   896   thus be inaccurate.

   897 */

   898 struct mallinfo dlmallinfo(void);

   899 #endif /* NO_MALLINFO */

   900 

   901 /*

   902   independent_calloc(size_t n_elements, size_t element_size, void* chunks[]);

   903 

   904   independent_calloc is similar to calloc, but instead of returning a

   905   single cleared space, it returns an array of pointers to n_elements

   906   independent elements that can hold contents of size elem_size, each

   907   of which starts out cleared, and can be independently freed,

   908   realloc'ed etc. The elements are guaranteed to be adjacently

   909   allocated (this is not guaranteed to occur with multiple callocs or

   910   mallocs), which may also improve cache locality in some

   911   applications.

   912 

   913   The "chunks" argument is optional (i.e., may be null, which is

   914   probably the most typical usage). If it is null, the returned array

   915   is itself dynamically allocated and should also be freed when it is

   916   no longer needed. Otherwise, the chunks array must be of at least

   917   n_elements in length. It is filled in with the pointers to the

   918   chunks.

   919 

   920   In either case, independent_calloc returns this pointer array, or

   921   null if the allocation failed.  If n_elements is zero and "chunks"

   922   is null, it returns a chunk representing an array with zero elements

   923   (which should be freed if not wanted).

   924 

   925   Each element must be individually freed when it is no longer

   926   needed. If you'd like to instead be able to free all at once, you

   927   should instead use regular calloc and assign pointers into this

   928   space to represent elements.  (In this case though, you cannot

   929   independently free elements.)

   930 

   931   independent_calloc simplifies and speeds up implementations of many

   932   kinds of pools.  It may also be useful when constructing large data

   933   structures that initially have a fixed number of fixed-sized nodes,

   934   but the number is not known at compile time, and some of the nodes

   935   may later need to be freed. For example:

   936 

   937   struct Node { int item; struct Node* next; };

   938 

   939   struct Node* build_list() {

   940     struct Node** pool;

   941     int n = read_number_of_nodes_needed();

   942     if (n <= 0) return 0;

   943     pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);

   944     if (pool == 0) die();

   945     // organize into a linked list...

   946     struct Node* first = pool[0];

   947     for (i = 0; i < n-1; ++i)

   948       pool[i]->next = pool[i+1];

   949     free(pool);     // Can now free the array (or not, if it is needed later)

   950     return first;

   951   }

   952 */

   953 void** dlindependent_calloc(size_t, size_t, void**);

   954 

   955 /*

   956   independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]);

   957 

   958   independent_comalloc allocates, all at once, a set of n_elements

   959   chunks with sizes indicated in the "sizes" array.    It returns

   960   an array of pointers to these elements, each of which can be

   961   independently freed, realloc'ed etc. The elements are guaranteed to

   962   be adjacently allocated (this is not guaranteed to occur with

   963   multiple callocs or mallocs), which may also improve cache locality

   964   in some applications.

   965 

   966   The "chunks" argument is optional (i.e., may be null). If it is null

   967   the returned array is itself dynamically allocated and should also

   968   be freed when it is no longer needed. Otherwise, the chunks array

   969   must be of at least n_elements in length. It is filled in with the

   970   pointers to the chunks.

   971 

   972   In either case, independent_comalloc returns this pointer array, or

   973   null if the allocation failed.  If n_elements is zero and chunks is

   974   null, it returns a chunk representing an array with zero elements

   975   (which should be freed if not wanted).

   976 

   977   Each element must be individually freed when it is no longer

   978   needed. If you'd like to instead be able to free all at once, you

   979   should instead use a single regular malloc, and assign pointers at

   980   particular offsets in the aggregate space. (In this case though, you

   981   cannot independently free elements.)

   982 

   983   independent_comallac differs from independent_calloc in that each

   984   element may have a different size, and also that it does not

   985   automatically clear elements.

   986 

   987   independent_comalloc can be used to speed up allocation in cases

   988   where several structs or objects must always be allocated at the

   989   same time.  For example:

   990 

   991   struct Head { ... }

   992   struct Foot { ... }

   993 

   994   void send_message(char* msg) {

   995     int msglen = strlen(msg);

   996     size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };

   997     void* chunks[3];

   998     if (independent_comalloc(3, sizes, chunks) == 0)

   999       die();

  1000     struct Head* head = (struct Head*)(chunks[0]);

  1001     char*        body = (char*)(chunks[1]);

  1002     struct Foot* foot = (struct Foot*)(chunks[2]);

  1003     // ...

  1004   }

  1005 

  1006   In general though, independent_comalloc is worth using only for

  1007   larger values of n_elements. For small values, you probably won't

  1008   detect enough difference from series of malloc calls to bother.

  1009 

  1010   Overuse of independent_comalloc can increase overall memory usage,

  1011   since it cannot reuse existing noncontiguous small chunks that

  1012   might be available for some of the elements.

  1013 */

  1014 void** dlindependent_comalloc(size_t, size_t*, void**);

  1015 

  1016 

  1017 /*

  1018   pvalloc(size_t n);

  1019   Equivalent to valloc(minimum-page-that-holds(n)), that is,

  1020   round up n to nearest pagesize.

  1021  */

  1022 void*  dlpvalloc(size_t);

  1023 

  1024 /*

  1025   malloc_trim(size_t pad);

  1026 

  1027   If possible, gives memory back to the system (via negative arguments

  1028   to sbrk) if there is unused memory at the `high' end of the malloc

  1029   pool or in unused MMAP segments. You can call this after freeing

  1030   large blocks of memory to potentially reduce the system-level memory

  1031   requirements of a program. However, it cannot guarantee to reduce

  1032   memory. Under some allocation patterns, some large free blocks of

  1033   memory will be locked between two used chunks, so they cannot be

  1034   given back to the system.

  1035 

  1036   The `pad' argument to malloc_trim represents the amount of free

  1037   trailing space to leave untrimmed. If this argument is zero, only

  1038   the minimum amount of memory to maintain internal data structures

  1039   will be left. Non-zero arguments can be supplied to maintain enough

  1040   trailing space to service future expected allocations without having

  1041   to re-obtain memory from the system.

  1042 

  1043   Malloc_trim returns 1 if it actually released any memory, else 0.

  1044 */

  1045 int  dlmalloc_trim(size_t);

  1046 

  1047 /*

  1048   malloc_usable_size(void* p);

  1049 

  1050   Returns the number of bytes you can actually use in

  1051   an allocated chunk, which may be more than you requested (although

  1052   often not) due to alignment and minimum size constraints.

  1053   You can use this many bytes without worrying about

  1054   overwriting other allocated objects. This is not a particularly great

  1055   programming practice. malloc_usable_size can be more useful in

  1056   debugging and assertions, for example:

  1057 

  1058   p = malloc(n);

  1059   assert(malloc_usable_size(p) >= 256);

  1060 */

  1061 size_t dlmalloc_usable_size(void*);

  1062 

  1063 /*

  1064   malloc_stats();

  1065   Prints on stderr the amount of space obtained from the system (both

  1066   via sbrk and mmap), the maximum amount (which may be more than

  1067   current if malloc_trim and/or munmap got called), and the current

  1068   number of bytes allocated via malloc (or realloc, etc) but not yet

  1069   freed. Note that this is the number of bytes allocated, not the

  1070   number requested. It will be larger than the number requested

  1071   because of alignment and bookkeeping overhead. Because it includes

  1072   alignment wastage as being in use, this figure may be greater than

  1073   zero even when no user-level chunks are allocated.

  1074 

  1075   The reported current and maximum system memory can be inaccurate if

  1076   a program makes other calls to system memory allocation functions

  1077   (normally sbrk) outside of malloc.

  1078 

  1079   malloc_stats prints only the most commonly interesting statistics.

  1080   More information can be obtained by calling mallinfo.

  1081 */

  1082 void  dlmalloc_stats(void);

  1083 

  1084 #endif /* ONLY_MSPACES */

  1085 

  1086 #if MSPACES

  1087 

  1088 /*

  1089   mspace is an opaque type representing an independent

  1090   region of space that supports mspace_malloc, etc.

  1091 */

  1092 typedef void* mspace;

  1093 

  1094 /*

  1095   create_mspace creates and returns a new independent space with the

  1096   given initial capacity, or, if 0, the default granularity size.  It

  1097   returns null if there is no system memory available to create the

  1098   space.  If argument locked is non-zero, the space uses a separate

  1099   lock to control access. The capacity of the space will grow

  1100   dynamically as needed to service mspace_malloc requests.  You can

  1101   control the sizes of incremental increases of this space by

  1102   compiling with a different DEFAULT_GRANULARITY or dynamically

  1103   setting with mallopt(M_GRANULARITY, value).

  1104 */

  1105 mspace create_mspace(size_t capacity, int locked);

  1106 

  1107 /*

  1108   destroy_mspace destroys the given space, and attempts to return all

  1109   of its memory back to the system, returning the total number of

  1110   bytes freed. After destruction, the results of access to all memory

  1111   used by the space become undefined.

  1112 */

  1113 size_t destroy_mspace(mspace msp);

  1114 

  1115 /*

  1116   create_mspace_with_base uses the memory supplied as the initial base

  1117   of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this

  1118   space is used for bookkeeping, so the capacity must be at least this

  1119   large. (Otherwise 0 is returned.) When this initial space is

  1120   exhausted, additional memory will be obtained from the system.

  1121   Destroying this space will deallocate all additionally allocated

  1122   space (if possible) but not the initial base.

  1123 */

  1124 mspace create_mspace_with_base(void* base, size_t capacity, int locked);

  1125 

  1126 /*

  1127   mspace_malloc behaves as malloc, but operates within

  1128   the given space.

  1129 */

  1130 void* mspace_malloc(mspace msp, size_t bytes);

  1131 

  1132 /*

  1133   mspace_free behaves as free, but operates within

  1134   the given space.

  1135