Next: Elision Tunables, Previous: Tunable names, Up: Tunables [Contents][Index]
Memory allocation behavior can be modified by setting any of the
following tunables in the malloc namespace:
This tunable supersedes the MALLOC_CHECK_ environment variable and is
identical in features.
Setting this tunable to a non-zero value enables a special (less efficient) memory allocator for the malloc family of functions that is designed to be tolerant against simple errors such as double calls of free with the same argument, or overruns of a single byte (off-by-one bugs). Not all such errors can be protected against, however, and memory leaks can result. Any detected heap corruption results in immediate termination of the process.
Like MALLOC_CHECK_, glibc.malloc.check has a problem in that it
diverges from normal program behavior by writing to stderr, which could
by exploited in SUID and SGID binaries. Therefore, glibc.malloc.check
is disabled by default for SUID and SGID binaries. This can be enabled again
by the system administrator by adding a file /etc/suid-debug; the
content of the file could be anything or even empty.
This tunable supersedes the MALLOC_TOP_PAD_ environment variable and is
identical in features.
This tunable determines the amount of extra memory in bytes to obtain from the system when any of the arenas need to be extended. It also specifies the number of bytes to retain when shrinking any of the arenas. This provides the necessary hysteresis in heap size such that excessive amounts of system calls can be avoided.
The default value of this tunable is ‘0’.
This tunable supersedes the MALLOC_PERTURB_ environment variable and is
identical in features.
If set to a non-zero value, memory blocks are initialized with values depending on some low order bits of this tunable when they are allocated (except when allocated by calloc) and freed. This can be used to debug the use of uninitialized or freed heap memory. Note that this option does not guarantee that the freed block will have any specific values. It only guarantees that the content the block had before it was freed will be overwritten.
The default value of this tunable is ‘0’.
This tunable supersedes the MALLOC_MMAP_THRESHOLD_ environment variable
and is identical in features.
When this tunable is set, all chunks larger than this value in bytes are
allocated outside the normal heap, using the mmap system call. This way
it is guaranteed that the memory for these chunks can be returned to the system
on free. Note that requests smaller than this threshold might still be
allocated via mmap.
If this tunable is not set, the default value is set to ‘131072’ bytes and the threshold is adjusted dynamically to suit the allocation patterns of the program. If the tunable is set, the dynamic adjustment is disabled and the value is set as static.
This tunable supersedes the MALLOC_TRIM_THRESHOLD_ environment variable
and is identical in features.
The value of this tunable is the minimum size (in bytes) of the top-most, releasable chunk in an arena that will trigger a system call in order to return memory to the system from that arena.
If this tunable is not set, the default value is set as 128 KB and the threshold is adjusted dynamically to suit the allocation patterns of the program. If the tunable is set, the dynamic adjustment is disabled and the value is set as static.
This tunable supersedes the MALLOC_MMAP_MAX_ environment variable and is
identical in features.
The value of this tunable is maximum number of chunks to allocate with
mmap. Setting this to zero disables all use of mmap.
The default value of this tunable is ‘65536’.
This tunable supersedes the MALLOC_ARENA_TEST environment variable and is
identical in features.
The glibc.malloc.arena_test tunable specifies the number of arenas that
can be created before the test on the limit to the number of arenas is
conducted. The value is ignored if glibc.malloc.arena_max is set.
The default value of this tunable is 2 for 32-bit systems and 8 for 64-bit systems.
This tunable supersedes the MALLOC_ARENA_MAX environment variable and is
identical in features.
This tunable sets the number of arenas to use in a process regardless of the number of cores in the system.
The default value of this tunable is 0, meaning that the limit on the
number of arenas is determined by the number of CPU cores online. For 32-bit
systems the limit is twice the number of cores online and on 64-bit systems, it
is 8 times the number of cores online.
The maximum size of a request (in bytes) which may be met via the per-thread cache. The default (and maximum) value is 1032 bytes on 64-bit systems and 516 bytes on 32-bit systems.
The maximum number of chunks of each size to cache. The default is 7. The upper limit is 65535. If set to zero, the per-thread cache is effectively disabled.
The approximate maximum overhead of the per-thread cache is thus equal to the number of bins times the chunk count in each bin times the size of each chunk. With defaults, the approximate maximum overhead of the per-thread cache is approximately 236 KB on 64-bit systems and 118 KB on 32-bit systems.
When the user requests memory and the request cannot be met via the per-thread cache, the arenas are used to meet the request. At this time, additional chunks will be moved from existing arena lists to pre-fill the corresponding cache. While copies from the fastbins, smallbins, and regular bins are bounded and predictable due to the bin sizes, copies from the unsorted bin are not bounded, and incur additional time penalties as they need to be sorted as they’re scanned. To make scanning the unsorted list more predictable and bounded, the user may set this tunable to limit the number of chunks that are scanned from the unsorted list while searching for chunks to pre-fill the per-thread cache with. The default, or when set to zero, is no limit.
Next: Elision Tunables, Previous: Tunable names, Up: Tunables [Contents][Index]