Provided by: erlang-manpages_25.2.3+dfsg-1_all 
NAME
erts_alloc - An Erlang runtime system internal memory allocator library.
DESCRIPTION
erts_alloc is an Erlang runtime system internal memory allocator library. erts_alloc
provides the Erlang runtime system with a number of memory allocators.
ALLOCATORS
The following allocators are present:
temp_alloc:
Allocator used for temporary allocations.
eheap_alloc:
Allocator used for Erlang heap data, such as Erlang process heaps.
binary_alloc:
Allocator used for Erlang binary data.
ets_alloc:
Allocator used for ets data.
driver_alloc:
Allocator used for driver data.
literal_alloc:
Allocator used for constant terms in Erlang code.
sl_alloc:
Allocator used for memory blocks that are expected to be short-lived.
ll_alloc:
Allocator used for memory blocks that are expected to be long-lived, for example,
Erlang code.
fix_alloc:
A fast allocator used for some frequently used fixed size data types.
std_alloc:
Allocator used for most memory blocks not allocated through any of the other
allocators described above.
sys_alloc:
This is normally the default malloc implementation used on the specific OS.
mseg_alloc:
A memory segment allocator. It is used by other allocators for allocating memory
segments and is only available on systems that have the mmap system call. Memory
segments that are deallocated are kept for a while in a segment cache before they are
destroyed. When segments are allocated, cached segments are used if possible instead
of creating new segments. This to reduce the number of system calls made.
sys_alloc, literal_alloc and temp_alloc are always enabled and cannot be disabled.
mseg_alloc is always enabled if it is available and an allocator that uses it is enabled.
All other allocators can be enabled or disabled. By default all allocators are enabled.
When an allocator is disabled, sys_alloc is used instead of the disabled allocator.
The main idea with the erts_alloc library is to separate memory blocks that are used
differently into different memory areas, to achieve less memory fragmentation. By putting
less effort in finding a good fit for memory blocks that are frequently allocated than for
those less frequently allocated, a performance gain can be achieved.
THE ALLOC_UTIL FRAMEWORK
Internally a framework called alloc_util is used for implementing allocators. sys_alloc
and mseg_alloc do not use this framework, so the following does not apply to them.
An allocator manages multiple areas, called carriers, in which memory blocks are placed. A
carrier is either placed in a separate memory segment (allocated through mseg_alloc), or
in the heap segment (allocated through sys_alloc).
* Multiblock carriers are used for storage of several blocks.
* Singleblock carriers are used for storage of one block.
* Blocks that are larger than the value of the singleblock carrier threshold (sbct)
parameter are placed in singleblock carriers.
* Blocks that are smaller than the value of parameter sbct are placed in multiblock
carriers.
Normally an allocator creates a "main multiblock carrier". Main multiblock carriers are
never deallocated. The size of the main multiblock carrier is determined by the value of
parameter mmbcs.
Sizes of multiblock carriers allocated through mseg_alloc are decided based on the
following parameters:
* The values of the largest multiblock carrier size (lmbcs)
* The smallest multiblock carrier size (smbcs)
* The multiblock carrier growth stages (mbcgs)
If nc is the current number of multiblock carriers (the main multiblock carrier excluded)
managed by an allocator, the size of the next mseg_alloc multiblock carrier allocated by
this allocator is roughly smbcs+nc*(lmbcs-smbcs)/mbcgs when nc <= mbcgs, and lmbcs when nc
> mbcgs. If the value of parameter sbct is larger than the value of parameter lmbcs, the
allocator may have to create multiblock carriers that are larger than the value of
parameter lmbcs, though. Singleblock carriers allocated through mseg_alloc are sized to
whole pages.
Sizes of carriers allocated through sys_alloc are decided based on the value of the
sys_alloc carrier size (ycs) parameter. The size of a carrier is the least number of
multiples of the value of parameter ycs satisfying the request.
Coalescing of free blocks are always performed immediately. Boundary tags (headers and
footers) in free blocks are used, which makes the time complexity for coalescing constant.
The memory allocation strategy used for multiblock carriers by an allocator can be
configured using parameter as. The following strategies are available:
Best fit:
Strategy: Find the smallest block satisfying the requested block size.
Implementation: A balanced binary search tree is used. The time complexity is
proportional to log N, where N is the number of sizes of free blocks.
Address order best fit:
Strategy: Find the smallest block satisfying the requested block size. If multiple
blocks are found, choose the one with the lowest address.
Implementation: A balanced binary search tree is used. The time complexity is
proportional to log N, where N is the number of free blocks.
Address order first fit:
Strategy: Find the block with the lowest address satisfying the requested block size.
Implementation: A balanced binary search tree is used. The time complexity is
proportional to log N, where N is the number of free blocks.
Address order first fit carrier best fit:
Strategy: Find the carrier with the lowest address that can satisfy the requested
block size, then find a block within that carrier using the "best fit" strategy.
Implementation: Balanced binary search trees are used. The time complexity is
proportional to log N, where N is the number of free blocks.
Address order first fit carrier address order best fit:
Strategy: Find the carrier with the lowest address that can satisfy the requested
block size, then find a block within that carrier using the "address order best fit"
strategy.
Implementation: Balanced binary search trees are used. The time complexity is
proportional to log N, where N is the number of free blocks.
Age order first fit carrier address order first fit:
Strategy: Find the oldest carrier that can satisfy the requested block size, then find
a block within that carrier using the "address order first fit" strategy.
Implementation: A balanced binary search tree is used. The time complexity is
proportional to log N, where N is the number of free blocks.
Age order first fit carrier best fit:
Strategy: Find the oldest carrier that can satisfy the requested block size, then find
a block within that carrier using the "best fit" strategy.
Implementation: Balanced binary search trees are used. The time complexity is
proportional to log N, where N is the number of free blocks.
Age order first fit carrier address order best fit:
Strategy: Find the oldest carrier that can satisfy the requested block size, then find
a block within that carrier using the "address order best fit" strategy.
Implementation: Balanced binary search trees are used. The time complexity is
proportional to log N, where N is the number of free blocks.
Good fit:
Strategy: Try to find the best fit, but settle for the best fit found during a limited
search.
Implementation: The implementation uses segregated free lists with a maximum block
search depth (in each list) to find a good fit fast. When the maximum block search
depth is small (by default 3), this implementation has a time complexity that is
constant. The maximum block search depth can be configured using parameter mbsd.
A fit:
Strategy: Do not search for a fit, inspect only one free block to see if it satisfies
the request. This strategy is only intended to be used for temporary allocations.
Implementation: Inspect the first block in a free-list. If it satisfies the request,
it is used, otherwise a new carrier is created. The implementation has a time
complexity that is constant.
As from ERTS 5.6.1 the emulator refuses to use this strategy on other allocators than
temp_alloc. This because it only causes problems for other allocators.
Apart from the ordinary allocators described above, some pre-allocators are used for some
specific data types. These pre-allocators pre-allocate a fixed amount of memory for
certain data types when the runtime system starts. As long as pre-allocated memory is
available, it is used. When no pre-allocated memory is available, memory is allocated in
ordinary allocators. These pre-allocators are typically much faster than the ordinary
allocators, but can only satisfy a limited number of requests.
SYSTEM FLAGS EFFECTING ERTS_ALLOC
Warning:
Only use these flags if you are sure what you are doing. Unsuitable settings can cause
serious performance degradation and even a system crash at any time during operation.
Memory allocator system flags have the following syntax: +M<S><P> <V>, where <S> is a
letter identifying a subsystem, <P> is a parameter, and <V> is the value to use. The flags
can be passed to the Erlang emulator (erl(1)) as command-line arguments.
System flags effecting specific allocators have an uppercase letter as <S>. The following
letters are used for the allocators:
* B: binary_alloc
* D: std_alloc
* E: ets_alloc
* F: fix_alloc
* H: eheap_alloc
* I: literal_alloc
* L: ll_alloc
* M: mseg_alloc
* R: driver_alloc
* S: sl_alloc
* T: temp_alloc
* Y: sys_alloc
Flags for Configuration of mseg_alloc
+MMamcbf <size>:
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.
+MMrmcbf <ratio>:
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.
+MMsco true|false:
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.
Note:
Setting this flag to false is not supported on all systems. The flag is then ignored.
+MMscrfsd <amount>:
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}).
+MMscrpm true|false:
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.
Note:
What reservation of physical memory means, highly depends on the operating system, and
how it is configured. For example, different memory overcommit settings on Linux
drastically change the behavior.
Setting this flag to false is possibly not supported on all systems. The flag is then
ignored.
+MMscs <size in MB>:
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.
+MMmcs <amount>:
Maximum cached segments. The maximum number of memory segments stored in the memory
segment cache. Valid range is [0, 30]. Defaults to 10.
Flags for Configuration of sys_alloc
+MYe true:
Enables sys_alloc.
Note:
sys_alloc cannot be disabled.
+MYtt <size>:
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.
Note:
This flag has effect only when the emulator is linked with the GNU C library, and uses
its malloc implementation.
+MYtp <size>:
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.
Note:
This flag has effect only when the emulator is linked with the GNU C library, and uses
its malloc implementation.
Flags for Configuration of Allocators Based on alloc_util
If u is used as subsystem identifier (that is, <S> = u), all allocators based on
alloc_util are effected. If B, D, E, F, H, I, L, R, S, T, X is used as subsystem
identifier, only the specific allocator identifier is effected.
+M<S>acul <utilization>|de:
Abandon carrier utilization limit. A valid <utilization> 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 <utilization>, 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 another allocator instance. 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).
+M<S>acfml <bytes>:
Abandon carrier free block min limit. A valid <bytes> 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.
+M<S>acnl <amount>:
Abandon carrier number limit. A valid <amount> 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.
+M<S>acful <utilization>|de:
Abandon carrier free utilization limit. When the utilization of a carrier falls belows
this limit erts_alloc instructs the OS that unused memory in the carrier can be re-
used for allocation by other OS procesesses. On Unix this is done by calling
madvise(..., ..., MADV_FREE) on the unused memory region, on Windows it is done by
calling VirtualAlloc(..., ..., MEM_RESET, PAGE_READWRITE). Defaults to 0 which means
that no memory will be marked as re-usable by the OS.
A valid <utilization> is an integer in the range [0, 100] representing utilization in
percent. If this value is larger than the acul limit it will be lowered to the current
acul limit. If de (default enabled) is passed instead of a <utilization>, a
recommended non-zero utilization value is used. The value chosen depends on the
allocator type and can be changed between ERTS versions.
See also acul.
+M<S>as bf|aobf|aoff|aoffcbf|aoffcaobf|ageffcaoff|ageffcbf|ageffcaobf|gf|af:
Allocation strategy. The following strategies are valid:
* bf (best fit)
* aobf (address order best fit)
* aoff (address order first fit)
* aoffcbf (address order first fit carrier best fit)
* aoffcaobf (address order first fit carrier address order best fit)
* ageffcaoff (age order first fit carrier address order first fit)
* ageffcbf (age order first fit carrier best fit)
* ageffcaobf (age order first fit carrier address order best fit)
* gf (good fit)
* af (a fit)
See the description of allocation strategies in section The alloc_util Framework.
+M<S>asbcst <size>:
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.
+M<S>atags true|false:
Adds a small tag to each allocated block that contains basic information about what it
is and who allocated it. Use the instrument module to inspect this information.
The runtime overhead is one word per allocation when enabled. This may change at any
time in the future.
The default is true for binary_alloc and driver_alloc, and false for the other
allocator types.
+M<S>cp B|D|E|F|H||L|R|S|@|::
Set carrier pool to use for the allocator. Memory carriers will only migrate between
allocator instances that use the same carrier pool. The following carrier pool names
exist:
B:
Carrier pool associated with binary_alloc.
D:
Carrier pool associated with std_alloc.
E:
Carrier pool associated with ets_alloc.
F:
Carrier pool associated with fix_alloc.
H:
Carrier pool associated with eheap_alloc.
L:
Carrier pool associated with ll_alloc.
R:
Carrier pool associated with driver_alloc.
S:
Carrier pool associated with sl_alloc.
@:
Carrier pool associated with the system as a whole.
Besides passing carrier pool name as value to the parameter, you can also pass :. By
passing : instead of carrier pool name, the allocator will use the carrier pool
associated with itself. By passing the command line argument "+Mucg :", all allocators
that have an associated carrier pool will use the carrier pool associated with
themselves.
The association between carrier pool and allocator is very loose. The associations are
more or less only there to get names for the amount of carrier pools needed and names
of carrier pools that can be easily identified by the : value.
This flag is only valid for allocators that have an associated carrier pool. Besides
that, there are no restrictions on carrier pools to use for an allocator.
Currently each allocator with an associated carrier pool defaults to using its own
associated carrier pool.
+M<S>e true|false:
Enables allocator <S>.
+M<S>lmbcs <size>:
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 > 64 MB.
+M<S>mbcgs <ratio>:
(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.
+M<S>mbsd <depth>:
Maximum block search depth. This flag has effect only if the good fit strategy is
selected for allocator <S>. 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 maximum 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.
+M<S>mmbcs <size>:
Main multiblock carrier size. Sets the size of the main multiblock carrier for
allocator <S>. The main multiblock carrier is allocated through sys_alloc and is never
deallocated.
+M<S>mmmbc <amount>:
Maximum mseg_alloc multiblock carriers. Maximum number of multiblock carriers
allocated through mseg_alloc by allocator <S>. When this limit is reached, new
multiblock carriers are allocated through sys_alloc.
+M<S>mmsbc <amount>:
Maximum mseg_alloc singleblock carriers. Maximum number of singleblock carriers
allocated through mseg_alloc by allocator <S>. When this limit is reached, new
singleblock carriers are allocated through sys_alloc.
+M<S>ramv <bool>:
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.
+M<S>rmbcmt <ratio>:
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 freed
memory compared to the previous size is more than this threshold, otherwise the block
is shrunk at the current location.
+M<S>rsbcmt <ratio>:
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.
+M<S>rsbcst <ratio>:
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.
+M<S>sbct <size>:
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.
+M<S>smbcs <size>:
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.
+M<S>t true|false:
Multiple, thread-specific instances of the allocator. Default behavior 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.
Flags for Configuration of alloc_util
All allocators based on alloc_util are effected.
+Muycs <size>:
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.
+Mummc <amount>:
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.
+Musac <bool>:
Allow sys_alloc carriers. Defaults to true. If set to false, sys_alloc carriers are
never created by allocators using the alloc_util framework.
Special Flag for literal_alloc
+MIscs <size in MB>:
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.
Instrumentation Flags
+M<S>atags:
Adds a small tag to each allocated block that contains basic information about what it
is and who allocated it. See +M<S>atags for a more complete description.
Note:
When instrumentation of the emulator is enabled, the emulator uses more memory and runs
slower.
Other Flags
+Mea min|max|r9c|r10b|r11b|config:
Options:
min:
Disables all allocators that can be disabled.
max:
Enables all allocators (default).
r9c|r10b|r11b:
Configures all allocators as they were configured in respective Erlang/OTP release.
These will eventually be removed.
config:
Disables features that cannot be enabled while creating an allocator configuration
with erts_alloc_config(3erl).
Note:
This option is to be used only while running erts_alloc_config(3erl), not when using
the created configuration.
+Mlpm all|no:
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.
+Mdai max|<amount>:
Set amount of dirty allocator instances used. Defaults to 0. That is, by default no
instances will be used. The maximum amount of instances equals the amount of dirty CPU
schedulers on the system.
By default, each normal scheduler thread has its own allocator instance for each
allocator. All other threads in the system, including dirty schedulers, share one
instance for each allocator. By enabling dirty allocator instances, dirty schedulers
will get and use their own set of allocator instances. Note that these instances are
not exclusive to each dirty scheduler, but instead shared among dirty schedulers. The
more instances used the less risk of lock contention on these allocator instances.
Memory consumption do however increase with increased amount of dirty allocator
instances.
NOTES
Only some default values have been presented here. For information about the currently
used settings and the current status of the allocators, see erlang:system_info(allocator)
and erlang:system_info({allocator, Alloc}).
Note:
Most of these flags are highly implementation-dependent and can be changed or removed
without prior notice.
erts_alloc is not obliged to strictly use the settings that have been passed to it (it can
even ignore them).
The erts_alloc_config(3erl) tool can be used to aid creation of an erts_alloc
configuration that is suitable for a limited number of runtime scenarios.
SEE ALSO
erl(1), erlang(3erl), erts_alloc_config(3erl), instrument(3erl)