erts_alloc(3)

📦

version 29.0.6 · 3 versions

💖 erts_alloc — Erlang Module Definition 💖

okay bestie, this is the manual page for erts_alloc(3), and it's literally the Erlang runtime system internal memory allocator library. Not me being dramatic — it says it right there. 💅

✨ 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. periodt. 💅

🌈 Allocators 🌈

The following allocators are present:

temp_alloc — the one for temporary allocations. ✨
eheap_alloc — for Erlang heap data, such as Erlang process heaps.
binary_alloc — for Erlang binary data.
ets_alloc — for ets data.
driver_alloc — for driver data.
literal_alloc — for constant terms in Erlang code.
sl_alloc — for memory blocks that are expected to be short-lived.
ll_alloc — 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 — for most memory blocks not allocated through any of the other allocators described above.
sys_alloc — normally the default malloc implementation used on the specific OS.
mseg_alloc — a memory segment allocator. Other allocators use it for allocating memory segments, and it 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.
+MMlp on|off — Enables the use of large pages, sometimes known as huge pages or super pages, for mapping memory segment allocations. Large pages improve performance by reducing TLB pressure but they can sometimes be costly to allocate or can only be allocated on a best-effort basis. Currently only affects memory segments allocated in a super carrier. Defaults to off.
+MMsco true|false — the super carrier only flag, bestie. Defaults to true. So when a super carrier is in play and this is true, mseg_alloc will only make carriers inside the super carrier, periodt. But heads up 👀 — the alloc_util framework can still create sys_alloc carriers, so if you genuinely want EVERY carrier living in the super carrier, you wanna shut off sys_alloc carriers too by also passing +Musac false. When the flag is false, mseg_alloc tries to create carriers outside the super carrier whenever the super carrier is full.

NOTE: setting this flag to false is not supported on all systems. On those systems the flag is just... ignored. 😭

+MMscrfsd <amount> — sets the super carrier reserved free segment descriptors. Defaults to 65536. This lil parameter decides how much memory gets reserved for free segment descriptors used by the super carrier. If the system runs out of that reserved memory for free segment descriptors, it just borrows other memory instead. But that can cause fragmentation issues 🫠, so you really wanna make sure it 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 — the super carrier reserve physical memory flag. Defaults to true. When it's true, physical memory is reserved for the whole super carrier in one go when it's created, and after that the reservation is left unchanged. When you set it to false, only virtual address space is reserved for the super carrier at creation time. Then the system attempts to reserve physical memory whenever carriers get created in the super carrier, and attempts to unreserve physical memory whenever carriers get destroyed in the super carrier.

NOTE: what "reservation of physical memory" even means highly depends on your operating system and how it's configured. Like, different memory overcommit settings on Linux drastically change the behavior. Setting this flag to false is possibly not supported on all systems — the flag then just gets ignored.

+MMscs <size in MB> — sets the super carrier size in MB. Defaults to 0, which means the super carrier is disabled by default, no cap 💅. The super carrier is a large continuous area in the virtual address space, and mseg_alloc always tries to create new carriers in the super carrier if it exists. Remember that the alloc_util framework can create sys_alloc carriers — for more info, see +MMsco.
+MMmcs <amount> — maximum cached segments. This is the max 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. It's giving unskippable. 💀

+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 gets kept by malloc and 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 only has effect 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 malloc allocates when sbrk is called to grab more memory from the operating system. Defaults to 0.

NOTE: this flag only has effect when the emulator is linked with the GNU C library, and uses its malloc implementation.

🦋 Flags for Configuration of Allocators Based on alloc_util 🦋

Okay so here's the tea ☕ — if u is used as the subsystem identifier (that is, <S> = u), then all allocators based on alloc_util are affected. If B, D, E, F, H, I, L, R, S, T, X is used as the subsystem identifier, only that specific allocator identifier is affected.

+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 get 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.

✨ Flags for Configuration of alloc_util ✨

All allocators based on alloc_util are affected.

+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.
+Mumadtn <bool> — Control how to mark memory as re-usable on Unix when +M<S>acful is set. Default is false, which means MADV_FREE is passed to madvise(). If set to true, MADV_DONTNEED is passed instead.

🎀 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.
+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).

👀 See Also 👀

erl(1), erlang, instrument

This page is brought to you by Ericsson AB, version erts 17.0.6, page erts_alloc(3). No date on the footer, but it's giving official manual energy. Byeee bestie 💖✨

📦 where this page comes from

ubuntu stonking: erlang-doc 1:29.0.6+dfsg-1 · Apache-2.0
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-11-03: a language model's rewrite of the original, under its terms

erts_alloc(3)

💖 erts_alloc — Erlang Module Definition 💖

✨ NAME ✨

🎀 DESCRIPTION 🎀

🌈 Allocators 🌈

🧚 The alloc_util Framework 🧚

Best fit

Address order best fit

Address order first fit

Address order first fit carrier best fit

Address order first fit carrier address order best fit

Age order first fit carrier address order first fit

Age order first fit carrier best fit

Age order first fit carrier address order best fit

Good fit

A fit

🚨 System Flags Effecting erts_alloc 🚨

💅 Flags for Configuration of mseg_alloc 💅

🌈 Flags for Configuration of sys_alloc 🌈

🦋 Flags for Configuration of Allocators Based on alloc_util 🦋

✨ Flags for Configuration of alloc_util ✨

🎀 Special Flag for literal_alloc 🎀

🔍 Instrumentation Flags 🔍

🌀 Other Flags 🌀

📝 Notes 📝

👀 See Also 👀

🧚 The `alloc_util` Framework 🧚

🚨 System Flags Effecting `erts_alloc` 🚨

💅 Flags for Configuration of `mseg_alloc` 💅