Absolute maximum cache bad fit (in kilobytes). A segment in the memory segment cache is not reused if its size exceeds the requested size with more than the value of this parameter. Defaults to 4096.

Relative maximum cache bad fit (in percent). A segment in the memory segment cache is not reused if its size exceeds the requested size with more than relative maximum cache bad fit percent of the requested size. Defaults to 20.

Sets super carrier only flag. Defaults to true. When a super carrier is used and this flag is true, mseg_alloc only creates carriers in the super carrier. Notice that the alloc_util framework can create sys_alloc carriers, so if you want all carriers to be created in the super carrier, you therefore want to disable use of sys_alloc carriers by also passing +Musac false. When the flag is false, mseg_alloc tries to create carriers outside of the super carrier when the super carrier is full.

Sets super carrier reserved free segment descriptors. Defaults to 65536. This parameter determines the amount of memory to reserve for free segment descriptors used by the super carrier. If the system runs out of reserved memory for free segment descriptors, other memory is used. This can however cause fragmentation issues, so you want to ensure that this never happens. The maximum amount of free segment descriptors used can be retrieved from the erts_mmap tuple part of the result from calling erlang:system_info({allocator, mseg_alloc}).

Sets super carrier reserve physical memory flag. Defaults to true. When this flag is true, physical memory is reserved for the whole super carrier at once when it is created. The reservation is after that left unchanged. When this flag is set to false, only virtual address space is reserved for the super carrier upon creation. The system attempts to reserve physical memory upon carrier creations in the super carrier, and attempt to unreserve physical memory upon carrier destructions in the super carrier.

Sets super carrier size (in MB). Defaults to 0, that is, the super carrier is by default disabled. The super carrier is a large continuous area in the virtual address space. mseg_alloc always tries to create new carriers in the super carrier if it exists. Notice that the alloc_util framework can create sys_alloc carriers. For more information, see +MMsco.

Maximum cached segments. The maximum number of memory segments stored in the memory segment cache. Valid range is [0, 30]. Defaults to 10.

Enables sys_alloc.

malloc library to use. Only libc is available. libc enables the standard libc malloc implementation. By default libc is used.

Trim threshold size (in kilobytes). This is the maximum amount of free memory at the top of the heap (allocated by sbrk) that is kept by malloc (not released to the operating system). When the amount of free memory at the top of the heap exceeds the trim threshold, malloc releases it (by calling sbrk). Trim threshold is specified in kilobytes. Defaults to 128.

Top pad size (in kilobytes). This is the amount of extra memory that is allocated by malloc when sbrk is called to get more memory from the operating system. Defaults to 0.

Abandon carrier utilization limit. A valid ]]> is an integer in the range [0, 100] representing utilization in percent. When a utilization value > 0 is used, allocator instances are allowed to abandon multiblock carriers. If de (default enabled) is passed instead of a ]]>, a recommended non-zero utilization value is used. The value chosen depends on the allocator type and can be changed between ERTS versions. Defaults to de, but this can be changed in the future.

Carriers are abandoned when memory utilization in the allocator instance falls below the utilization value used. Once a carrier is abandoned, no new allocations are made in it. When an allocator instance gets an increased multiblock carrier need, it first tries to fetch an abandoned carrier from an allocator instance of the same allocator type. If no abandoned carrier can be fetched, it creates a new empty carrier. When an abandoned carrier has been fetched, it will function as an ordinary carrier. This feature has special requirements on the allocation strategy used. Only the strategies aoff, aoffcbf, aoffcaobf, ageffcaoffm, ageffcbf and ageffcaobf support abandoned carriers.

This feature also requires multiple thread specific instances to be enabled. When enabling this feature, multiple thread-specific instances are enabled if not already enabled, and the aoffcbf strategy is enabled if the current strategy does not support abandoned carriers. This feature can be enabled on all allocators based on the alloc_util framework, except temp_alloc (which would be pointless).

Abandon carrier free block min limit. A valid ]]> is a positive integer representing a block size limit. The largest free block in a carrier must be at least bytes large, for the carrier to be abandoned. The default is zero but can be changed in the future.

See also acul.

Abandon carrier number limit. A valid ]]> is a positive integer representing max number of abandoned carriers per allocator instance. Defaults to 1000 which will practically disable the limit, but this can be changed in the future.

See also acul.

Allocation strategy. The following strategies are valid:

See the description of allocation strategies in section The alloc_util Framework.

Absolute singleblock carrier shrink threshold (in kilobytes). When a block located in an mseg_alloc singleblock carrier is shrunk, the carrier is left unchanged if the amount of unused memory is less than this threshold, otherwise the carrier is shrunk. See also rsbcst.

Enables allocator ]]>.

Largest (mseg_alloc) multiblock carrier size (in kilobytes). See the description on how sizes for mseg_alloc multiblock carriers are decided in section The alloc_util Framework. On 32-bit Unix style OS this limit cannot be set > 128 MB.

(mseg_alloc) multiblock carrier growth stages. See the description on how sizes for mseg_alloc multiblock carriers are decided in section The alloc_util Framework.

Maximum block search depth. This flag has effect only if the good fit strategy is selected for allocator ]]>. When the good fit strategy is used, free blocks are placed in segregated free-lists. Each free-list contains blocks of sizes in a specific range. The maxiumum block search depth sets a limit on the maximum number of blocks to inspect in a free-list during a search for suitable block satisfying the request.

Main multiblock carrier size. Sets the size of the main multiblock carrier for allocator ]]>. The main multiblock carrier is allocated through and is never deallocated.

Maximum mseg_alloc multiblock carriers. Maximum number of multiblock carriers allocated through mseg_alloc by allocator ]]>. When this limit is reached, new multiblock carriers are allocated through sys_alloc.

Maximum mseg_alloc singleblock carriers. Maximum number of singleblock carriers allocated through mseg_alloc by allocator ]]>. When this limit is reached, new singleblock carriers are allocated through sys_alloc.

Realloc always moves. When enabled, reallocate operations are more or less translated into an allocate, copy, free sequence. This often reduces memory fragmentation, but costs performance.

Relative multiblock carrier move threshold (in percent). When a block located in a multiblock carrier is shrunk, the block is moved if the ratio of the size of the returned memory compared to the previous size is more than this threshold, otherwise the block is shrunk at the current location.

Relative singleblock carrier move threshold (in percent). When a block located in a singleblock carrier is shrunk to a size smaller than the value of parameter sbct, the block is left unchanged in the singleblock carrier if the ratio of unused memory is less than this threshold, otherwise it is moved into a multiblock carrier.

Relative singleblock carrier shrink threshold (in percent). When a block located in an mseg_alloc singleblock carrier is shrunk, the carrier is left unchanged if the ratio of unused memory is less than this threshold, otherwise the carrier is shrunk. See also asbcst.

Singleblock carrier threshold (in kilobytes). Blocks larger than this threshold are placed in singleblock carriers. Blocks smaller than this threshold are placed in multiblock carriers. On 32-bit Unix style OS this threshold cannot be set > 8 MB.

Smallest (mseg_alloc) multiblock carrier size (in kilobytes). See the description on how sizes for mseg_alloc multiblock carriers are decided in section The alloc_util Framework.

Multiple, thread-specific instances of the allocator. This option has only effect on the runtime system with SMP support. Default behavior on the runtime system with SMP support is NoSchedulers+1 instances. Each scheduler uses a lock-free instance of its own and other threads use a common instance.

Before ERTS 5.9 it was possible to configure a smaller number of thread-specific instances than schedulers. This is, however, not possible anymore.

sys_alloc carrier size. Carriers allocated through sys_alloc are allocated in sizes that are multiples of the sys_alloc carrier size. This is not true for main multiblock carriers and carriers allocated during a memory shortage, though.

Maximum mseg_alloc carriers. Maximum number of carriers placed in separate memory segments. When this limit is reached, new carriers are placed in memory retrieved from sys_alloc.

Allow sys_alloc carriers. Defaults to true. If set to false, sys_alloc carriers are never created by allocators using the alloc_util framework.

literal_alloc super carrier size (in MB). The amount of virtual address space reserved for literal terms in Erlang code on 64-bit architectures. Defaults to 1024 (that is, 1 GB), which is usually sufficient. The flag is ignored on 32-bit architectures.

exec_alloc super carrier size (in MB). The amount of virtual address space reserved for native executable code used by the HiPE application on specific architectures (x86_64). Defaults to 512.

A map over current allocations is kept by the emulator. The allocation map can be retrieved through module instrument(3). +Mim true implies +Mis true. +Mim true is the same as flag -instr in erl(1).

Status over allocated memory is kept by the emulator. The allocation status can be retrieved through module instrument(3).

Reserved for future use. Do not use this flag.

Options:

Lock physical memory. Defaults to no, that is, no physical memory is locked. If set to all, all memory mappings made by the runtime system are locked into physical memory. If set to all, the runtime system fails to start if this feature is not supported, the user has not got enough privileges, or the user is not allowed to lock enough physical memory. The runtime system also fails with an out of memory condition if the user limit on the amount of locked memory is reached.