Computes and returns the adler32 checksum for Data.

Continues computing the adler32 checksum by combining the previous checksum, OldAdler, with the checksum of Data.

The following code:

assigns the same value to Y as this:

Combines two previously computed adler32 checksums. This computation requires the size of the data object for the second checksum to be known.

The following code:

assigns the same value to Z as this:

Returns a new tuple that has one element more than Tuple1, and contains the elements in Tuple1 followed by Term as the last element. Semantically equivalent to list_to_tuple(tuple_to_list(Tuple1) ++ [Term]), but much faster. Example:

> erlang:append_element({one, two}, three).
{one,two,three}

Calls a fun, passing the elements in Args as arguments.

If the number of elements in the arguments are known at compile time, the call is better written as Fun(Arg1, Arg2, ... ArgN).

Returns the result of applying Function in Module to Args. The applied function must be exported from Module. The arity of the function is the length of Args. Example:

> apply(lists, reverse, [[a, b, c]]).
[c,b,a]
> apply(erlang, atom_to_list, ['Erlang']).
"Erlang"

If the number of arguments are known at compile time, the call is better written as Module:Function(Arg1, Arg2, ..., ArgN).

Failure: error_handler:undefined_function/3 is called if the applied function is not exported. The error handler can be redefined (see process_flag/2). If error_handler is undefined, or if the user has redefined the default error_handler so the replacement module is undefined, an error with reason undef is generated.

Returns a binary corresponding to the text representation of Atom. If Encoding is latin1, one byte exists for each character in the text representation. If Encoding is utf8 or unicode, the characters are encoded using UTF-8 where characters may require multiple bytes.

Example:

> atom_to_binary('Erlang', latin1).
<<"Erlang">>

Returns a string corresponding to the text representation of Atom, for example:

> atom_to_list('Erlang').
"Erlang"

Extracts the part of the binary described by PosLen.

Negative length can be used to extract bytes at the end of a binary, for example:

Failure: badarg if PosLen in any way references outside the binary.

Start is zero-based, that is:

For details about the PosLen semantics, see binary(3).

Allowed in guard tests.

The same as binary_part(Subject, {Start, Length}).

Allowed in guard tests.

Returns the atom whose text representation is Binary. If Encoding is latin1, no translation of bytes in the binary is done. If Encoding is utf8 or unicode, the binary must contain valid UTF-8 sequences.

Examples:

> binary_to_atom(<<"Erlang">>, latin1).
'Erlang'
> binary_to_atom(<<1024/utf8>>, utf8).
'Ѐ'

As binary_to_atom/2, but the atom must exist.

Failure: badarg if the atom does not exist.

Returns the float whose text representation is Binary, for example:

> binary_to_float(<<"2.2017764e+0">>).
2.2017764

Failure: badarg if Binary contains a bad representation of a float.

Returns an integer whose text representation is Binary, for example:

> binary_to_integer(<<"123">>).
123

Failure: badarg if Binary contains a bad representation of an integer.

Returns an integer whose text representation in base Base is Binary, for example:

> binary_to_integer(<<"3FF">>, 16).
1023

Failure: badarg if Binary contains a bad representation of an integer.

Returns a list of integers corresponding to the bytes of Binary.

As binary_to_list/1, but returns a list of integers corresponding to the bytes from position Start to position Stop in Binary. The positions in the binary are numbered starting from 1.

Returns an Erlang term that is the result of decoding binary object Binary, which must be encoded according to the Erlang external term format.

> Bin = term_to_binary(hello).
<<131,100,0,5,104,101,108,108,111>>
> hello = binary_to_term(Bin).
hello

See also term_to_binary/1 and binary_to_term/2.

As binary_to_term/1, but takes options that affect decoding of the binary.

Option:

Failure: badarg if safe is specified and unsafe data is decoded.

> binary_to_term(<<131,100,0,5,104,101,108,108,111>>, [safe]).
** exception error: bad argument
> hello.
hello
> binary_to_term(<<131,100,0,5,104,101,108,108,111>>, [safe]).
hello

See also term_to_binary/1, binary_to_term/1, and list_to_existing_atom/1.

Returns an integer that is the size in bits of Bitstring, for example:

> bit_size(<<433:16,3:3>>).
19
> bit_size(<<1,2,3>>).
24

Allowed in guard tests.

Returns a list of integers corresponding to the bytes of Bitstring. If the number of bits in the binary is not divisible by 8, the last element of the list is a bitstring containing the remaining 1-7 bits.

This implementation-dependent function increments the reduction counter for the calling process. In the Beam emulator, the reduction counter is normally incremented by one for each function and BIF call. A context switch is forced when the counter reaches the maximum number of reductions for a process (2000 reductions in Erlang/OTP R12B).

Returns an integer that is the number of bytes needed to contain Bitstring. That is, if the number of bits in Bitstring is not divisible by 8, the resulting number of bytes is rounded up. Examples:

> byte_size(<<433:16,3:3>>).
3
> byte_size(<<1,2,3>>).
3

Allowed in guard tests.

Cancels a timer. The same as calling erlang:cancel_timer(TimerRef, []).

Cancels a timer that has been created by erlang:start_timer or erlang:send_after. TimerRef identifies the timer, and was returned by the BIF that created the timer.

Options:

More Options may be added in the future.

If Result is an integer, it represents the time in milliseconds left until the canceled timer would have expired.

If Result is false, a timer corresponding to TimerRef could not be found. This can be either because the timer had expired, already had been canceled, or because TimerRef never corresponded to a timer. Even if the timer had expired, it does not tell you if the time-out message has arrived at its destination yet.

See also erlang:send_after/4, erlang:start_timer/4, and erlang:read_timer/2.

Returns the smallest integer not less than Number. For example:

> ceil(5.5).
6

Allowed in guard tests.

Returns true if Module has old code, otherwise false.

See also code(3).

The same as check_process_code(Pid, Module, []) .

Checks if the node local process identified by Pid executes old code for Module.

Options:

If Pid equals self(), and no async option has been passed, the operation is performed at once. Otherwise a request for the operation is sent to the process identified by Pid, and is handled when appropriate. If no async option has been passed, the caller blocks until CheckResult is available and can be returned.

CheckResult informs about the result of the request as follows:

See also code(3).

Failures:

Converts the Time value of time unit FromUnit to the corresponding ConvertedTime value of time unit ToUnit. The result is rounded using the floor function.

Computes and returns the crc32 (IEEE 802.3 style) checksum for Data.

Continues computing the crc32 checksum by combining the previous checksum, OldCrc, with the checksum of Data.

The following code:

assigns the same value to Y as this:

Combines two previously computed crc32 checksums. This computation requires the size of the data object for the second checksum to be known.

The following code:

assigns the same value to Z as this:

Returns the current date as {Year, Month, Day}.

The time zone and Daylight Saving Time correction depend on the underlying OS. Example:

> date().
{1995,2,19}

Decodes the binary Bin according to the packet protocol specified by Type. Similar to the packet handling done by sockets with option {packet,Type}.

If an entire packet is contained in Bin, it is returned together with the remainder of the binary as {ok,Packet,Rest}.

If Bin does not contain the entire packet, {more,Length} is returned. Length is either the expected total size of the packet, or undefined if the expected packet size is unknown. decode_packet can then be called again with more data added.

If the packet does not conform to the protocol format, {error,Reason} is returned.

Types:

Options:

Examples:

> erlang:decode_packet(1,<<3,"abcd">>,[]).
{ok,<<"abc">>,<<"d">>}
> erlang:decode_packet(1,<<5,"abcd">>,[]).
{more,6}

Returns a new tuple with element at Index removed from tuple Tuple1, for example:

> erlang:delete_element(2, {one, two, three}).
{one,three}

Makes the current code for Module become old code and deletes all references for this module from the export table. Returns undefined if the module does not exist, otherwise true.

Failure: badarg if there already is an old version of Module.

If MonitorRef is a reference that the calling process obtained by calling monitor/2, this monitoring is turned off. If the monitoring is already turned off, nothing happens.

Once demonitor(MonitorRef) has returned, it is guaranteed that no {'DOWN', MonitorRef, _, _, _} message, because of the monitor, will be placed in the caller message queue in the future. However, a {'DOWN', MonitorRef, _, _, _} message can have been placed in the caller message queue before the call. It is therefore usually advisable to remove such a 'DOWN' message from the message queue after monitoring has been stopped. demonitor(MonitorRef, [flush]) can be used instead of demonitor(MonitorRef) if this cleanup is wanted.

Failure: It is an error if MonitorRef refers to a monitoring started by another process. Not all such cases are cheap to check. If checking is cheap, the call fails with badarg, for example if MonitorRef is a remote reference.

The returned value is true unless info is part of OptionList.

demonitor(MonitorRef, []) is equivalent to demonitor(MonitorRef).

Options:

Failures:

Forces the disconnection of a node. This appears to the node Node as if the local node has crashed. This BIF is mainly used in the Erlang network authentication protocols.

Returns true if disconnection succeeds, otherwise false. If the local node is not alive, ignored is returned.

Prints a text representation of Term on the standard output.

Returns the Nth element (numbering from 1) of Tuple, for example:

> element(2, {a, b, c}).
b

Allowed in guard tests.

Returns the process dictionary and deletes it, for example:

> put(key1, {1, 2, 3}),
put(key2, [a, b, c]),
erase().
[{key1,{1,2,3}},{key2,[a,b,c]}]

Returns the value Val associated with Key and deletes it from the process dictionary. Returns undefined if no value is associated with Key. Example:

> put(key1, {merry, lambs, are, playing}),
X = erase(key1),
{X, erase(key1)}.
{{merry,lambs,are,playing},undefined}

Stops the execution of the calling process with the reason Reason, where Reason is any term. The exit reason is {Reason, Where}, where Where is a list of the functions most recently called (the current function first). As evaluating this function causes the process to terminate, it has no return value. Example:

> catch error(foobar).
{'EXIT',{foobar,[{erl_eval,do_apply,5},
                 {erl_eval,expr,5},
                 {shell,exprs,6},
                 {shell,eval_exprs,6},
                 {shell,eval_loop,3}]}}

Stops the execution of the calling process with the reason Reason, where Reason is any term. The exit reason is {Reason, Where}, where Where is a list of the functions most recently called (the current function first). Args is expected to be the list of arguments for the current function; in Beam it is used to provide the arguments for the current function in the term Where. As evaluating this function causes the process to terminate, it has no return value.

Stops the execution of the calling process with exit reason Reason, where Reason is any term. As evaluating this function causes the process to terminate, it has no return value. Example:

> exit(foobar).
** exception exit: foobar
> catch exit(foobar).
{'EXIT',foobar}

Sends an exit signal with exit reason Reason to the process or port identified by Pid.

The following behavior applies if Reason is any term, except normal or kill:

If Reason is the atom normal, Pid does not exit. If it is trapping exits, the exit signal is transformed into a message {'EXIT', From, normal} and delivered to its message queue.

If Reason is the atom kill, that is, if exit(Pid, kill) is called, an untrappable exit signal is sent to Pid, which unconditionally exits with exit reason killed.

Calculates, without doing the encoding, the maximum byte size for a term encoded in the Erlang external term format. The following condition applies always:

> Size1 = byte_size(term_to_binary(Term)),
> Size2 = erlang:external_size(Term),
> true = Size1 =< Size2.
true

This is equivalent to a call to:

Calculates, without doing the encoding, the maximum byte size for a term encoded in the Erlang external term format. The following condition applies always:

> Size1 = byte_size(term_to_binary(Term, Options)),
> Size2 = erlang:external_size(Term, Options),
> true = Size1 =< Size2.
true

Option {minor_version, Version} specifies how floats are encoded. For a detailed description, see term_to_binary/2.

Returns a float by converting Number to a float, for example:

> float(55).
55.0

Allowed in guard tests.

The same as float_to_binary(Float,[{scientific,20}]).

Returns a binary corresponding to the text representation of Float using fixed decimal point formatting. Options behaves in the same way as float_to_list/2. Examples:

> float_to_binary(7.12, [{decimals, 4}]).
<<"7.1200">>
> float_to_binary(7.12, [{decimals, 4}, compact]).
<<"7.12">>

The same as float_to_list(Float,[{scientific,20}]).

Returns a string corresponding to the text representation of Float using fixed decimal point formatting.

Available options:

Examples:

> float_to_list(7.12, [{decimals, 4}]).
"7.1200"
> float_to_list(7.12, [{decimals, 4}, compact]).
"7.12"

Returns the largest integer not greater than Number. For example:

> floor(-10.5).
-11

Allowed in guard tests.

Returns a list with information about the fun Fun. Each list element is a tuple. The order of the tuples is undefined, and more tuples can be added in a future release.

Two types of funs have slightly different semantics:

The following elements are always present in the list for both local and external funs:

The following elements are only present in the list if Fun is local:

Returns a string corresponding to the text representation of Fun.

Returns true if the module Module is loaded and contains an exported function Function/Arity, or if there is a BIF (a built-in function implemented in C) with the specified name, otherwise returns false.

Forces an immediate garbage collection of the executing process. The function is not to be used unless it has been noticed (or there are good reasons to suspect) that the spontaneous garbage collection will occur too late or not at all.

The same as garbage_collect(Pid, []).

Garbage collects the node local process identified by Pid.

Option:

If Pid equals self(), and no async option has been passed, the garbage collection is performed at once, that is, the same as calling garbage_collect/0. Otherwise a request for garbage collection is sent to the process identified by Pid, and will be handled when appropriate. If no async option has been passed, the caller blocks until GCResult is available and can be returned.

GCResult informs about the result of the garbage collection request as follows:

Notice that the same caveats apply as for garbage_collect/0.

Failures:

Returns the process dictionary as a list of {Key, Val} tuples, for example:

> put(key1, merry),
put(key2, lambs),
put(key3, {are, playing}),
get().
[{key1,merry},{key2,lambs},{key3,{are,playing}}]

Returns the value Val associated with Key in the process dictionary, or undefined if Key does not exist. Example:

> put(key1, merry),
put(key2, lambs),
put({any, [valid, term]}, {are, playing}),
get({any, [valid, term]}).
{are,playing}

Returns the magic cookie of the local node if the node is alive, otherwise the atom nocookie.

Returns a list of all keys present in the process dictionary, for example:

> put(dog, {animal,1}),
put(cow, {animal,2}),
put(lamb, {animal,3}),
get_keys().
[dog,cow,lamb]

Returns a list of keys that are associated with the value Val in the process dictionary, for example:

> put(mary, {1, 2}),
put(had, {1, 2}),
put(a, {1, 2}),
put(little, {1, 2}),
put(dog, {1, 3}),
put(lamb, {1, 2}),
get_keys({1, 2}).
[mary,had,a,little,lamb]

Returns the process identifier of the group leader for the process evaluating the function.

Every process is a member of some process group and all groups have a group leader. All I/O from the group is channeled to the group leader. When a new process is spawned, it gets the same group leader as the spawning process. Initially, at system startup, init is both its own group leader and the group leader of all processes.

Sets the group leader of Pid to GroupLeader. Typically, this is used when a process started from a certain shell is to have another group leader than init.

See also group_leader/0.

The same as halt(0, []). Example:

> halt().
os_prompt%

The same as halt(Status, []). Example:

> halt(17).
os_prompt% echo $?
17
os_prompt%

Status must be a non-negative integer, a string, or the atom abort. Halts the Erlang runtime system. Has no return value. Depending on Status, the following occurs:

For integer Status, the Erlang runtime system closes all ports and allows async threads to finish their operations before exiting. To exit without such flushing, use Option as {flush,false}.

For statuses string() and abort, option flush is ignored and flushing is not done.

Returns the head of List, that is, the first element, for example:

> hd([1,2,3,4,5]).
1

Allowed in guard tests.

Failure: badarg if List is the empty list [].

Puts the calling process into a wait state where its memory allocation has been reduced as much as possible. This is useful if the process does not expect to receive any messages soon.

The process is awaken when a message is sent to it, and control resumes in Module:Function with the arguments specified by Args with the call stack emptied, meaning that the process terminates when that function returns. Thus erlang:hibernate/3 never returns to its caller.

If the process has any message in its message queue, the process is awakened immediately in the same way as described earlier.

In more technical terms, erlang:hibernate/3 discards the call stack for the process, and then garbage collects the process. After this, all live data is in one continuous heap. The heap is then shrunken to the exact same size as the live data that it holds (even if that size is less than the minimum heap size for the process).

If the size of the live data in the process is less than the minimum heap size, the first garbage collection occurring after the process is awakened ensures that the heap size is changed to a size not smaller than the minimum heap size.

Notice that emptying the call stack means that any surrounding catch is removed and must be re-inserted after hibernation. One effect of this is that processes started using proc_lib (also indirectly, such as gen_server processes), are to use proc_lib:hibernate/3 instead, to ensure that the exception handler continues to work when the process wakes up.

Returns a new tuple with element Term inserted at position Index in tuple Tuple1. All elements from position Index and upwards are pushed one step higher in the new tuple Tuple2. Example:

> erlang:insert_element(2, {one, two, three}, new).
{one,new,two,three}

Returns a binary corresponding to the text representation of Integer, for example:

> integer_to_binary(77).
<<"77">>

Returns a binary corresponding to the text representation of Integer in base Base, for example:

> integer_to_binary(1023, 16).
<<"3FF">>

Returns a string corresponding to the text representation of Integer, for example:

> integer_to_list(77).
"77"

Returns a string corresponding to the text representation of Integer in base Base, for example:

> integer_to_list(1023, 16).
"3FF"

Returns an integer, that is the size in bytes, of the binary that would be the result of iolist_to_binary(Item), for example:

> iolist_size([1,2|<<3,4>>]).
4

Returns a binary that is made from the integers and binaries in IoListOrBinary, for example:

> Bin1 = <<1,2,3>>.
<<1,2,3>>
> Bin2 = <<4,5>>.
<<4,5>>
> Bin3 = <<6>>.
<<6>>
> iolist_to_binary([Bin1,1,[2,3,Bin2],4|Bin3]).
<<1,2,3,1,2,3,4,5,4,6>>

Returns true if the local node is alive (that is, if the node can be part of a distributed system), otherwise false.

Returns true if Term is an atom, otherwise false.

Allowed in guard tests.

Returns true if Term is a binary, otherwise false.

A binary always contains a complete number of bytes.

Allowed in guard tests.

Returns true if Term is a bitstring (including a binary), otherwise false.

Allowed in guard tests.

Returns true if Term is the atom true or the atom false (that is, a boolean). Otherwise returns false.

Allowed in guard tests.

This BIF is useful for builders of cross-reference tools.

Returns true if Module:Function/Arity is a BIF implemented in C, otherwise false.

Returns true if Term is a floating point number, otherwise false.

Allowed in guard tests.

Returns true if Term is a fun, otherwise false.

Allowed in guard tests.

Returns true if Term is a fun that can be applied with Arity number of arguments, otherwise false.

Allowed in guard tests.

Returns true if Term is an integer, otherwise false.

Allowed in guard tests.

Returns true if Term is a list with zero or more elements, otherwise false.

Allowed in guard tests.

Returns true if Term is a map, otherwise false.

Allowed in guard tests.

Returns true if Term is an integer or a floating point number. Otherwise returns false.

Allowed in guard tests.

Returns true if Term is a process identifier, otherwise false.

Allowed in guard tests.

Returns true if Term is a port identifier, otherwise false.

Allowed in guard tests.

Pid must refer to a process at the local node.

Returns true if the process exists and is alive, that is, is not exiting and has not exited. Otherwise returns false.

Returns true if Term is a tuple and its first element is RecordTag. Otherwise returns false.

Allowed in guard tests, if RecordTag is a literal atom.

RecordTag must be an atom.

Returns true if Term is a tuple, its first element is RecordTag, and its size is Size. Otherwise returns false.

Allowed in guard tests if RecordTag is a literal atom and Size is a literal integer.

Returns true if Term is a reference, otherwise false.

Allowed in guard tests.

Returns true if Term is a tuple, otherwise false.

Allowed in guard tests.

Returns the length of List, for example:

> length([1,2,3,4,5,6,7,8,9]).
9

Allowed in guard tests.

Creates a link between the calling process and another process (or port) PidOrPort, if there is not such a link already. If a process attempts to create a link to itself, nothing is done. Returns true.

If PidOrPort does not exist, the behavior of the BIF depends on if the calling process is trapping exits or not (see process_flag/2):

Returns the atom whose text representation is String.

As from Erlang/OTP 20, String may contain any Unicode character. Earlier versions allowed only ISO-latin-1 characters as the implementation did not allow Unicode characters above 255. For more information on Unicode support in atoms, see note on UTF-8 encoded atoms in section "External Term Format" in the User's Guide.

Example:

> list_to_atom("Erlang").
'Erlang'

Returns a binary that is made from the integers and binaries in IoList, for example:

> Bin1 = <<1,2,3>>.
<<1,2,3>>
> Bin2 = <<4,5>>.
<<4,5>>
> Bin3 = <<6>>.
<<6>>
> list_to_binary([Bin1,1,[2,3,Bin2],4|Bin3]).
<<1,2,3,1,2,3,4,5,4,6>>

Returns the atom whose text representation is String, but only if there already exists such atom.

Failure: badarg if there does not already exist an atom whose text representation is String.

Returns the float whose text representation is String, for example:

> list_to_float("2.2017764e+0").
2.2017764

Failure: badarg if String contains a bad representation of a float.

Returns an integer whose text representation is String, for example:

> list_to_integer("123").
123

Failure: badarg if String contains a bad representation of an integer.

Returns an integer whose text representation in base Base is String, for example:

> list_to_integer("3FF", 16).
1023

Failure: badarg if String contains a bad representation of an integer.

Returns a process identifier whose text representation is a String, for example:

> list_to_pid("<0.4.1>").
<0.4.1>

Failure: badarg if String contains a bad representation of a process identifier.

Returns a tuple corresponding to List, for example

> list_to_tuple([share, ['Ericsson_B', 163]]).
{share, ['Ericsson_B', 163]}

List can contain any Erlang terms.

If Binary contains the object code for module Module, this BIF loads that object code. If the code for module Module already exists, all export references are replaced so they point to the newly loaded code. The previously loaded code is kept in the system as old code, as there can still be processes executing that code.

Returns either {module, Module}, or {error, Reason} if loading fails. Reason is one of the following:

Loads and links a dynamic library containing native implemented functions (NIFs) for a module. Path is a file path to the shareable object/dynamic library file minus the OS-dependent file extension (.so for Unix and .dll for Windows). Notice that on most OSs the library has to have a different name on disc when an upgrade of the nif is done. If the name is the same, but the contents differ, the old library may be loaded instead. For information on how to implement a NIF library, see erl_nif(3).

LoadInfo can be any term. It is passed on to the library as part of the initialization. A good practice is to include a module version number to support future code upgrade scenarios.

The call to load_nif/2 must be made directly from the Erlang code of the module that the NIF library belongs to. It returns either ok, or {error,{Reason,Text}} if loading fails. Reason is one of the following atoms while Text is a human readable string that can give more information about the failure:

Returns a list of all loaded Erlang modules (current and old code), including preloaded modules.

See also code(3).

Returns the current local date and time, {{Year, Month, Day}, {Hour, Minute, Second}}, for example:

> erlang:localtime().
{{1996,11,6},{14,45,17}}

The time zone and Daylight Saving Time correction depend on the underlying OS.

Converts local date and time to Universal Time Coordinated (UTC), if supported by the underlying OS. Otherwise no conversion is done and Localtime is returned. Example:

> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}).
{{1996,11,6},{13,45,17}}

Failure: badarg if Localtime denotes an invalid date and time.

Converts local date and time to Universal Time Coordinated (UTC) as erlang:localtime_to_universaltime/1, but the caller decides if Daylight Saving Time is active.

If IsDst == true, Localtime is during Daylight Saving Time, if IsDst == false it is not. If IsDst == undefined, the underlying OS can guess, which is the same as calling erlang:localtime_to_universaltime(Localtime).

Examples:

> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}, true).
{{1996,11,6},{12,45,17}}
> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}, false).
{{1996,11,6},{13,45,17}}
> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}, undefined).
{{1996,11,6},{13,45,17}}

Failure: badarg if Localtime denotes an invalid date and time.

Returns a unique reference. The reference is unique among connected nodes.

Creates a new tuple of the specified Arity, where all elements are InitialValue, for example:

> erlang:make_tuple(4, []).
{[],[],[],[]}

Creates a tuple of size Arity, where each element has value DefaultValue, and then fills in values from InitList. Each list element in InitList must be a two-tuple, where the first element is a position in the newly created tuple and the second element is any term. If a position occurs more than once in the list, the term corresponding to the last occurrence is used. Example:

> erlang:make_tuple(5, [], [{2,ignored},{5,zz},{2,aa}]).
{[],aa,[],[],zz}

Returns an integer, which is the number of key-value pairs in Map, for example:

> map_size(#{a=>1, b=>2, c=>3}).
3

Allowed in guard tests.

Tests a match specification used in calls to ets:select/2 and erlang:trace_pattern/3. The function tests both a match specification for "syntactic" correctness and runs the match specification against the object. If the match specification contains errors, the tuple {error, Errors} is returned, where Errors is a list of natural language descriptions of what was wrong with the match specification.

If Type is table, the object to match against is to be a tuple. The function then returns {ok,Result,[],Warnings}, where Result is what would have been the result in a real ets:select/2 call, or false if the match specification does not match the object tuple.

If Type is trace, the object to match against is to be a list. The function returns {ok, Result, Flags, Warnings}, where Result is one of the following:

Flags is a list containing all the trace flags to be enabled, currently this is only return_trace.

This is a useful debugging and test tool, especially when writing complicated match specifications.

See also ets:test_ms/2.

Returns the largest of Term1 and Term2. If the terms are equal, Term1 is returned.

Computes an MD5 message digest from Data, where the length of the digest is 128 bits (16 bytes). Data is a binary or a list of small integers and binaries.

For more information about MD5, see RFC 1321 - The MD5 Message-Digest Algorithm.

Finishes the update of an MD5 Context and returns the computed MD5 message digest.

Creates an MD5 context, to be used in the following calls to md5_update/2.

Update an MD5 Context with Data and returns a NewContext.

Returns the smallest of Term1 and Term2. If the terms are equal, Term1 is returned.

Returns true if the module Module is loaded, otherwise false. It does not attempt to load the module.

Monitor the status of the node Node. If Flag is true, monitoring is turned on. If Flag is false, monitoring is turned off.

Making several calls to monitor_node(Node, true) for the same Node is not an error; it results in as many independent monitoring instances.

If Node fails or does not exist, the message {nodedown, Node} is delivered to the process. If a process has made two calls to monitor_node(Node, true) and Node terminates, two nodedown messages are delivered to the process. If there is no connection to Node, an attempt is made to create one. If this fails, a nodedown message is delivered.

Nodes connected through hidden connections can be monitored as any other nodes.

Failure: badarg if the local node is not alive.

Behaves as monitor_node/2 except that it allows an extra option to be specified, namely allow_passive_connect. This option allows the BIF to wait the normal network connection time-out for the monitored node to connect itself, even if it cannot be actively connected from this node (that is, it is blocked). The state where this can be useful can only be achieved by using the Kernel option dist_auto_connect once. If that option is not used, option allow_passive_connect has no effect.

Failure: badarg if the local node is not alive or the option list is malformed.

Returns the current Erlang monotonic time in native time unit. This is a monotonically increasing time since some unspecified point in time.

Returns the current Erlang monotonic time converted into the Unit passed as argument.

Same as calling erlang:convert_time_unit( erlang:monotonic_time(), native, Unit), however optimized for commonly used Units.

Works exactly like error/1, but Dialyzer thinks that this BIF will return an arbitrary term. When used in a stub function for a NIF to generate an exception when the NIF library is not loaded, Dialyzer does not generate false warnings.

Works exactly like error/2, but Dialyzer thinks that this BIF will return an arbitrary term. When used in a stub function for a NIF to generate an exception when the NIF library is not loaded, Dialyzer does not generate false warnings.

Returns the name of the local node. If the node is not alive, nonode@nohost is returned instead.

Allowed in guard tests.

Returns the node where Arg originates. Arg can be a process identifier, a reference, or a port. If the local node is not alive, nonode@nohost is returned.

Allowed in guard tests.

Returns a list of all visible nodes in the system, except the local node. Same as nodes(visible).

Returns a list of nodes according to the argument specified. The returned result, when the argument is a list, is the list of nodes satisfying the disjunction(s) of the list elements.

NodeTypes:

Some equalities: [node()] = nodes(this), nodes(connected) = nodes([visible, hidden]), and nodes() = nodes(visible).

Returns a port identifier as the result of opening a new Erlang port. A port can be seen as an external Erlang process.

The name of the executable as well as the arguments specifed in cd, env, args, and arg0 are subject to Unicode filename translation if the system is running in Unicode filename mode. To avoid translation or to force, for example UTF-8, supply the executable and/or arguments as a binary in the correct encoding. For details, see the module file(3), the function file:native_name_encoding/0 in Kernel, and the Using Unicode in Erlang User's Guide.

PortNames:

PortSettings is a list of settings for the port. The valid settings are as follows:

Default is stream for all port types and use_stdio for spawned ports.

Failure: if the port cannot be opened, the exit reason is badarg, system_limit, or the POSIX error code that most closely describes the error, or einval if no POSIX code is appropriate:

During use of a port opened using {spawn, Name}, {spawn_driver, Name}, or {spawn_executable, Name}, errors arising when sending messages to it are reported to the owning process using signals of the form {'EXIT', Port, PosixCode}. For the possible values of PosixCode, see file(3).

The maximum number of ports that can be open at the same time can be configured by passing command-line flag +Q to erl(1).

Portable hash function that gives the same hash for the same Erlang term regardless of machine architecture and ERTS version (the BIF was introduced in ERTS 4.9.1.1). The function returns a hash value for Term within the range 1..Range. The maximum value for Range is 2^32.

Returns a string corresponding to the text representation of Pid.

Performs a synchronous call to a port. The meaning of Operation and Data depends on the port, that is, on the port driver. Not all port drivers support this feature.

Port is a port identifier, referring to a driver.

Operation is an integer, which is passed on to the driver.

Data is any Erlang term. This data is converted to binary term format and sent to the port.

Returns a term from the driver. The meaning of the returned data also depends on the port driver.

Failures:

Closes an open port. Roughly the same as Port ! {self(), close} except for the error behavior (see below), being synchronous, and that the port does not reply with {Port, closed}. Any process can close a port with port_close/1, not only the port owner (the connected process). If the calling process is linked to the port identified by Port, the exit signal from the port is guaranteed to be delivered before port_close/1 returns.

For comparison: Port ! {self(), close} only fails with badarg if Port does not refer to a port or a process. If Port is a closed port, nothing happens. If Port is an open port and the calling process is the port owner, the port replies with {Port, closed} when all buffers have been flushed and the port really closes. If the calling process is not the port owner, the port owner fails with badsig.

Notice that any process can close a port using Port ! {PortOwner, close} as if it itself was the port owner, but the reply always goes to the port owner.

As from Erlang/OTP R16, Port ! {PortOwner, close} is truly asynchronous. Notice that this operation has always been documented as an asynchronous operation, while the underlying implementation has been synchronous. port_close/1 is however still fully synchronous because of its error behavior.

Failure: badarg if Port is not an identifier of an open port, or the registered name of an open port. If the calling process was previously linked to the closed port, identified by Port, the exit signal from the port is guaranteed to be delivered before this badarg exception occurs.

Sends data to a port. Same as Port ! {PortOwner, {command, Data}} except for the error behavior and being synchronous (see below). Any process can send data to a port with port_command/2, not only the port owner (the connected process).

For comparison: Port ! {PortOwner, {command, Data}} only fails with badarg if Port does not refer to a port or a process. If Port is a closed port, the data message disappears without a sound. If Port is open and the calling process is not the port owner, the port owner fails with badsig. The port owner fails with badsig also if Data is an invalid I/O list.

Notice that any process can send to a port using Port ! {PortOwner, {command, Data}} as if it itself was the port owner.

If the port is busy, the calling process is suspended until the port is not busy any more.

As from Erlang/OTP R16, Port ! {PortOwner, {command, Data}} is truly asynchronous. Notice that this operation has always been documented as an asynchronous operation, while the underlying implementation has been synchronous. port_command/2 is however still fully synchronous because of its error behavior.

Failures:

Sends data to a port. port_command(Port, Data, []) equals port_command(Port, Data).

If the port command is aborted, false is returned, otherwise true.

If the port is busy, the calling process is suspended until the port is not busy anymore.

Options:

Failures:

Sets the port owner (the connected port) to Pid. Roughly the same as Port ! {Owner, {connect, Pid}} except for the following:

The old port owner stays linked to the port and must call unlink(Port) if this is not desired. Any process can set the port owner to be any process with port_connect/2.

For comparison: Port ! {self(), {connect, Pid}} only fails with badarg if Port does not refer to a port or a process. If Port is a closed port, nothing happens. If Port is an open port and the calling process is the port owner, the port replies with {Port, connected} to the old port owner. Notice that the old port owner is still linked to the port, while the new is not. If Port is an open port and the calling process is not the port owner, the port owner fails with badsig. The port owner fails with badsig also if Pid is not an existing local process identifier.

Notice that any process can set the port owner using Port ! {PortOwner, {connect, Pid}} as if it itself was the port owner, but the reply always goes to the port owner.

As from Erlang/OTP R16, Port ! {PortOwner, {connect, Pid}} is truly asynchronous. Notice that this operation has always been documented as an asynchronous operation, while the underlying implementation has been synchronous. port_connect/2 is however still fully synchronous because of its error behavior.

Failures:

Performs a synchronous control operation on a port. The meaning of Operation and Data depends on the port, that is, on the port driver. Not all port drivers support this control feature.

Returns a list of integers in the range 0..255, or a binary, depending on the port driver. The meaning of the returned data also depends on the port driver.

Failures:

Returns a list containing tuples with information about Port, or undefined if the port is not open. The order of the tuples is undefined, and all the tuples are not mandatory. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/1 returns undefined.

The result contains information about the following Items:

For more information about the different Items, see port_info/2.

Failure: badarg if Port is not a local port identifier, or an atom.

Pid is the process identifier of the process connected to the port.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Index is the internal index of the port. This index can be used to separate ports.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Bytes is the total number of bytes read from the port.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Pids is a list of the process identifiers of the processes that the port is linked to.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Locking is one of the following:

Notice that these results are highly implementation-specific and can change in a future release.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Bytes is the total number of bytes allocated for this port by the runtime system. The port itself can have allocated memory that is not included in Bytes.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Monitors represent processes monitored by this port.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Returns list of pids that are monitoring given port at the moment.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Name is the command name set by open_port/2.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

OsPid is the process identifier (or equivalent) of an OS process created with open_port({spawn | spawn_executable, Command}, Options). If the port is not the result of spawning an OS process, the value is undefined.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Bytes is the total number of bytes written to the port from Erlang processes using port_command/2, port_command/3, or Port ! {Owner, {command, Data}.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Boolean corresponds to the port parallelism hint used by this port. For more information, see option parallelism of open_port/2.

Bytes is the total number of bytes queued by the port using the ERTS driver queue implementation.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

RegisteredName is the registered name of the port. If the port has no registered name, [] is returned.

If the port identified by Port is not open, undefined is returned. If the port is closed and the calling process was previously linked to the port, the exit signal from the port is guaranteed to be delivered before port_info/2 returns undefined.

Failure: badarg if Port is not a local port identifier, or an atom.

Returns a string corresponding to the text representation of the port identifier Port.

Returns a list of port identifiers corresponding to all the ports existing on the local node.

Notice that an exiting port exists, but is not open.

Returns a list of Erlang modules that are preloaded in the system. As all loading of code is done through the file system, the file system must have been loaded previously. Hence, at least the module init must be preloaded.

Writes information about the local process Pid on standard error. The only allowed value for the atom Type is backtrace, which shows the contents of the call stack, including information about the call chain, with the current function printed first. The format of the output is not further defined.

When trap_exit is set to true, exit signals arriving to a process are converted to {'EXIT', From, Reason} messages, which can be received as ordinary messages. If trap_exit is set to false, the process exits if it receives an exit signal other than normal and the exit signal is propagated to its linked processes. Application processes are normally not to trap exits.

Returns the old value of the flag.

See also exit/2.

Used by a process to redefine the error handler for undefined function calls and undefined registered processes. Inexperienced users are not to use this flag, as code auto-loading depends on the correct operation of the error handling module.

Returns the old value of the flag.

Changes the minimum binary virtual heap size for the calling process.

Returns the old value of the flag.

N must be an integer in the interval 0..10000. If N > 0, call saving is made active for the process. This means that information about the N most recent global function calls, BIF calls, sends, and receives made by the process are saved in a list, which can be retrieved with process_info(Pid, last_calls). A global function call is one in which the module of the function is explicitly mentioned. Only a fixed amount of information is saved, as follows:

If N = 0, call saving is disabled for the process, which is the default. Whenever the size of the call saving list is set, its contents are reset.

Returns the old value of the flag.

Sets or clears flag sensitive for the current process. When a process has been marked as sensitive by calling process_flag(sensitive, true), features in the runtime system that can be used for examining the data or inner working of the process are silently disabled.

Features that are disabled include (but are not limited to) the following:

process_info/1,2 cannot be used to read out the message queue or the process dictionary (both are returned as empty lists).

Stack back-traces cannot be displayed for the process.

In crash dumps, the stack, messages, and the process dictionary are omitted.

If {save_calls,N} has been set for the process, no function calls are saved to the call saving list. (The call saving list is not cleared. Also, send, receive, and time-out events are still added to the list.)

Returns the old value of the flag.

Sets certain flags for the process Pid, in the same manner as process_flag/2. Returns the old value of the flag. The valid values for Flag are only a subset of those allowed in process_flag/2, namely save_calls.

Failure: badarg if Pid is not a local process.

Returns a list of process identifiers corresponding to all the processes currently existing on the local node.

Notice that an exiting process exists, but is not alive. That is, is_process_alive/1 returns false for an exiting process, but its process identifier is part of the result returned from processes/0.

Example:

> processes().
[<0.0.0>,<0.2.0>,<0.4.0>,<0.5.0>,<0.7.0>,<0.8.0>]

Removes old code for Module. Before this BIF is used, check_process_code/2is to be called to check that no processes execute old code in the module.

Failure: badarg if there is no old code for Module.

Adds a new Key to the process dictionary, associated with the value Val, and returns undefined. If Key exists, the old value is deleted and replaced by Val, and the function returns the old value. Example:

> X = put(name, walrus), Y = put(name, carpenter),
Z = get(name),
{X, Y, Z}.
{undefined,walrus,carpenter}

Reads the state of a timer. The same as calling erlang:read_timer(TimerRef, []).

Reads the state of a timer that has been created by either erlang:start_timer or erlang:send_after. TimerRef identifies the timer, and was returned by the BIF that created the timer.

Options:

More Options can be added in the future.

If Result is an integer, it represents the time in milliseconds left until the timer expires.

If Result is false, a timer corresponding to TimerRef could not be found. This because the timer had expired, or been canceled, or because TimerRef never has corresponded to a timer. Even if the timer has expired, it does not tell you whether or not the time-out message has arrived at its destination yet.

See also erlang:send_after/4, erlang:start_timer/4, and erlang:cancel_timer/2.

Returns a string corresponding to the text representation of Ref.

Associates the name RegName with a process identifier (pid) or a port identifier. RegName, which must be an atom, can be used instead of the pid or port identifier in send operator (RegName ! Message). Example:

> register(db, Pid).
true

Failures:

Returns a list of names that have been registered using register/2, for example:

> registered().
[code_server, file_server, init, user, my_db]

Decreases the suspend count on the process identified by Suspendee. Suspendee is previously to have been suspended through erlang:suspend_process/2 or erlang:suspend_process/1 by the process calling erlang:resume_process(Suspendee). When the suspend count on Suspendee reaches zero, Suspendee is resumed, that is, its state is changed from suspended into the state it had before it was suspended.

Failures:

Returns an integer by rounding Number, for example:

round(5.5).
6

Allowed in guard tests.

Returns the process identifier of the calling process, for example:

> self().
<0.26.0>

Allowed in guard tests.

Starts a timer. The same as calling erlang:send_after(Time, Dest, Msg, []).

Starts a timer. When the timer expires, the message Msg is sent to the process identified by Dest. Apart from the format of the time-out message, this function works exactly as erlang:start_timer/4.

Sets the magic cookie of Node to the atom Cookie. If Node is the local node, the function also sets the cookie of all other unknown nodes to Cookie (see section Distributed Erlang in the Erlang Reference Manual in System Documentation).

Failure: function_clause if the local node is not alive.

Returns a tuple that is a copy of argument Tuple1 with the element specified by integer argument Index (the first element is the element with index 1) replaced by argument Value, for example:

> setelement(2, {10, green, bottles}, red).
{10,red,bottles}

Returns the number of elements in a tuple or the number of bytes in a binary or bitstring, for example:

> size({morni, mulle, bwange}).
3
> size(<<11, 22, 33>>).
3

For bitstrings, the number of whole bytes is returned. That is, if the number of bits in the bitstring is not divisible by 8, the resulting number of bytes is rounded down.

Allowed in guard tests.

See also tuple_size/1, byte_size/1, and bit_size/1.

Returns the process identifier of a new process started by the application of Fun to the empty list []. Otherwise works like spawn/3.

Returns the process identifier of a new process started by the application of Fun to the empty list [] on Node. If Node does not exist, a useless pid is returned. Otherwise works like spawn/3.

Returns the process identifier of a new process started by the application of Module:Function to Args.

error_handler:undefined_function(Module, Function, Args) is evaluated by the new process if Module:Function/Arity does not exist (where Arity is the length of Args). The error handler can be redefined (see process_flag/2). If error_handler is undefined, or the user has redefined the default error_handler and its replacement is undefined, a failure with reason undef occurs.

Example:

> spawn(speed, regulator, [high_speed, thin_cut]).
<0.13.1>

Returns the process identifier (pid) of a new process started by the application of Module:Function to Args on Node. If Node does not exist, a useless pid is returned. Otherwise works like spawn/3.

Returns the process identifier of a new process started by the application of Fun to the empty list []. A link is created between the calling process and the new process, atomically. Otherwise works like spawn/3.

Returns the process identifier (pid) of a new process started by the application of Fun to the empty list [] on Node. A link is created between the calling process and the new process, atomically. If Node does not exist, a useless pid is returned and an exit signal with reason noconnection is sent to the calling process. Otherwise works like spawn/3.

Returns the process identifier of a new process started by the application of Module:Function to Args. A link is created between the calling process and the new process, atomically. Otherwise works like spawn/3.

Returns the process identifier (pid) of a new process started by the application of Module:Function to Args on Node. A link is created between the calling process and the new process, atomically. If Node does not exist, a useless pid is returned and an exit signal with reason noconnection is sent to the calling process. Otherwise works like spawn/3.

Returns the process identifier of a new process, started by the application of Fun to the empty list [], and a reference for a monitor created to the new process. Otherwise works like spawn/3.

A new process is started by the application of Module:Function to Args. The process is monitored at the same time. Returns the process identifier and a reference for the monitor. Otherwise works like spawn/3.

Returns a tuple containing the binaries that are the result of splitting Bin into two parts at position Pos. This is not a destructive operation. After the operation, there are three binaries altogether. Example:

> B = list_to_binary("0123456789").
<<"0123456789">>
> byte_size(B).
10
> {B1, B2} = split_binary(B,3).
{<<"012">>,<<"3456789">>}
> byte_size(B1).
3
> byte_size(B2).
7

Starts a timer. The same as calling erlang:start_timer(Time, Dest, Msg, []).

Starts a timer. When the timer expires, the message {timeout, TimerRef, Msg} is sent to the process identified by Dest.

Options:

More Options can be added in the future.

The absolute point in time, the timer is set to expire on, must be in the interval [ erlang:system_info(start_time), erlang:system_info(end_time)]. If a relative time is specified, the Time value is not allowed to be negative.

If Dest is a pid(), it must be a pid() of a process created on the current runtime system instance. This process has either terminated or not. If Dest is an atom(), it is interpreted as the name of a locally registered process. The process referred to by the name is looked up at the time of timer expiration. No error is returned if the name does not refer to a process.

If Dest is a pid(), the timer is automatically canceled if the process referred to by the pid() is not alive, or if the process exits. This feature was introduced in ERTS 5.4.11. Notice that timers are not automatically canceled when Dest is an atom().

See also erlang:send_after/4, erlang:cancel_timer/2, and erlang:read_timer/2.

Failure: badarg if the arguments do not satisfy the requirements specified here.

Returns a list where each element represents the amount of active processes and ports on each run queue and its associated scheduler. That is, the number of processes and ports that are ready to run, or are currently running. The element location in the list corresponds to the scheduler and its run queue. The first element corresponds to scheduler number 1 and so on. The information is not gathered atomically. That is, the result is not necessarily a consistent snapshot of the state, but instead quite efficiently gathered.

See also statistics(total_active_tasks), statistics(run_queue_lengths), and statistics(total_run_queue_lengths).

Returns the total number of context switches since the system started.

Returns the number of exact reductions.

Returns information about garbage collection, for example:

> statistics(garbage_collection).
{85,23961,0}

This information can be invalid for some implementations.

Returns Input, which is the total number of bytes received through ports, and Output, which is the total number of bytes output to ports.

Microstate accounting can be used to measure how much time the Erlang runtime system spends doing various tasks. It is designed to be as lightweight as possible, but some overhead exists when this is enabled. Microstate accounting is meant to be a profiling tool to help finding performance bottlenecks. To start/stop/reset microstate accounting, use system flag microstate_accounting.

statistics(microstate_accounting) returns a list of maps representing some of the OS threads within ERTS. Each map contains type and id fields that can be used to identify what thread it is, and also a counters field that contains data about how much time has been spent in the various states.

Example:

> erlang:statistics(microstate_accounting).
[#{counters => #{aux => 1899182914,
                 check_io => 2605863602,
                 emulator => 45731880463,
                 gc => 1512206910,
                 other => 5421338456,
                 port => 221631,
                 sleep => 5150294100},
   id => 1,
   type => scheduler}|...]

The time unit is the same as returned by os:perf_counter/0. So, to convert it to milliseconds, you can do something like this:

lists:map(
  fun(#{ counters := Cnt } = M) ->
          MsCnt = maps:map(fun(_K, PerfCount) ->
                                   erlang:convert_time_unit(PerfCount, perf_counter, 1000)
                           end, Cnt),
         M#{ counters := MsCnt }
  end, erlang:statistics(microstate_accounting)).

Notice that these values are not guaranteed to be the exact time spent in each state. This is because of various optimisation done to keep the overhead as small as possible.

MSAcc_Thread_Types:

The following MSAcc_Thread_States are available. All states are exclusive, meaning that a thread cannot be in two states at once. So, if you add the numbers of all counters in a thread, you get the total runtime for that thread.

More fine-grained MSAcc_Thread_States can be added through configure (such as ./configure --with-microstate-accounting=extra). Enabling these states causes performance degradation when microstate accounting is turned off and increases the overhead when it is turned on.

The utility module msacc(3) can be used to more easily analyse these statistics.

Returns undefined if system flag microstate_accounting is turned off.

The list of thread information is unsorted and can appear in different order between calls.

Returns information about reductions, for example:

> statistics(reductions).
{2046,11}

Returns the total length of the run-queues. That is, the number of processes and ports that are ready to run on all available run-queues. The information is gathered atomically. That is, the result is a consistent snapshot of the state, but this operation is much more expensive compared to statistics(total_run_queue_lengths), especially when a large amount of schedulers is used.

Returns a list where each element represents the amount of processes and ports ready to run for each run queue. The element location in the list corresponds to the run queue of a scheduler. The first element corresponds to the run queue of scheduler number 1 and so on. The information is not gathered atomically. That is, the result is not necessarily a consistent snapshot of the state, but instead quite efficiently gathered.

See also statistics(total_run_queue_lengths), statistics(active_tasks), and statistics(total_active_tasks).

Returns information about runtime, in milliseconds.

This is the sum of the runtime for all threads in the Erlang runtime system and can therefore be greater than the wall clock time.

Example:

> statistics(runtime).
{1690,1620}

Returns a list of tuples with {SchedulerId, ActiveTime, TotalTime}, where SchedulerId is an integer ID of the scheduler, ActiveTime is the duration the scheduler has been busy, and TotalTime is the total time duration since scheduler_wall_time activation for the specific scheduler. Note that activation time can differ significantly between schedulers. Currently dirty schedulers are activated at system start while normal schedulers are activated some time after the scheduler_wall_time functionality is enabled. The time unit is undefined and can be subject to change between releases, OSs, and system restarts. scheduler_wall_time is only to be used to calculate relative values for scheduler utilization. ActiveTime can never exceed TotalTime.

The definition of a busy scheduler is when it is not idle and is not scheduling (selecting) a process or port, that is:

Notice that a scheduler can also be busy even if the OS has scheduled out the scheduler thread.

Returns undefined if system flag scheduler_wall_time is turned off.

The list of scheduler information is unsorted and can appear in different order between calls.

As of ERTS version 9.0, also dirty CPU schedulers will be included in the result. That is, all scheduler threads that are expected to handle CPU bound work. If you also want information about dirty I/O schedulers, use statistics(scheduler_wall_time_all) instead.

Normal schedulers will have scheduler identifiers in the range 1 =< SchedulerId =< erlang:system_info(schedulers). Dirty CPU schedulers will have scheduler identifiers in the range erlang:system_info(schedulers) < SchedulerId =< erlang:system_info(schedulers) + erlang:system_info(dirty_cpu_schedulers).

Using scheduler_wall_time to calculate scheduler utilization:

> erlang:system_flag(scheduler_wall_time, true).
false
> Ts0 = lists:sort(erlang:statistics(scheduler_wall_time)), ok.
ok

Some time later the user takes another snapshot and calculates scheduler utilization per scheduler, for example:

> Ts1 = lists:sort(erlang:statistics(scheduler_wall_time)), ok.
ok
> lists:map(fun({{I, A0, T0}, {I, A1, T1}}) ->
	{I, (A1 - A0)/(T1 - T0)} end, lists:zip(Ts0,Ts1)).
[{1,0.9743474730177548},
 {2,0.9744843782751444},
 {3,0.9995902361669045},
 {4,0.9738012596572161},
 {5,0.9717956667018103},
 {6,0.9739235846420741},
 {7,0.973237033077876},
 {8,0.9741297293248656}]

Using the same snapshots to calculate a total scheduler utilization:

> {A, T} = lists:foldl(fun({{_, A0, T0}, {_, A1, T1}}, {Ai,Ti}) ->
	{Ai + (A1 - A0), Ti + (T1 - T0)} end, {0, 0}, lists:zip(Ts0,Ts1)),
	TotalSchedulerUtilization = A/T.
0.9769136803764825

Total scheduler utilization will equal 1.0 when all schedulers have been active all the time between the two measurements.

Another (probably more) useful value is to calculate total scheduler utilization weighted against maximum amount of available CPU time:

> WeightedSchedulerUtilization = (TotalSchedulerUtilization
                                  * (erlang:system_info(schedulers)
                                     + erlang:system_info(dirty_cpu_schedulers)))
                                 / erlang:system_info(logical_processors_available).
0.9769136803764825

This weighted scheduler utilization will reach 1.0 when schedulers are active the same amount of time as maximum available CPU time. If more schedulers exist than available logical processors, this value may be greater than 1.0.

As of ERTS version 9.0, the Erlang runtime system with SMP support will as default have more schedulers than logical processors. This due to the dirty schedulers.

The same as statistics(scheduler_wall_time), except that it also include information about all dirty I/O schedulers.

Dirty IO schedulers will have scheduler identifiers in the range erlang:system_info(schedulers) + erlang:system_info(dirty_cpu_schedulers) < SchedulerId =< erlang:system_info(schedulers) + erlang:system_info(dirty_cpu_schedulers) + erlang:system_info(dirty_io_schedulers).

Returns the total amount of active processes and ports in the system. That is, the number of processes and ports that are ready to run, or are currently running. The information is not gathered atomically. That is, the result is not necessarily a consistent snapshot of the state, but instead quite efficiently gathered.

See also statistics(active_tasks), statistics(run_queue_lengths), and statistics(total_run_queue_lengths).

Returns the total length of the run queues. That is, the number of processes and ports that are ready to run on all available run queues. The information is not gathered atomically. That is, the result is not necessarily a consistent snapshot of the state, but much more efficiently gathered compared to statistics(run_queue).

See also statistics(run_queue_lengths), statistics(total_active_tasks), and statistics(active_tasks).

Returns information about wall clock. wall_clock can be used in the same manner as runtime, except that real time is measured as opposed to runtime or CPU time.

Suspends the process identified by Suspendee. The same as calling erlang:suspend_process(Suspendee, []).

Increases the suspend count on the process identified by Suspendee and puts it in the suspended state if it is not already in that state. A suspended process is not scheduled for execution until the process has been resumed.

A process can be suspended by multiple processes and can be suspended multiple times by a single process. A suspended process does not leave the suspended state until its suspend count reaches zero. The suspend count of Suspendee is decreased when erlang:resume_process(Suspendee) is called by the same process that called erlang:suspend_process(Suspendee). All increased suspend counts on other processes acquired by a process are automatically decreased when the process terminates.

Options (Opts):

If the suspend count on the process identified by Suspendee is increased, true is returned, otherwise false.

Failures:

Sets the maximum depth of call stack back-traces in the exit reason element of 'EXIT' tuples. The flag also limits the stacktrace depth returned by process_info item current_stacktrace.

Returns the old value of the flag.

Sets the number of dirty CPU schedulers online. Range is , where N is the smallest of the return values of erlang:system_info(dirty_cpu_schedulers) and erlang:system_info(schedulers_online).

Returns the old value of the flag.

The number of dirty CPU schedulers online can change if the number of schedulers online changes. For example, if 12 schedulers and 6 dirty CPU schedulers are online, and system_flag/2 is used to set the number of schedulers online to 6, then the number of dirty CPU schedulers online is automatically decreased by half as well, down to 3. Similarly, the number of dirty CPU schedulers online increases proportionally to increases in the number of schedulers online.

For more information, see erlang:system_info(dirty_cpu_schedulers) and erlang:system_info(dirty_cpu_schedulers_online).

Sets system flag fullsweep_after. Number is a non-negative integer indicating how many times generational garbage collections can be done without forcing a fullsweep collection. The value applies to new processes, while processes already running are not affected.

Returns the old value of the flag.

In low-memory systems (especially without virtual memory), setting the value to 0 can help to conserve memory.

This value can also be set through (OS) environment variable ERL_FULLSWEEP_AFTER.

Turns on/off microstate accounting measurements. When passing reset, all counters are reset to 0.

For more information see statistics(microstate_accounting).

Sets the default minimum heap size for processes. The size is specified in words. The new min_heap_size effects only processes spawned after the change of min_heap_size has been made. min_heap_size can be set for individual processes by using spawn_opt/4 or process_flag/2.

Returns the old value of the flag.

Sets the default minimum binary virtual heap size for processes. The size is specified in words. The new min_bin_vhheap_size effects only processes spawned after the change of min_bin_vheap_size has been made. min_bin_vheap_size can be set for individual processes by using spawn_opt/2,3,4 or process_flag/2.

Returns the old value of the flag.

If multi-scheduling is enabled, more than one scheduler thread is used by the emulator. Multi-scheduling can be blocked in two different ways. Either all schedulers but one is blocked, or all normal schedulers but one is blocked. When only normal schedulers are blocked, dirty schedulers are free to continue to schedule processes.

If BlockState =:= block, multi-scheduling is blocked. That is, one and only one scheduler thread will execute. If BlockState =:= unblock and no one else blocks multi-scheduling, and this process has blocked only once, multi-scheduling is unblocked.

If BlockState =:= block_normal, normal multi-scheduling is blocked. That is, only one normal scheduler thread will execute, but multiple dirty schedulers can execute. If BlockState =:= unblock_normal and no one else blocks normal multi-scheduling, and this process has blocked only once, normal multi-scheduling is unblocked.

One process can block multi-scheduling and normal multi-scheduling multiple times. If a process has blocked multiple times, it must unblock exactly as many times as it has blocked before it has released its multi-scheduling block. If a process that has blocked multi-scheduling or normal multi-scheduling exits, it automatically releases its blocking of multi-scheduling and normal multi-scheduling.

The return values are disabled, blocked, blocked_normal, or enabled. The returned value describes the state just after the call to erlang:system_flag(multi_scheduling, BlockState) has been made. For information about the return values, see erlang:system_info(multi_scheduling).

See also erlang:system_info(multi_scheduling), erlang:system_info(normal_multi_scheduling_blockers), erlang:system_info(multi_scheduling_blockers), and erlang:system_info(schedulers).

Turns on or off scheduler wall time measurements.

For more information, see statistics(scheduler_wall_time).

Sets the number of schedulers online. Range is .

Returns the old value of the flag.

If the emulator was built with support for dirty schedulers, changing the number of schedulers online can also change the number of dirty CPU schedulers online. For example, if 12 schedulers and 6 dirty CPU schedulers are online, and system_flag/2 is used to set the number of schedulers online to 6, then the number of dirty CPU schedulers online is automatically decreased by half as well, down to 3. Similarly, the number of dirty CPU schedulers online increases proportionally to increases in the number of schedulers online.

For more information, see erlang:system_info(schedulers) and erlang:system_info(schedulers_online).

Sets the value of the node trace control word to TCW, which is to be an unsigned integer. For more information, see function set_tcw in section "Match Specifications in Erlang" in the User's Guide.

Returns the old value of the flag.

Finalizes the time offset when single time warp mode is used. If another time warp mode is used, the time offset state is left unchanged.

Returns the old state identifier, that is:

Returns current Erlang system time in native time unit.

Calling erlang:system_time() is equivalent to erlang:monotonic_time() + erlang:time_offset().

Returns current Erlang system time converted into the Unit passed as argument.

Calling erlang:system_time(Unit) is equivalent to erlang:convert_time_unit(erlang:system_time(), native, Unit).

Returns a binary data object that is the result of encoding Term according to the Erlang external term format.

This can be used for various purposes, for example, writing a term to a file in an efficient way, or sending an Erlang term to some type of communications channel not supported by distributed Erlang.

> Bin = term_to_binary(hello).
<<131,100,0,5,104,101,108,108,111>>
> hello = binary_to_term(Bin).
hello

See also binary_to_term/1.

Returns a binary data object that is the result of encoding Term according to the Erlang external term format.

If option compressed is provided, the external term format is compressed. The compressed format is automatically recognized by binary_to_term/1 as from Erlang/OTP R7B.

A compression level can be specified by giving option {compressed, Level}. Level is an integer with range 0..9, where:

Option {minor_version, Version} can be used to control some encoding details. This option was introduced in Erlang/OTP R11B-4. The valid values for Version are 0 and 1.

As from Erlang/OTP 17.0, {minor_version, 1} is the default. It forces any floats in the term to be encoded in a more space-efficient and exact way (namely in the 64-bit IEEE format, rather than converted to a textual representation).

As from Erlang/OTP R11B-4, binary_to_term/1 can decode this representation.

{minor_version, 0} means that floats are encoded using a textual representation. This option is useful to ensure that releases before Erlang/OTP R11B-4 can decode resulting binary.

See also binary_to_term/1.

A non-local return from a function. If evaluated within a catch, catch returns value Any. Example:

> catch throw({hello, there}).
{hello,there}

Failure: nocatch if not evaluated within a catch.

Returns the current time as {Hour, Minute, Second}.

The time zone and Daylight Saving Time correction depend on the underlying OS. Example:

> time().
{9,42,44}

Returns the current time offset between Erlang monotonic time and Erlang system time in native time unit. Current time offset added to an Erlang monotonic time gives corresponding Erlang system time.

The time offset may or may not change during operation depending on the time warp mode used.

Returns the current time offset between Erlang monotonic time and Erlang system time converted into the Unit passed as argument.

Same as calling erlang:convert_time_unit( erlang:time_offset(), native, Unit) however optimized for commonly used Units.

Returns the tail of List, that is, the list minus the first element, for example:

> tl([geesties, guilies, beasties]).
[guilies, beasties]

Allowed in guard tests.

Failure: badarg if List is the empty list [].