A good start when programming efficient is to have knowledge about how much memory different data types and operations require. It is implementation dependent how much memory the Erlang data types and other items consume, but here are some figures for the current beam emulator version 5.2 system (OTP release R9B). The unit of measurement is memory words. There exists both a 32-bit and a 64-bit implementation, and a word is therefore, respectively, 4 bytes and 8 bytes.
Data type | Memory size |
Integer (-16#7FFFFFF < i <16#7FFFFFF) | 1 word |
Integer (big numbers) | 3..N words |
Atom | 1 word. Note, an atom refers into an atom table which also consumes memory. The atom text is stored once for each unique atom in this table. Note also, this table is not garbage collected. |
Float |
On 32-bit architectures: 4 words
On 64-bit architectures: 3 words |
Binary | 3..6 + data (can be shared) |
List | 1 words per element + the size of each element |
String (is the same as a List of Integers) | 2 words per character |
Tuple | 2 words + the size of each element |
Pid | 1 word for a process identifier from the current local node, and 5 words for a process identifier from another node. Note, a process identifier refers into a process table and a node table which also consumes memory. |
Port | 1 word for a port identifier from the current local node, and 5 words for a port identifier from another node. Note, a port identifier refers into a port table and a node table which also consumes memory. |
Reference |
On 32-bit architectures: 5 words for a reference from the current
local node, and 7 words for a reference from another node.
On 64-bit architectures: 4 words for a reference from the current local node, and 6 words for a reference from another node. Note, a reference refers into a node table which also consumes memory. |
Fun | 9..13 words + size of environment. Note, a fun refers into a code table which also consumes memory. |
Ets table | Initially 768 words + the size of each element (6 words + size of Erlang data). The table will grow when necessary. |
Erlang process | 327 words when spawned including a heap of 233 words. |
The Erlang language specification puts no limits on number of processes, length of atoms etc. but for performance and memory saving reasons there will always be limits in a practical implementation of the Erlang language and execution environment. The current implementation has a few limitations that is good to know about since some of them can be of great importance for the design of an application.
ERL_MAX_ETS_TABLES
.
system_limit
exception, while any attempt to match a binary that is
too large will fail.
This limit is enforced starting with the R11B-4 release; in earlier releases,
operations on too large binaries would in general either fail or give incorrect
results.
In future releases of Erlang/OTP, other operations that create binaries (such as
list_to_binary/1
) will proably also enforce the same limit.