modules/ims_qos: added patch for flow-description bug when request originates from...
[sip-router] / mem / dl_malloc.h
1 /*
2   Default header file for malloc-2.8.x, written by Doug Lea
3   and released to the public domain, as explained at
4   http://creativecommons.org/licenses/publicdomain. 
5  
6   last update: Mon Aug 15 08:55:52 2005  Doug Lea  (dl at gee)
7
8   This header is for ANSI C/C++ only.  You can set any of
9   the following #defines before including:
10
11   * If USE_DL_PREFIX is defined, it is assumed that malloc.c 
12     was also compiled with this option, so all routines
13     have names starting with "dl".
14
15   * If HAVE_USR_INCLUDE_MALLOC_H is defined, it is assumed that this
16     file will be #included AFTER <malloc.h>. This is needed only if
17     your system defines a struct mallinfo that is incompatible with the
18     standard one declared here.  Otherwise, you can include this file
19     INSTEAD of your system system <malloc.h>.  At least on ANSI, all
20     declarations should be compatible with system versions
21
22   * If MSPACES is defined, declarations for mspace versions are included.
23 */
24
25 #ifndef MALLOC_280_H
26 #define MALLOC_280_H
27
28 #include "dl_config.h"
29 #include "meminfo.h"
30
31 #ifdef __cplusplus
32 extern "C" {
33 #endif
34
35 #include <stddef.h>   /* for size_t */
36
37 #if !ONLY_MSPACES
38
39 #ifndef USE_DL_PREFIX
40 #define dlcalloc               calloc
41 #define dlfree                 free
42 #define dlmalloc               malloc
43 #define dlmemalign             memalign
44 #define dlrealloc              realloc
45 #define dlvalloc               valloc
46 #define dlpvalloc              pvalloc
47 #define dlmallinfo             mallinfo
48 #define dlmallopt              mallopt
49 #define dlmalloc_trim          malloc_trim
50 #define dlmalloc_stats         malloc_stats
51 #define dlmalloc_usable_size   malloc_usable_size
52 #define dlmalloc_footprint     malloc_footprint
53 #define dlindependent_calloc   independent_calloc
54 #define dlindependent_comalloc independent_comalloc
55 #endif /* USE_DL_PREFIX */
56
57
58 /*
59   malloc(size_t n)
60   Returns a pointer to a newly allocated chunk of at least n bytes, or
61   null if no space is available, in which case errno is set to ENOMEM
62   on ANSI C systems.
63
64   If n is zero, malloc returns a minimum-sized chunk. (The minimum
65   size is 16 bytes on most 32bit systems, and 32 bytes on 64bit
66   systems.)  Note that size_t is an unsigned type, so calls with
67   arguments that would be negative if signed are interpreted as
68   requests for huge amounts of space, which will often fail. The
69   maximum supported value of n differs across systems, but is in all
70   cases less than the maximum representable value of a size_t.
71 */
72 void* dlmalloc(size_t);
73
74 /*
75   free(void* p)
76   Releases the chunk of memory pointed to by p, that had been previously
77   allocated using malloc or a related routine such as realloc.
78   It has no effect if p is null. If p was not malloced or already
79   freed, free(p) will by default cuase the current program to abort.
80 */
81 void  dlfree(void*);
82
83 /*
84   calloc(size_t n_elements, size_t element_size);
85   Returns a pointer to n_elements * element_size bytes, with all locations
86   set to zero.
87 */
88 void* dlcalloc(size_t, size_t);
89
90 /*
91   realloc(void* p, size_t n)
92   Returns a pointer to a chunk of size n that contains the same data
93   as does chunk p up to the minimum of (n, p's size) bytes, or null
94   if no space is available.
95
96   The returned pointer may or may not be the same as p. The algorithm
97   prefers extending p in most cases when possible, otherwise it
98   employs the equivalent of a malloc-copy-free sequence.
99
100   If p is null, realloc is equivalent to malloc.
101
102   If space is not available, realloc returns null, errno is set (if on
103   ANSI) and p is NOT freed.
104
105   if n is for fewer bytes than already held by p, the newly unused
106   space is lopped off and freed if possible.  realloc with a size
107   argument of zero (re)allocates a minimum-sized chunk.
108
109   The old unix realloc convention of allowing the last-free'd chunk
110   to be used as an argument to realloc is not supported.
111 */
112
113 void* dlrealloc(void*, size_t);
114
115 /*
116   memalign(size_t alignment, size_t n);
117   Returns a pointer to a newly allocated chunk of n bytes, aligned
118   in accord with the alignment argument.
119
120   The alignment argument should be a power of two. If the argument is
121   not a power of two, the nearest greater power is used.
122   8-byte alignment is guaranteed by normal malloc calls, so don't
123   bother calling memalign with an argument of 8 or less.
124
125   Overreliance on memalign is a sure way to fragment space.
126 */
127 void* dlmemalign(size_t, size_t);
128
129 /*
130   valloc(size_t n);
131   Equivalent to memalign(pagesize, n), where pagesize is the page
132   size of the system. If the pagesize is unknown, 4096 is used.
133 */
134 void* dlvalloc(size_t);
135
136 /*
137   mallopt(int parameter_number, int parameter_value)
138   Sets tunable parameters The format is to provide a
139   (parameter-number, parameter-value) pair.  mallopt then sets the
140   corresponding parameter to the argument value if it can (i.e., so
141   long as the value is meaningful), and returns 1 if successful else
142   0.  SVID/XPG/ANSI defines four standard param numbers for mallopt,
143   normally defined in malloc.h.  None of these are use in this malloc,
144   so setting them has no effect. But this malloc also supports other
145   options in mallopt:
146
147   Symbol            param #  default    allowed param values
148   M_TRIM_THRESHOLD     -1   2*1024*1024   any   (-1U disables trimming)
149   M_GRANULARITY        -2     page size   any power of 2 >= page size
150   M_MMAP_THRESHOLD     -3      256*1024   any   (or 0 if no MMAP support)
151 */
152 int dlmallopt(int, int);
153
154 #define M_TRIM_THRESHOLD     (-1)
155 #define M_GRANULARITY        (-2)
156 #define M_MMAP_THRESHOLD     (-3)
157
158
159 /*
160   malloc_footprint();
161   Returns the number of bytes obtained from the system.  The total
162   number of bytes allocated by malloc, realloc etc., is less than this
163   value. Unlike mallinfo, this function returns only a precomputed
164   result, so can be called frequently to monitor memory consumption.
165   Even if locks are otherwise defined, this function does not use them,
166   so results might not be up to date.
167 */
168 size_t dlmalloc_footprint();
169
170 #if !NO_MALLINFO
171 /*
172   mallinfo()
173   Returns (by copy) a struct containing various summary statistics:
174
175   arena:     current total non-mmapped bytes allocated from system
176   ordblks:   the number of free chunks
177   smblks:    always zero.
178   hblks:     current number of mmapped regions
179   hblkhd:    total bytes held in mmapped regions
180   usmblks:   the maximum total allocated space. This will be greater
181                 than current total if trimming has occurred.
182   fsmblks:   always zero
183   uordblks:  current total allocated space (normal or mmapped)
184   fordblks:  total free space
185   keepcost:  the maximum number of bytes that could ideally be released
186                back to system via malloc_trim. ("ideally" means that
187                it ignores page restrictions etc.)
188
189   Because these fields are ints, but internal bookkeeping may
190   be kept as longs, the reported values may wrap around zero and
191   thus be inaccurate.
192 */
193 #ifndef HAVE_USR_INCLUDE_MALLOC_H
194 #ifndef _MALLOC_H
195 #ifndef MALLINFO_FIELD_TYPE
196 #define MALLINFO_FIELD_TYPE size_t
197 #endif /* MALLINFO_FIELD_TYPE */
198 struct mallinfo {
199   MALLINFO_FIELD_TYPE arena;    /* non-mmapped space allocated from system */
200   MALLINFO_FIELD_TYPE ordblks;  /* number of free chunks */
201   MALLINFO_FIELD_TYPE smblks;   /* always 0 */
202   MALLINFO_FIELD_TYPE hblks;    /* always 0 */
203   MALLINFO_FIELD_TYPE hblkhd;   /* space in mmapped regions */
204   MALLINFO_FIELD_TYPE usmblks;  /* maximum total allocated space */
205   MALLINFO_FIELD_TYPE fsmblks;  /* always 0 */
206   MALLINFO_FIELD_TYPE uordblks; /* total allocated space */
207   MALLINFO_FIELD_TYPE fordblks; /* total free space */
208   MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */
209 };
210 #endif  /* _MALLOC_H */
211 #endif  /* HAVE_USR_INCLUDE_MALLOC_H */
212
213 struct mallinfo dlmallinfo(void);
214 #endif  /* NO_MALLINFO */
215
216 /*
217   independent_calloc(size_t n_elements, size_t element_size, void* chunks[]);
218
219   independent_calloc is similar to calloc, but instead of returning a
220   single cleared space, it returns an array of pointers to n_elements
221   independent elements that can hold contents of size elem_size, each
222   of which starts out cleared, and can be independently freed,
223   realloc'ed etc. The elements are guaranteed to be adjacently
224   allocated (this is not guaranteed to occur with multiple callocs or
225   mallocs), which may also improve cache locality in some
226   applications.
227
228   The "chunks" argument is optional (i.e., may be null, which is
229   probably the most typical usage). If it is null, the returned array
230   is itself dynamically allocated and should also be freed when it is
231   no longer needed. Otherwise, the chunks array must be of at least
232   n_elements in length. It is filled in with the pointers to the
233   chunks.
234
235   In either case, independent_calloc returns this pointer array, or
236   null if the allocation failed.  If n_elements is zero and "chunks"
237   is null, it returns a chunk representing an array with zero elements
238   (which should be freed if not wanted).
239
240   Each element must be individually freed when it is no longer
241   needed. If you'd like to instead be able to free all at once, you
242   should instead use regular calloc and assign pointers into this
243   space to represent elements.  (In this case though, you cannot
244   independently free elements.)
245
246   independent_calloc simplifies and speeds up implementations of many
247   kinds of pools.  It may also be useful when constructing large data
248   structures that initially have a fixed number of fixed-sized nodes,
249   but the number is not known at compile time, and some of the nodes
250   may later need to be freed. For example:
251
252   struct Node { int item; struct Node* next; };
253
254   struct Node* build_list() {
255     struct Node** pool;
256     int n = read_number_of_nodes_needed();
257     if (n <= 0) return 0;
258     pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
259     if (pool == 0) die();
260     // organize into a linked list...
261     struct Node* first = pool[0];
262     for (i = 0; i < n-1; ++i)
263       pool[i]->next = pool[i+1];
264     free(pool);     // Can now free the array (or not, if it is needed later)
265     return first;
266   }
267 */
268 void** dlindependent_calloc(size_t, size_t, void**);
269
270 /*
271   independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]);
272
273   independent_comalloc allocates, all at once, a set of n_elements
274   chunks with sizes indicated in the "sizes" array.    It returns
275   an array of pointers to these elements, each of which can be
276   independently freed, realloc'ed etc. The elements are guaranteed to
277   be adjacently allocated (this is not guaranteed to occur with
278   multiple callocs or mallocs), which may also improve cache locality
279   in some applications.
280
281   The "chunks" argument is optional (i.e., may be null). If it is null
282   the returned array is itself dynamically allocated and should also
283   be freed when it is no longer needed. Otherwise, the chunks array
284   must be of at least n_elements in length. It is filled in with the
285   pointers to the chunks.
286
287   In either case, independent_comalloc returns this pointer array, or
288   null if the allocation failed.  If n_elements is zero and chunks is
289   null, it returns a chunk representing an array with zero elements
290   (which should be freed if not wanted).
291
292   Each element must be individually freed when it is no longer
293   needed. If you'd like to instead be able to free all at once, you
294   should instead use a single regular malloc, and assign pointers at
295   particular offsets in the aggregate space. (In this case though, you
296   cannot independently free elements.)
297
298   independent_comallac differs from independent_calloc in that each
299   element may have a different size, and also that it does not
300   automatically clear elements.
301
302   independent_comalloc can be used to speed up allocation in cases
303   where several structs or objects must always be allocated at the
304   same time.  For example:
305
306   struct Head { ... }
307   struct Foot { ... }
308
309   void send_message(char* msg) {
310     int msglen = strlen(msg);
311     size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
312     void* chunks[3];
313     if (independent_comalloc(3, sizes, chunks) == 0)
314       die();
315     struct Head* head = (struct Head*)(chunks[0]);
316     char*        body = (char*)(chunks[1]);
317     struct Foot* foot = (struct Foot*)(chunks[2]);
318     // ...
319   }
320
321   In general though, independent_comalloc is worth using only for
322   larger values of n_elements. For small values, you probably won't
323   detect enough difference from series of malloc calls to bother.
324
325   Overuse of independent_comalloc can increase overall memory usage,
326   since it cannot reuse existing noncontiguous small chunks that
327   might be available for some of the elements.
328 */
329 void** dlindependent_comalloc(size_t, size_t*, void**);
330
331
332 /*
333   pvalloc(size_t n);
334   Equivalent to valloc(minimum-page-that-holds(n)), that is,
335   round up n to nearest pagesize.
336  */
337 void*  dlpvalloc(size_t);
338
339 /*
340   malloc_trim(size_t pad);
341
342   If possible, gives memory back to the system (via negative arguments
343   to sbrk) if there is unused memory at the `high' end of the malloc
344   pool or in unused MMAP segments. You can call this after freeing
345   large blocks of memory to potentially reduce the system-level memory
346   requirements of a program. However, it cannot guarantee to reduce
347   memory. Under some allocation patterns, some large free blocks of
348   memory will be locked between two used chunks, so they cannot be
349   given back to the system.
350
351   The `pad' argument to malloc_trim represents the amount of free
352   trailing space to leave untrimmed. If this argument is zero, only
353   the minimum amount of memory to maintain internal data structures
354   will be left. Non-zero arguments can be supplied to maintain enough
355   trailing space to service future expected allocations without having
356   to re-obtain memory from the system.
357
358   Malloc_trim returns 1 if it actually released any memory, else 0.
359 */
360 int  dlmalloc_trim(size_t);
361
362 /*
363   malloc_usable_size(void* p);
364
365   Returns the number of bytes you can actually use in
366   an allocated chunk, which may be more than you requested (although
367   often not) due to alignment and minimum size constraints.
368   You can use this many bytes without worrying about
369   overwriting other allocated objects. This is not a particularly great
370   programming practice. malloc_usable_size can be more useful in
371   debugging and assertions, for example:
372
373   p = malloc(n);
374   assert(malloc_usable_size(p) >= 256);
375 */
376 size_t dlmalloc_usable_size(void*);
377
378 /*
379   malloc_stats();
380   Prints on stderr the amount of space obtained from the system (both
381   via sbrk and mmap), the maximum amount (which may be more than
382   current if malloc_trim and/or munmap got called), and the current
383   number of bytes allocated via malloc (or realloc, etc) but not yet
384   freed. Note that this is the number of bytes allocated, not the
385   number requested. It will be larger than the number requested
386   because of alignment and bookkeeping overhead. Because it includes
387   alignment wastage as being in use, this figure may be greater than
388   zero even when no user-level chunks are allocated.
389
390   The reported current and maximum system memory can be inaccurate if
391   a program makes other calls to system memory allocation functions
392   (normally sbrk) outside of malloc.
393
394   malloc_stats prints only the most commonly interesting statistics.
395   More information can be obtained by calling mallinfo.
396 */
397 void  dlmalloc_stats();
398
399 #endif /* !ONLY_MSPACES */
400
401 #if MSPACES
402
403 /*
404   mspace is an opaque type representing an independent
405   region of space that supports mspace_malloc, etc.
406 */
407 typedef void* mspace;
408
409 /*
410   create_mspace creates and returns a new independent space with the
411   given initial capacity, or, if 0, the default granularity size.  It
412   returns null if there is no system memory available to create the
413   space.  If argument locked is non-zero, the space uses a separate
414   lock to control access. The capacity of the space will grow
415   dynamically as needed to service mspace_malloc requests.  You can
416   control the sizes of incremental increases of this space by
417   compiling with a different DEFAULT_GRANULARITY or dynamically
418   setting with mallopt(M_GRANULARITY, value).
419 */
420 mspace create_mspace(size_t capacity, int locked);
421
422 /*
423   destroy_mspace destroys the given space, and attempts to return all
424   of its memory back to the system, returning the total number of
425   bytes freed. After destruction, the results of access to all memory
426   used by the space become undefined.
427 */
428 size_t destroy_mspace(mspace msp);
429
430 /*
431   create_mspace_with_base uses the memory supplied as the initial base
432   of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this
433   space is used for bookkeeping, so the capacity must be at least this
434   large. (Otherwise 0 is returned.) When this initial space is
435   exhausted, additional memory will be obtained from the system.
436   Destroying this space will deallocate all additionally allocated
437   space (if possible) but not the initial base.
438 */
439 mspace create_mspace_with_base(void* base, size_t capacity, int locked);
440
441 /*
442   mspace_malloc behaves as malloc, but operates within
443   the given space.
444 */
445 void* mspace_malloc(mspace msp, size_t bytes);
446
447 /*
448   mspace_free behaves as free, but operates within
449   the given space.
450
451   If compiled with FOOTERS==1, mspace_free is not actually needed.
452   free may be called instead of mspace_free because freed chunks from
453   any space are handled by their originating spaces.
454 */
455 void mspace_free(mspace msp, void* mem);
456
457 /*
458   mspace_realloc behaves as realloc, but operates within
459   the given space.
460
461   If compiled with FOOTERS==1, mspace_realloc is not actually
462   needed.  realloc may be called instead of mspace_realloc because
463   realloced chunks from any space are handled by their originating
464   spaces.
465 */
466 void* mspace_realloc(mspace msp, void* mem, size_t newsize);
467
468 /*
469   mspace_calloc behaves as calloc, but operates within
470   the given space.
471 */
472 void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
473
474 /*
475   mspace_memalign behaves as memalign, but operates within
476   the given space.
477 */
478 void* mspace_memalign(mspace msp, size_t alignment, size_t bytes);
479
480 /*
481   mspace_independent_calloc behaves as independent_calloc, but
482   operates within the given space.
483 */
484 void** mspace_independent_calloc(mspace msp, size_t n_elements,
485                                  size_t elem_size, void* chunks[]);
486
487 /*
488   mspace_independent_comalloc behaves as independent_comalloc, but
489   operates within the given space.
490 */
491 void** mspace_independent_comalloc(mspace msp, size_t n_elements,
492                                    size_t sizes[], void* chunks[]);
493
494 /*
495   mspace_footprint() returns the number of bytes obtained from the
496   system for this space.
497 */
498 size_t mspace_footprint(mspace msp);
499
500
501 #if !NO_MALLINFO
502 /*
503   mspace_mallinfo behaves as mallinfo, but reports properties of
504   the given space.
505 */
506 struct mallinfo mspace_mallinfo(mspace msp);
507 #endif /* NO_MALLINFO */
508
509 /*
510   mspace_malloc_stats behaves as malloc_stats, but reports
511   properties of the given space.
512 */
513 void mspace_malloc_stats(mspace msp);
514
515 /*
516   mspace_trim behaves as malloc_trim, but
517   operates within the given space.
518 */
519 int mspace_trim(mspace msp, size_t pad);
520
521 /*
522   An alias for mallopt.
523 */
524 int mspace_mallopt(int, int);
525
526 void mspace_info(mspace ms, struct mem_info* info);
527
528 #endif  /* MSPACES */
529
530 #ifdef __cplusplus
531 };  /* end of extern "C" */
532 #endif
533
534 #endif /* MALLOC_280_H */