| erlang(3erl) | Erlang Module Definition | erlang(3erl) |
erlang - The Erlang BIFs.
By convention, most Built-In Functions (BIFs) are included in this module. Some of the BIFs are viewed more or less as part of the Erlang programming language and are auto-imported. Thus, it is not necessary to specify the module name. For example, the calls atom_to_list(erlang) and erlang:atom_to_list(erlang) are identical.
Auto-imported BIFs are listed without module prefix. BIFs listed with module prefix are not auto-imported.
BIFs can fail for various reasons. All BIFs fail with reason badarg if they are called with arguments of an incorrect type. The other reasons are described in the description of each individual BIF.
Some BIFs can be used in guard tests and are marked with "Allowed in guard tests".
ext_binary() = binary()
A binary data object, structured according to the Erlang external term format.
ext_iovec() = iovec()
A term of type iovec(), structured according to the Erlang external term format.
iovec() = [binary()]
A list of binaries. This datatype is useful to use together with enif_inspect_iovec.
message_queue_data() = off_heap | on_heap
See process_flag(message_queue_data, MQD).
timestamp() =
{MegaSecs :: integer() >= 0,
Secs :: integer() >= 0,
MicroSecs :: integer() >= 0}
See erlang:timestamp/0.
time_unit() =
integer() >= 1 |
second | millisecond | microsecond | nanosecond | native |
perf_counter |
deprecated_time_unit()
Supported time unit representations:
The native time unit is determined at runtime system start, and remains the same until the runtime system terminates. If a runtime system is stopped and then started again (even on the same machine), the native time unit of the new runtime system instance can differ from the native time unit of the old runtime system instance.
One can get an approximation of the native time unit by calling erlang:convert_time_unit(1, second, native). The result equals the number of whole native time units per second. If the number of native time units per second does not add up to a whole number, the result is rounded downwards.
The perf_counter time unit behaves much in the same way as the native time unit. That is, it can differ between runtime restarts. To get values of this type, call os:perf_counter/0.
The time_unit/0 type can be extended. To convert time values between time units, use erlang:convert_time_unit/3.
deprecated_time_unit() =
seconds | milli_seconds | micro_seconds | nano_seconds
The time_unit() type also consist of the following deprecated symbolic time units:
dist_handle()
An opaque handle identifing a distribution channel.
nif_resource()
An opaque handle identifing a NIF resource object .
spawn_opt_option() =
link | monitor |
{priority, Level :: priority_level()} |
{fullsweep_after, Number :: integer() >= 0} |
{min_heap_size, Size :: integer() >= 0} |
{min_bin_vheap_size, VSize :: integer() >= 0} |
{max_heap_size, Size :: max_heap_size()} |
{message_queue_data, MQD :: message_queue_data()}
Options for spawn_opt().
priority_level() = low | normal | high | max
Process priority level. For more info see process_flag(priority, Level)
max_heap_size() =
integer() >= 0 |
#{size => integer() >= 0,
kill => boolean(),
error_logger => boolean()}
Process max heap size configuration. For more info see process_flag(max_heap_size, MaxHeapSize)
message_queue_data() = off_heap | on_heap
Process message queue data configuration. For more info see process_flag(message_queue_data, MQD)
abs(Float) -> float()
abs(Int) -> integer() >= 0
Types:
Returns an integer or float that is the arithmetical absolute value of Float or Int, for example:
> abs(-3.33). 3.33 > abs(-3). 3
Allowed in guard tests.
erlang:adler32(Data) -> integer() >= 0
Types:
Computes and returns the adler32 checksum for Data.
erlang:adler32(OldAdler, Data) -> integer() >= 0
Types:
Continues computing the adler32 checksum by combining the previous checksum, OldAdler, with the checksum of Data.
The following code:
X = erlang:adler32(Data1), Y = erlang:adler32(X,Data2).
assigns the same value to Y as this:
Y = erlang:adler32([Data1,Data2]).
erlang:adler32_combine(FirstAdler, SecondAdler, SecondSize) ->
integer() >= 0
Types:
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:
Y = erlang:adler32(Data1), Z = erlang:adler32(Y,Data2).
assigns the same value to Z as this:
X = erlang:adler32(Data1), Y = erlang:adler32(Data2), Z = erlang:adler32_combine(X,Y,iolist_size(Data2)).
erlang:append_element(Tuple1, Term) -> Tuple2
Types:
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}
apply(Fun, Args) -> term()
Types:
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).
apply(Module, Function, Args) -> term()
Types:
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.
atom_to_binary(Atom) -> binary()
Types:
The same as atom_to_binary(Atom, utf8).
atom_to_binary(Atom, Encoding) -> binary()
Types:
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">>
atom_to_list(Atom) -> string()
Types:
Returns a string corresponding to the text representation of Atom, for example:
> atom_to_list('Erlang').
"Erlang"
binary_part(Subject, PosLen) -> binary()
Types:
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:
1> Bin = <<1,2,3,4,5,6,7,8,9,10>>.
2> binary_part(Bin,{byte_size(Bin), -5}).
<<6,7,8,9,10>>
Failure: badarg if PosLen in any way references outside the binary.
Start is zero-based, that is:
1> Bin = <<1,2,3>>
2> binary_part(Bin,{0,2}).
<<1,2>>
For details about the PosLen semantics, see binary(3erl).
Allowed in guard tests.
binary_part(Subject, Start, Length) -> binary()
Types:
The same as binary_part(Subject, {Start, Length}).
Allowed in guard tests.
binary_to_atom(Binary) -> atom()
Types:
The same as binary_to_atom(Binary, utf8).
binary_to_atom(Binary, Encoding) -> atom()
Types:
Returns the atom whose text representation is Binary. 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).
binary_to_existing_atom(Binary) -> atom()
Types:
The same as binary_to_existing_atom (Binary, utf8).
binary_to_existing_atom(Binary, Encoding) -> atom()
Types:
As binary_to_atom/2, but the atom must exist.
Failure: badarg if the atom does not exist.
binary_to_float(Binary) -> float()
Types:
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.
binary_to_integer(Binary) -> integer()
Types:
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.
binary_to_integer(Binary, Base) -> integer()
Types:
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.
binary_to_list(Binary) -> [byte()]
Types:
Returns a list of integers corresponding to the bytes of Binary.
binary_to_list(Binary, Start, Stop) -> [byte()]
Types:
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.
binary_to_term(Binary) -> term()
Types:
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.
binary_to_term(Binary, Opts) -> term() | {term(), Used}
Types:
As binary_to_term/1, but takes these options:
When enabled, it prevents decoding data that can be used to attack the Erlang system. In the event of receiving unsafe data, decoding fails with a badarg error.
This prevents creation of new atoms directly, creation of new atoms indirectly (as they are embedded in certain structures, such as process identifiers, refs, and funs), and creation of new external function references. None of those resources are garbage collected, so unchecked creation of them can exhaust available memory.
> binary_to_term(<<131,100,0,5,"hello">>, [safe]). ** exception error: bad argument > hello. hello > binary_to_term(<<131,100,0,5,"hello">>, [safe]). hello
> Input = <<131,100,0,5,"hello","world">>.
<<131,100,0,5,104,101,108,108,111,119,111,114,108,100>>
> {Term, Used} = binary_to_term(Input, [used]).
{hello, 9}
> split_binary(Input, Used).
{<<131,100,0,5,104,101,108,108,111>>, <<"world">>}
Failure: badarg if safe is specified and unsafe data is decoded.
See also term_to_binary/1, binary_to_term/1, and list_to_existing_atom/1.
bit_size(Bitstring) -> integer() >= 0
Types:
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.
bitstring_to_list(Bitstring) -> [byte() | bitstring()]
Types:
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.
erlang:bump_reductions(Reductions) -> true
Types:
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).
byte_size(Bitstring) -> integer() >= 0
Types:
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.
erlang:cancel_timer(TimerRef) -> Result
Types:
Cancels a timer. The same as calling erlang:cancel_timer(TimerRef, []).
erlang:cancel_timer(TimerRef, Options) -> Result | ok
Types:
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.
ceil(Number) -> integer()
Types:
Returns the smallest integer not less than Number. For example:
> ceil(5.5). 6
Allowed in guard tests.
check_old_code(Module) -> boolean()
Types:
Returns true if Module has old code, otherwise false.
See also code(3erl).
check_process_code(Pid, Module) -> CheckResult
Types:
The same as check_process_code(Pid, Module, []).
check_process_code(Pid, Module, OptionList) -> CheckResult | async
Types:
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:
As of ERTS version 9.0, the check process code operation only checks for direct references to the code. Indirect references via funs will be ignored. If such funs exist and are used after a purge of the old code, an exception will be raised upon usage (same as the case when the fun is received by the process after the purge). Literals will be taken care of (copied) at a later stage. This behavior can as of ERTS version 8.1 be enabled when building OTP, and will automatically be enabled if dirty scheduler support is enabled.
See also code(3erl).
Failures:
erlang:convert_time_unit(Time, FromUnit, ToUnit) -> ConvertedTime
Types:
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.
erlang:crc32(Data) -> integer() >= 0
Types:
Computes and returns the crc32 (IEEE 802.3 style) checksum for Data.
erlang:crc32(OldCrc, Data) -> integer() >= 0
Types:
Continues computing the crc32 checksum by combining the previous checksum, OldCrc, with the checksum of Data.
The following code:
X = erlang:crc32(Data1), Y = erlang:crc32(X,Data2).
assigns the same value to Y as this:
Y = erlang:crc32([Data1,Data2]).
erlang:crc32_combine(FirstCrc, SecondCrc, SecondSize) ->
integer() >= 0
Types:
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:
Y = erlang:crc32(Data1), Z = erlang:crc32(Y,Data2).
assigns the same value to Z as this:
X = erlang:crc32(Data1), Y = erlang:crc32(Data2), Z = erlang:crc32_combine(X,Y,iolist_size(Data2)).
date() -> Date
Types:
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}
erlang:decode_packet(Type, Bin, Options) ->
{ok, Packet, Rest} |
{more, Length} |
{error, Reason}
Types:
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:
The meanings of the packet types are as follows:
Recognized request methods and header fields are returned as atoms. Others are returned as strings. Strings of unrecognized header fields are formatted with only capital letters first and after hyphen characters, for example, "Sec-Websocket-Key". Header field names are also returned in UnmodifiedField as strings, without any conversion or formatting.
The protocol type http is only to be used for the first line when an HttpRequest or an HttpResponse is expected. The following calls are to use httph to get HttpHeaders until http_eoh is returned, which marks the end of the headers and the beginning of any following message body.
The variants http_bin and httph_bin return strings (HttpString) as binaries instead of lists.
Options:
Option line_length also applies to http* packet types as an alias for option packet_size if packet_size itself is not set. This use is only intended for backward compatibility.
Examples:
> erlang:decode_packet(1,<<3,"abcd">>,[]).
{ok,<<"abc">>,<<"d">>}
> erlang:decode_packet(1,<<5,"abcd">>,[]).
{more,6}
erlang:delete_element(Index, Tuple1) -> Tuple2
Types:
Returns a new tuple with element at Index removed from tuple Tuple1, for example:
> erlang:delete_element(2, {one, two, three}).
{one,three}
delete_module(Module) -> true | undefined
Types:
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.
demonitor(MonitorRef) -> true
Types:
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.
The current behavior can be viewed as two combined operations: asynchronously send a "demonitor signal" to the monitored entity and ignore any future results of the monitor.
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.
demonitor(MonitorRef, OptionList) -> boolean()
Types:
The returned value is true unless info is part of OptionList.
demonitor(MonitorRef, []) is equivalent to demonitor(MonitorRef).
Options:
Calling demonitor(MonitorRef, [flush]) is equivalent to the following, but more efficient:
demonitor(MonitorRef), receive
{_, MonitorRef, _, _, _} ->
true after 0 ->
true end
If option info is combined with option flush, false is returned if a flush was needed, otherwise true.
Failures:
disconnect_node(Node) -> boolean() | ignored
Types:
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.
erlang:display(Term) -> true
Types:
Prints a text representation of Term on the standard output.
erlang:dist_ctrl_get_data(DHandle) -> {Size, Data} | Data | none
Types:
Get distribution channel data from the local node that is to be passed to the remote node. The distribution channel is identified by DHandle. If no data is available, the atom none is returned. One can request to be informed by a message when more data is available by calling erlang:dist_ctrl_get_data_notification(DHandle).
The returned value when there are data available depends on the value of the get_size option configured on the distribution channel identified by DHandle. For more information see the documentation of the get_size option for the erlang:dist_ctrl_set_opt/3 function.
This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.
erlang:dist_ctrl_get_opt(DHandle, Opt :: get_size) -> Value
Types:
Returns the value of the get_size option on the distribution channel identified by DHandle. For more information see the documentation of the get_size option for the erlang:dist_ctrl_set_opt/3 function.
This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.
erlang:dist_ctrl_get_data_notification(DHandle) -> ok
Types:
Request notification when more data is available to fetch using erlang:dist_ctrl_get_data(DHandle) for the distribution channel identified by DHandle. When more data is present, the caller will be sent the message dist_data. Once a dist_data messages has been sent, no more dist_data messages will be sent until the dist_ctrl_get_data_notification/1 function has been called again.
This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.
erlang:dist_ctrl_input_handler(DHandle, InputHandler) -> ok
Types:
Register an alternate input handler process for the distribution channel identified by DHandle. Once this function has been called, InputHandler is the only process allowed to call erlang:dist_ctrl_put_data(DHandle, Data) with the DHandle identifing this distribution channel.
This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.
erlang:dist_ctrl_put_data(DHandle, Data) -> ok
Types:
Deliver distribution channel data from a remote node to the local node.
This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.
erlang:dist_ctrl_set_opt(DHandle, Opt :: get_size, Value) ->
OldValue
Types:
Sets the value of the get_size option on the distribution channel identified by DHandle. This option controls the return value of calls to erlang:dist_ctrl_get_data(DHandle) where DHandle equals DHandle used when setting this option. When the get_size option is:
All options are set to default when a channel is closed.
This function is used when implementing an alternative distribution carrier using processes as distribution controllers. DHandle is retrived via the callback f_handshake_complete. More information can be found in the documentation of ERTS User's Guide ➜ How to implement an Alternative Carrier for the Erlang Distribution ➜ Distribution Module.
element(N, Tuple) -> term()
Types:
Returns the Nth element (numbering from 1) of Tuple, for example:
> element(2, {a, b, c}).
b
Allowed in guard tests.
erase() -> [{Key, Val}]
Types:
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]}]
erase(Key) -> Val | undefined
Types:
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}
error(Reason) -> no_return()
Types:
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,[{shell,apply_fun,3,
[{file,"shell.erl"},{line,906}]},
{erl_eval,do_apply,6,[{file,"erl_eval.erl"},{line,677}]},
{erl_eval,expr,5,[{file,"erl_eval.erl"},{line,430}]},
{shell,exprs,7,[{file,"shell.erl"},{line,687}]},
{shell,eval_exprs,7,[{file,"shell.erl"},{line,642}]},
{shell,eval_loop,3,[{file,"shell.erl"},{line,627}]}]}}
error(Reason, Args) -> no_return()
Types:
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.
exit(Reason) -> no_return()
Types:
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}
exit(Pid, Reason) -> true
Types:
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.
erlang:external_size(Term) -> integer() >= 0
Types:
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:
erlang:external_size(Term, [])
erlang:external_size(Term, Options) -> integer() >= 0
Types:
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.
float(Number) -> float()
Types:
Returns a float by converting Number to a float, for example:
> float(55). 55.0
Allowed in guard tests.
When float/1 is used in an expression in a guard, such as 'float(A) == 4.0', it converts a number as described earlier.
float_to_binary(Float) -> binary()
Types:
The same as float_to_binary(Float,[{scientific,20}]).
float_to_binary(Float, Options) -> binary()
Types:
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">>
float_to_list(Float) -> string()
Types:
The same as float_to_list(Float,[{scientific,20}]).
float_to_list(Float, Options) -> string()
Types:
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"
floor(Number) -> integer()
Types:
Returns the largest integer not greater than Number. For example:
> floor(-10.5). -11
Allowed in guard tests.
erlang:fun_info(Fun) -> [{Item, Info}]
Types:
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:
If Fun is a local fun, Module is the module in which the fun is defined.
If Fun is an external fun, Module is the module that the fun refers to.
If Fun is a local fun, Name is the name of the local function that implements the fun. (This name was generated by the compiler, and is only of informational use. As it is a local function, it cannot be called directly.) If no code is currently loaded for the fun, [] is returned instead of an atom.
If Fun is an external fun, Name is the name of the exported function that the fun refers to.
The following elements are only present in the list if Fun is local:
It might point to the init process if the Fun was statically allocated when module was loaded (this optimisation is performed for local functions that do not capture the environment).
erlang:fun_info(Fun, Item) -> {Item, Info}
Types:
fun_info_item() =
arity | env | index | name | module | new_index | new_uniq |
pid | type | uniq
Returns information about Fun as specified by Item, in the form {Item,Info}.
For any fun, Item can be any of the atoms module, name, arity, env, or type.
For a local fun, Item can also be any of the atoms index, new_index, new_uniq, uniq, and pid. For an external fun, the value of any of these items is always the atom undefined.
See erlang:fun_info/1.
erlang:fun_to_list(Fun) -> string()
Types:
Returns a string corresponding to the text representation of Fun.
erlang:function_exported(Module, Function, Arity) -> boolean()
Types:
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.
garbage_collect() -> true
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.
garbage_collect(Pid) -> GCResult
Types:
The same as garbage_collect(Pid, []).
garbage_collect(Pid, OptionList) -> GCResult | async
Types:
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:
get() -> [{Key, Val}]
Types:
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}}]
get(Key) -> Val | undefined
Types:
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}
erlang:get_cookie() -> Cookie | nocookie
Types:
Returns the magic cookie of the local node if the node is alive, otherwise the atom nocookie.
get_keys() -> [Key]
Types:
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]
get_keys(Val) -> [Key]
Types:
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]
erlang:get_stacktrace() -> [stack_item()]
Types:
stack_item() =
{Module :: module(),
Function :: atom(),
Arity :: arity() | (Args :: [term()]),
Location ::
[{file, Filename :: string()} |
{line, Line :: integer() >= 1}]}
Instead of using erlang:get_stacktrace/0 to retrieve the call stack back-trace, use the following syntax:
try Expr catch
Class:Reason:Stacktrace ->
{Class,Reason,Stacktrace} end
group_leader() -> pid()
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.
group_leader(GroupLeader, Pid) -> true
Types:
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.
The group leader should be rarely changed in applications with a supervision tree, because OTP assumes the group leader of their processes is their application master.
See also group_leader/0 and OTP design principles related to starting and stopping applications.
halt() -> no_return()
The same as halt(0, []). Example:
> halt(). os_prompt%
halt(Status) -> no_return()
Types:
The same as halt(Status, []). Example:
> halt(17). os_prompt% echo $? 17 os_prompt%
halt(Status, Options) -> no_return()
Types:
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.
hd(List) -> term()
Types:
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 [].
erlang:hibernate(Module, Function, Args) -> no_return()
Types:
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.
erlang:insert_element(Index, Tuple1, Term) -> Tuple2
Types:
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}
integer_to_binary(Integer) -> binary()
Types:
Returns a binary corresponding to the text representation of Integer, for example:
> integer_to_binary(77). <<"77">>
integer_to_binary(Integer, Base) -> binary()
Types:
Returns a binary corresponding to the text representation of Integer in base Base, for example:
> integer_to_binary(1023, 16). <<"3FF">>
integer_to_list(Integer) -> string()
Types:
Returns a string corresponding to the text representation of Integer, for example:
> integer_to_list(77). "77"
integer_to_list(Integer, Base) -> string()
Types:
Returns a string corresponding to the text representation of Integer in base Base, for example:
> integer_to_list(1023, 16). "3FF"
iolist_size(Item) -> integer() >= 0
Types:
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
iolist_to_binary(IoListOrBinary) -> binary()
Types:
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>>
erlang:iolist_to_iovec(IoListOrBinary) -> iovec()
Types:
Returns an iovec that is made from the integers and binaries in IoListOrBinary.
is_alive() -> boolean()
Returns true if the local node is alive (that is, if the node can be part of a distributed system), otherwise false.
is_atom(Term) -> boolean()
Types:
Returns true if Term is an atom, otherwise false.
Allowed in guard tests.
is_binary(Term) -> boolean()
Types:
Returns true if Term is a binary, otherwise false.
A binary always contains a complete number of bytes.
Allowed in guard tests.
is_bitstring(Term) -> boolean()
Types:
Returns true if Term is a bitstring (including a binary), otherwise false.
Allowed in guard tests.
is_boolean(Term) -> boolean()
Types:
Returns true if Term is the atom true or the atom false (that is, a boolean). Otherwise returns false.
Allowed in guard tests.
erlang:is_builtin(Module, Function, Arity) -> boolean()
Types:
This BIF is useful for builders of cross-reference tools.
Returns true if Module:Function/Arity is a BIF implemented in C, otherwise false.
is_float(Term) -> boolean()
Types:
Returns true if Term is a floating point number, otherwise false.
Allowed in guard tests.
is_function(Term) -> boolean()
Types:
Returns true if Term is a fun, otherwise false.
Allowed in guard tests.
is_function(Term, Arity) -> boolean()
Types:
Returns true if Term is a fun that can be applied with Arity number of arguments, otherwise false.
Allowed in guard tests.
is_integer(Term) -> boolean()
Types:
Returns true if Term is an integer, otherwise false.
Allowed in guard tests.
is_list(Term) -> boolean()
Types:
Returns true if Term is a list with zero or more elements, otherwise false.
Allowed in guard tests.
is_map(Term) -> boolean()
Types:
Returns true if Term is a map, otherwise false.
Allowed in guard tests.
is_map_key(Key, Map) -> boolean()
Types:
Returns true if map Map contains Key and returns false if it does not contain the Key.
The call fails with a {badmap,Map} exception if Map is not a map.
Example:
> Map = #{"42" => value}.
#{"42" => value}
> is_map_key("42",Map).
true
> is_map_key(value,Map).
false
Allowed in guard tests.
is_number(Term) -> boolean()
Types:
Returns true if Term is an integer or a floating point number. Otherwise returns false.
Allowed in guard tests.
is_pid(Term) -> boolean()
Types:
Returns true if Term is a process identifier, otherwise false.
Allowed in guard tests.
is_port(Term) -> boolean()
Types:
Returns true if Term is a port identifier, otherwise false.
Allowed in guard tests.
is_process_alive(Pid) -> boolean()
Types:
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.
is_record(Term, RecordTag) -> boolean()
Types:
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.
is_record(Term, RecordTag, Size) -> boolean()
Types:
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.
is_reference(Term) -> boolean()
Types:
Returns true if Term is a reference, otherwise false.
Allowed in guard tests.
is_tuple(Term) -> boolean()
Types:
Returns true if Term is a tuple, otherwise false.
Allowed in guard tests.
length(List) -> integer() >= 0
Types:
Returns the length of List, for example:
> length([1,2,3,4,5,6,7,8,9]). 9
Allowed in guard tests.
link(PidOrPort) -> true
Types:
Creates a link between the calling process and another process (or port) PidOrPort. If the link already exists or a process attempts to create a link to itself, nothing is done. Returns true if the link is set up.
If PidOrPort does not exist and checking it is cheap, a noproc error is raised. Currently, checking is cheap if the PidOrPort is local and the caller does not trap exits (see process_flag/2 ).
Apart from any exit signals from the linked process itself, two special exit signals may be sent to the calling process:
See Processes ➜ Links in the Erlang Reference Manual for more details.
list_to_atom(String) -> atom()
Types:
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'
list_to_binary(IoList) -> binary()
Types:
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>>
list_to_bitstring(BitstringList) -> bitstring()
Types:
bitstring_list() =
maybe_improper_list(byte() | bitstring() | bitstring_list(),
bitstring() | [])
Returns a bitstring that is made from the integers and bitstrings in BitstringList. (The last tail in BitstringList is allowed to be a bitstring.) Example:
> Bin1 = <<1,2,3>>. <<1,2,3>> > Bin2 = <<4,5>>. <<4,5>> > Bin3 = <<6,7:4>>. <<6,7:4>> > list_to_bitstring([Bin1,1,[2,3,Bin2],4|Bin3]). <<1,2,3,1,2,3,4,5,4,6,7:4>>
list_to_existing_atom(String) -> atom()
Types:
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.
list_to_float(String) -> float()
Types:
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.
list_to_integer(String) -> integer()
Types:
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.
list_to_integer(String, Base) -> integer()
Types:
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.
list_to_pid(String) -> pid()
Types:
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.
list_to_port(String) -> port()
Types:
Returns a port identifier whose text representation is a String, for example:
> list_to_port("#Port<0.4>").
#Port<0.4>
Failure: badarg if String contains a bad representation of a port identifier.
list_to_ref(String) -> reference()
Types:
Returns a reference whose text representation is a String, for example:
> list_to_ref("#Ref<0.4192537678.4073193475.71181>").
#Ref<0.4192537678.4073193475.71181>
Failure: badarg if String contains a bad representation of a reference.
list_to_tuple(List) -> tuple()
Types:
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.
load_module(Module, Binary) -> {module, Module} | {error, Reason}
Types:
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:
erlang:load_nif(Path, LoadInfo) -> ok | Error
Types:
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(3erl).
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:
erlang:loaded() -> [Module]
Types:
Returns a list of all loaded Erlang modules (current and old code), including preloaded modules.
See also code(3erl).
erlang:localtime() -> DateTime
Types:
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.
erlang:localtime_to_universaltime(Localtime) -> Universaltime
Types:
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.
erlang:localtime_to_universaltime(Localtime, IsDst) ->
Universaltime
Types:
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.
make_ref() -> reference()
Returns a unique reference. The reference is unique among connected nodes.
erlang:make_tuple(Arity, InitialValue) -> tuple()
Types:
Creates a new tuple of the specified Arity, where all elements are InitialValue, for example:
> erlang:make_tuple(4, []).
{[],[],[],[]}
erlang:make_tuple(Arity, DefaultValue, InitList) -> tuple()
Types:
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}
map_get(Key, Map) -> Value
Types:
Returns value Value associated with Key if Map contains Key.
The call fails with a {badmap,Map} exception if Map is not a map, or with a {badkey,Key} exception if no value is associated with Key.
Example:
> Key = 1337,
Map = #{42 => value_two,1337 => "value one","a" => 1},
map_get(Key,Map). "value one"
Allowed in guard tests.
map_size(Map) -> integer() >= 0
Types:
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.
erlang:match_spec_test(MatchAgainst, MatchSpec, Type) ->
TestResult
Types:
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.
max(Term1, Term2) -> Maximum
Types:
Returns the largest of Term1 and Term2. If the terms are equal, Term1 is returned.
erlang:md5(Data) -> Digest
Types:
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.
erlang:md5_final(Context) -> Digest
Types:
Finishes the update of an MD5 Context and returns the computed MD5 message digest.
erlang:md5_init() -> Context
Types:
Creates an MD5 context, to be used in the following calls to md5_update/2.
erlang:md5_update(Context, Data) -> NewContext
Types:
Update an MD5 Context with Data and returns a NewContext.
erlang:memory() -> [{Type, Size}]
Types:
memory_type() =
total | processes | processes_used | system | atom |
atom_used | binary | code | ets
Returns a list with information about memory dynamically allocated by the Erlang emulator. Each list element is a tuple {Type, Size}. The first element Type is an atom describing memory type. The second element Size is the memory size in bytes.
Memory types:
Can be removed in a future release of the halfword emulator.
For information on how to run the emulator with instrumentation, see instrument(3erl) and/or erl(1).
When the emulator is run with instrumentation, the system value is more accurate, but memory directly allocated for malloc (and friends) is still not part of the system value. Direct calls to malloc are only done from OS-specific runtime libraries and perhaps from user-implemented Erlang drivers that do not use the memory allocation functions in the driver interface.
As the total value is the sum of processes and system, the error in system propagates to the total value.
The different amounts of memory that are summed are not gathered atomically, which introduces an error in the result.
The different values have the following relation to each other. Values beginning with an uppercase letter is not part of the result.
total = processes + system processes = processes_used + ProcessesNotUsed system = atom + binary + code + ets + OtherSystem atom = atom_used + AtomNotUsed RealTotal = processes + RealSystem RealSystem = system + MissedSystem
More tuples in the returned list can be added in a future release.
Also, because of fragmentation and prereservation of memory areas, the size of the memory segments containing the dynamically allocated memory blocks can be much larger than the total size of the dynamically allocated memory blocks.
Failure: notsup if an erts_alloc(3erl) allocator has been disabled.
erlang:memory(Type :: memory_type()) -> integer() >= 0
erlang:memory(TypeList :: [memory_type()]) ->
[{memory_type(), integer() >= 0}]
Types:
memory_type() =
total | processes | processes_used | system | atom |
atom_used | binary | code | ets
Returns the memory size in bytes allocated for memory of type Type. The argument can also be specified as a list of memory_type() atoms, in which case a corresponding list of {memory_type(), Size :: integer >= 0} tuples is returned.
Failures:
See also erlang:memory/0.
min(Term1, Term2) -> Minimum
Types:
Returns the smallest of Term1 and Term2. If the terms are equal, Term1 is returned.
module_loaded(Module) -> boolean()
Types:
Returns true if the module Module is loaded, otherwise false. It does not attempt to load the module.
monitor(Type :: process, Item :: monitor_process_identifier()) ->
MonitorRef
monitor(Type :: port, Item :: monitor_port_identifier()) ->
MonitorRef
monitor(Type :: time_offset, Item :: clock_service) -> MonitorRef
Types:
registered_name() = atom()
registered_process_identifier() =
registered_name() | {registered_name(), node()}
monitor_process_identifier() =
pid() | registered_process_identifier()
monitor_port_identifier() = port() | registered_name()
Sends a monitor request of type Type to the entity identified by Item. If the monitored entity does not exist or it changes monitored state, the caller of monitor/2 is notified by a message on the following format:
{Tag, MonitorRef, Type, Object, Info}
Type can be one of the following atoms: process, port or time_offset.
A process or port monitor is triggered only once, after that it is removed from both monitoring process and the monitored entity. Monitors are fired when the monitored process or port terminates, does not exist at the moment of creation, or if the connection to it is lost. If the connection to it is lost, we do not know if it still exists. The monitoring is also turned off when demonitor/1 is called.
A process or port monitor by name resolves the RegisteredName to pid() or port() only once at the moment of monitor instantiation, later changes to the name registration will not affect the existing monitor.
When a process or port monitor is triggered, a 'DOWN' message is sent that has the following pattern:
{'DOWN', MonitorRef, Type, Object, Info}
In the monitor message MonitorRef and Type are the same as described earlier, and:
Now, such a call to monitor will instead succeed and a monitor is created. But the monitor will only supervise the connection. That is, a {'DOWN', _, process, _, noconnection} is the only message that may be received, as the primitive node have no way of reporting the status of the monitored process.
The monitor is triggered when the time offset is changed. This either if the time offset value is changed, or if the offset is changed from preliminary to final during finalization of the time offset when the single time warp mode is used. When a change from preliminary to final time offset is made, the monitor is triggered once regardless of whether the time offset value was changed or not.
If the runtime system is in multi time warp mode, the time offset is changed when the runtime system detects that the OS system time has changed. The runtime system does, however, not detect this immediately when it occurs. A task checking the time offset is scheduled to execute at least once a minute, so under normal operation this is to be detected within a minute, but during heavy load it can take longer time.
The monitor is not automatically removed after it has been triggered. That is, repeated changes of the time offset trigger the monitor repeatedly.
When the monitor is triggered a 'CHANGE' message is sent to the monitoring process. A 'CHANGE' message has the following pattern:
{'CHANGE', MonitorRef, Type, Item, NewTimeOffset}
where MonitorRef, Type, and Item are the same as described above, and NewTimeOffset is the new time offset.
When the 'CHANGE' message has been received you are guaranteed not to retrieve the old time offset when calling erlang:time_offset(). Notice that you can observe the change of the time offset when calling erlang:time_offset() before you get the 'CHANGE' message.
Making several calls to monitor/2 for the same Item and/or Type is not an error; it results in as many independent monitoring instances.
The monitor functionality is expected to be extended. That is, other Types and Items are expected to be supported in a future release.
monitor_node(Node, Flag) -> true
Types:
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.
erlang:monitor_node(Node, Flag, Options) -> true
Types:
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.
erlang:monotonic_time() -> integer()
Returns the current Erlang monotonic time in native time unit. This is a monotonically increasing time since some unspecified point in time.
Different runtime system instances will use different unspecified points in time as base for their Erlang monotonic clocks. That is, it is pointless comparing monotonic times from different runtime system instances. Different runtime system instances can also place this unspecified point in time different relative runtime system start. It can be placed in the future (time at start is a negative value), the past (time at start is a positive value), or the runtime system start (time at start is zero). The monotonic time at runtime system start can be retrieved by calling erlang:system_info(start_time).
erlang:monotonic_time(Unit) -> integer()
Types:
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.
erlang:nif_error(Reason) -> no_return()
Types:
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.
erlang:nif_error(Reason, Args) -> no_return()
Types:
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.
node() -> Node
Types:
Returns the name of the local node. If the node is not alive, nonode@nohost is returned instead.
Allowed in guard tests.
node(Arg) -> Node
Types:
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.
nodes() -> Nodes
Types:
Returns a list of all visible nodes in the system, except the local node. Same as nodes(visible).
nodes(Arg) -> Nodes
Types:
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).
now() -> Timestamp
Types:
timestamp() =
{MegaSecs :: integer() >= 0,
Secs :: integer() >= 0,
MicroSecs :: integer() >= 0}
For more information, see section Time and Time Correction in the User's Guide. Specifically, section Dos and Dont's describes what to use instead of erlang:now/0.
Returns the tuple {MegaSecs, Secs, MicroSecs}, which is the elapsed time since 00:00 GMT, January 1, 1970 (zero hour), if provided by the underlying OS. Otherwise some other point in time is chosen. It is also guaranteed that the following calls to this BIF return continuously increasing values. Hence, the return value from erlang:now/0 can be used to generate unique time stamps. If it is called in a tight loop on a fast machine, the time of the node can become skewed.
Can only be used to check the local time of day if the time-zone information of the underlying OS is properly configured.
open_port(PortName, PortSettings) -> port()
Types:
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(3erl), the function file:native_name_encoding/0 in Kernel, and the Using Unicode in Erlang User's Guide.
PortNames:
For external programs, PATH is searched (or an equivalent method is used to find programs, depending on the OS). This is done by invoking the shell on certain platforms. The first space-separated token of the command is considered as the name of the executable (or driver). This (among other things) makes this option unsuitable for running programs with spaces in filenames or directory names. If spaces in executable filenames are desired, use {spawn_executable, Command} instead.
The shell is usually not invoked to start the program, it is executed directly. PATH (or equivalent) is not searched. To find a program in PATH to execute, use os:find_executable/1.
Only if a shell script or .bat file is executed, the appropriate command interpreter is invoked implicitly, but there is still no command-argument expansion or implicit PATH search.
If FileName cannot be run, an error exception is raised, with the POSIX error code as the reason. The error reason can differ between OSs. Typically the error enoent is raised when an attempt is made to run a program that is not found and eacces is raised when the specified file is not executable.
PortSettings is a list of settings for the port. The valid settings are as follows:
L specifies the maximum line length in bytes. Lines longer than this are delivered in more than one message, with Flag set to noeol for all but the last message. If end of file is encountered anywhere else than immediately following a newline sequence, the last line is also delivered with Flag set to noeol. Otherwise lines are delivered with Flag set to eol.
The {packet, N} and {line, L} settings are mutually exclusive.
Only valid for {spawn, Command}, and {spawn_executable, FileName}. The environment of the started process is extended using the environment specifications in Env.
Env is to be a list of tuples {Name, Val}, where Name is the name of an environment variable, and Val is the value it is to have in the spawned port process. Both Name and Val must be strings. The one exception is Val being the atom false (in analogy with os:getenv/1, which removes the environment variable.
For information about encoding requirements, see documentation of the types for Name and Val.
The arguments are not expanded by the shell before they are supplied to the executable. Most notably this means that file wildcard expansion does not occur. To expand wildcards for the arguments, use filelib:wildcard/1. Notice that even if the program is a Unix shell script, meaning that the shell ultimately is invoked, wildcard expansion does not occur, and the script is provided with the untouched arguments. On Windows, wildcard expansion is always up to the program itself, therefore this is not an issue.
The executable name (also known as argv[0]) is not to be specified in this list. The proper executable name is automatically used as argv[0], where applicable.
If you explicitly want to set the program name in the argument vector, option arg0 can be used.
When the external process connected to the port exits, a message of the form {Port,{exit_status,Status}} is sent to the connected process, where Status is the exit status of the external process. If the program aborts on Unix, the same convention is used as the shells do (that is, 128+signal).
If option eof is specified also, the messages eof and exit_status appear in an unspecified order.
If the port program closes its stdout without exiting, option exit_status does not work.
Sets scheduler hint for port parallelism. If set to true, the virtual machine schedules port tasks; when doing so, it improves parallelism in the system. If set to false, the virtual machine tries to perform port tasks immediately, improving latency at the expense of parallelism. The default can be set at system startup by passing command-line argument +spp to erl(1).
When the ports internal output queue size becomes larger than or equal to High bytes, it enters the busy state. When it becomes less than Low bytes it leaves the busy state. When the port is in the busy state, processes sending commands to it will be suspended until the port leaves the busy state. Commands are in this context either Port ! {Owner, {command, Data}} or port_command/[2,3].
The Low limit is automatically adjusted to the same as High if it is set larger then High. Valid range of values for Low and High is [1, (1 bsl (8*erlang:system_info(wordsize)))-2]. If the atom disabled is passed, the port will never enter the busy state.
The defaults are Low = 4096 and High = 8192.
Note that this option is only valid when spawning an executable (port program) by opening the spawn driver and when opening the fd driver. This option will cause a failure with a badarg exception when opening other drivers.
When the ports message queue size becomes larger than or equal to High bytes it enters the busy state. When it becomes less than Low bytes it leaves the busy state. When the port message queue is in the busy state, processes sending commands to it will be suspended until the port message queue leaves the busy state. Commands are in this context either Port ! {Owner, {command, Data}} or port_command/[2,3].
The Low limit is automatically adjusted to the same as High if it is set larger then High. Valid range of values for Low and High is [1, (1 bsl (8*erlang:system_info(wordsize)))-2]. If the atom disabled is passed, the port message queue will never enter the busy state.
Note that if the driver statically has disabled the use of this feature, a failure with a badarg exception will be raised unless this option also is set to disable or not passed at all.
The defaults are Low = 4096 and High = 8192 unless the driver itself does modifications of these values.
Note that the driver might fail if it also adjust these limits by itself and you have disabled this feature.
The spawn driver (used when spawning an executable) and the fd driver do not disable this feature and do not adjust these limits by themselves.
For more information see the documentation erl_drv_busy_msgq_limits().
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(3erl).
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).
erlang:phash(Term, Range) -> Hash
Types:
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.
erlang:phash2(Term) -> Hash
erlang:phash2(Term, Range) -> Hash
Types:
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 5.2). The function returns a hash value for Term within the range 0..Range-1. The maximum value for Range is 2^32. When without argument Range, a value in the range 0..2^27-1 is returned.
This BIF is always to be used for hashing terms. It distributes small integers better than phash/2, and it is faster for bignums and binaries.
Notice that the range 0..Range-1 is different from the range of phash/2, which is 1..Range.
pid_to_list(Pid) -> string()
Types:
Returns a string corresponding to the text representation of Pid.
erlang:port_call(Port, Operation, Data) -> term()
Types:
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:
port_close(Port) -> true
Types:
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.
port_command(Port, Data) -> true
Types:
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:
port_command(Port, Data, OptionList) -> boolean()
Types:
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:
port_connect(Port, Pid) -> true
Types:
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:
port_control(Port, Operation, Data) -> iodata() | binary()
Types:
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:
erlang:port_info(Port) -> Result
Types:
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.
erlang:port_info(Port, Item :: connected) ->
{connected, Pid} | undefined
Types:
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.
erlang:port_info(Port, Item :: id) -> {id, Index} | undefined
Types:
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.
erlang:port_info(Port, Item :: input) ->
{input, Bytes} | undefined
Types:
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.
erlang:port_info(Port, Item :: links) -> {links, Pids} | undefined
Types:
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.
erlang:port_info(Port, Item :: locking) ->
{locking, Locking} | undefined
Types:
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.
erlang:port_info(Port, Item :: memory) ->
{memory, Bytes} | undefined
Types:
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.
erlang:port_info(Port, Item :: monitors) ->
{monitors, Monitors} | undefined
Types:
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.
erlang:port_info(Port, Item :: monitored_by) ->
{monitored_by, MonitoredBy} | undefined
Types:
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.
erlang:port_info(Port, Item :: name) -> {name, Name} | undefined
Types:
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.
erlang:port_info(Port, Item :: os_pid) ->
{os_pid, OsPid} | undefined
Types:
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.
erlang:port_info(Port, Item :: output) ->
{output, Bytes} | undefined
Types:
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.
erlang:port_info(Port, Item :: parallelism) ->
{parallelism, Boolean} | undefined
Types:
Boolean corresponds to the port parallelism hint used by this port. For more information, see option parallelism of open_port/2.
erlang:port_info(Port, Item :: queue_size) ->
{queue_size, Bytes} | undefined
Types:
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.
erlang:port_info(Port, Item :: registered_name) ->
{registered_name, RegisteredName} |
[] | undefined
Types:
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.
port_to_list(Port) -> string()
Types:
Returns a string corresponding to the text representation of the port identifier Port.
erlang:ports() -> [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.
pre_loaded() -> [module()]
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.
erlang:process_display(Pid, Type) -> true
Types:
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.
process_flag(Flag :: trap_exit, Boolean) -> OldBoolean
Types:
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.
process_flag(Flag :: error_handler, Module) -> OldModule
Types:
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.
process_flag(Flag :: min_heap_size, MinHeapSize) -> OldMinHeapSize
Types:
Changes the minimum heap size for the calling process.
Returns the old value of the flag.
process_flag(Flag :: min_bin_vheap_size, MinBinVHeapSize) ->
OldMinBinVHeapSize
Types:
Changes the minimum binary virtual heap size for the calling process.
Returns the old value of the flag.
process_flag(Flag :: max_heap_size, MaxHeapSize) -> OldMaxHeapSize
Types:
max_heap_size() =
integer() >= 0 |
#{size => integer() >= 0,
kill => boolean(),
error_logger => boolean()}
This flag sets the maximum heap size for the calling process. If MaxHeapSize is an integer, the system default values for kill and error_logger are used.
size is the entire heap of the process when garbage collection is triggered. This includes all generational heaps, the process stack, any messages that are considered to be part of the heap, and any extra memory that the garbage collector needs during collection.
size is the same as can be retrieved using erlang:process_info(Pid, total_heap_size), or by adding heap_block_size, old_heap_block_size and mbuf_size from erlang:process_info(Pid, garbage_collection_info).
If kill is not defined in the map, the system default will be used. The default system default is true. It can be changed by either option +hmaxk in erl(1), or erlang:system_flag(max_heap_size, MaxHeapSize).
If error_logger is not defined in the map, the system default is used. The default system default is true. It can be changed by either the option +hmaxel int erl(1), or erlang:system_flag(max_heap_size, MaxHeapSize).
The heap size of a process is quite hard to predict, especially the amount of memory that is used during the garbage collection. When contemplating using this option, it is recommended to first run it in production with kill set to false and inspect the log events to see what the normal peak sizes of the processes in the system is and then tune the value accordingly.
process_flag(Flag :: message_queue_data, MQD) -> OldMQD
Types:
message_queue_data() = off_heap | on_heap
This flag determines how messages in the message queue are stored, as follows:
The default message_queue_data process flag is determined by command-line argument +hmqd in erl(1).
If the process potentially can get many messages in its queue, you are advised to set the flag to off_heap. This because a garbage collection with many messages placed on the heap can become extremely expensive and the process can consume large amounts of memory. Performance of the actual message passing is however generally better when not using flag off_heap.
When changing this flag messages will be moved. This work has been initiated but not completed when this function call returns.
Returns the old value of the flag.
process_flag(Flag :: priority, Level) -> OldLevel
Types:
priority_level() = low | normal | high | max
Sets the process priority. Level is an atom. Four priority levels exist: low, normal, high, and max. Default is normal.
Internally in each priority level, processes are scheduled in a round robin fashion.
Execution of processes on priority normal and low are interleaved. Processes on priority low are selected for execution less frequently than processes on priority normal.
When runnable processes on priority high exist, no processes on priority low or normal are selected for execution. Notice however that this does not mean that no processes on priority low or normal can run when processes are running on priority high. When using multiple schedulers, more processes can be running in parallel than processes on priority high. That is, a low and a high priority process can execute at the same time.
When runnable processes on priority max exist, no processes on priority low, normal, or high are selected for execution. As with priority high, processes on lower priorities can execute in parallel with processes on priority max.
Scheduling is pre-emptive. Regardless of priority, a process is pre-empted when it has consumed more than a certain number of reductions since the last time it was selected for execution.
There is no automatic mechanism for avoiding priority inversion, such as priority inheritance or priority ceilings. When using priorities, take this into account and handle such scenarios by yourself.
Making calls from a high priority process into code that you has no control over can cause the high priority process to wait for a process with lower priority. That is, effectively decreasing the priority of the high priority process during the call. Even if this is not the case with one version of the code that you have no control over, it can be the case in a future version of it. This can, for example, occur if a high priority process triggers code loading, as the code server runs on priority normal.
Other priorities than normal are normally not needed. When other priorities are used, use them with care, especially priority high. A process on priority high is only to perform work for short periods. Busy looping for long periods in a high priority process causes most likely problems, as important OTP servers run on priority normal.
Returns the old value of the flag.
process_flag(Flag :: save_calls, N) -> OldN
Types:
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.
process_flag(Flag :: sensitive, Boolean) -> OldBoolean
Types:
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.
process_flag(Pid, Flag, Value) -> OldValue
Types:
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.
process_info(Pid) -> Info
Types:
process_info_result_item() =
{backtrace, Bin :: binary()} |
{binary,
BinInfo ::
[{integer() >= 0,
integer() >= 0,
integer() >= 0}]} |
{catchlevel, CatchLevel :: integer() >= 0} |
{current_function,
{Module :: module(), Function :: atom(), Arity :: arity()} |
undefined} |
{current_location,
{Module :: module(),
Function :: atom(),
Arity :: arity(),
Location ::
[{file, Filename :: string()} |
{line, Line :: integer() >= 1}]}} |
{current_stacktrace, Stack :: [stack_item()]} |
{dictionary, Dictionary :: [{Key :: term(), Value :: term()}]} |
{error_handler, Module :: module()} |
{garbage_collection, GCInfo :: [{atom(), integer() >= 0}]} |
{garbage_collection_info,
GCInfo :: [{atom(), integer() >= 0}]} |
{group_leader, GroupLeader :: pid()} |
{heap_size, Size :: integer() >= 0} |
{initial_call, mfa()} |
{links, PidsAndPorts :: [pid() | port()]} |
{last_calls, false | (Calls :: [mfa()])} |
{memory, Size :: integer() >= 0} |
{message_queue_len, MessageQueueLen :: integer() >= 0} |
{messages, MessageQueue :: [term()]} |
{min_heap_size, MinHeapSize :: integer() >= 0} |
{min_bin_vheap_size, MinBinVHeapSize :: integer() >= 0} |
{max_heap_size, MaxHeapSize :: max_heap_size()} |
{monitored_by,
MonitoredBy :: [pid() | port() | nif_resource()]} |
{monitors,
Monitors ::
[{process | port,
Pid ::
pid() |
port() |
{RegName :: atom(), Node :: node()}}]} |
{message_queue_data, MQD :: message_queue_data()} |
{priority, Level :: priority_level()} |
{reductions, Number :: integer() >= 0} |
{registered_name, [] | (Atom :: atom())} |
{sequential_trace_token,
[] | (SequentialTraceToken :: term())} |
{stack_size, Size :: integer() >= 0} |
{status,
Status ::
exiting | garbage_collecting | waiting | running |
runnable | suspended} |
{suspending,
SuspendeeList ::
[{Suspendee :: pid(),
ActiveSuspendCount :: integer() >= 0,
OutstandingSuspendCount :: integer() >= 0}]} |
{total_heap_size, Size :: integer() >= 0} |
{trace, InternalTraceFlags :: integer() >= 0} |
{trap_exit, Boolean :: boolean()}
priority_level() = low | normal | high | max
stack_item() =
{Module :: module(),
Function :: atom(),
Arity :: arity() | (Args :: [term()]),
Location ::
[{file, Filename :: string()} |
{line, Line :: integer() >= 1}]}
max_heap_size() =
integer() >= 0 |
#{size => integer() >= 0,
kill => boolean(),
error_logger => boolean()}
message_queue_data() = off_heap | on_heap
Returns a list containing InfoTuples with miscellaneous information about the process identified by Pid, or undefined if the process is not alive.
The order of the InfoTuples is undefined and all InfoTuples are not mandatory. The InfoTuples part of the result can be changed without prior notice.
The InfoTuples with the following items are part of the result:
If the process identified by Pid has a registered name, also an InfoTuple with item registered_name is included.
For information about specific InfoTuples, see process_info/2.
Failure: badarg if Pid is not a local process.
process_info(Pid, Item) -> InfoTuple | [] | undefined
process_info(Pid, ItemList) -> InfoTupleList | [] | undefined
Types:
process_info_item() =
backtrace | binary | catchlevel | current_function |
current_location | current_stacktrace | dictionary |
error_handler | garbage_collection | garbage_collection_info |
group_leader | heap_size | initial_call | links | last_calls |
memory | message_queue_len | messages | min_heap_size |
min_bin_vheap_size | monitored_by | monitors |
message_queue_data | priority | reductions | registered_name |
sequential_trace_token | stack_size | status | suspending |
total_heap_size | trace | trap_exit
process_info_result_item() =
{backtrace, Bin :: binary()} |
{binary,
BinInfo ::
[{integer() >= 0,
integer() >= 0,
integer() >= 0}]} |
{catchlevel, CatchLevel :: integer() >= 0} |
{current_function,
{Module :: module(), Function :: atom(), Arity :: arity()} |
undefined} |
{current_location,
{Module :: module(),
Function :: atom(),
Arity :: arity(),
Location ::
[{file, Filename :: string()} |
{line, Line :: integer() >= 1}]}} |
{current_stacktrace, Stack :: [stack_item()]} |
{dictionary, Dictionary :: [{Key :: term(), Value :: term()}]} |
{error_handler, Module :: module()} |
{garbage_collection, GCInfo :: [{atom(), integer() >= 0}]} |
{garbage_collection_info,
GCInfo :: [{atom(), integer() >= 0}]} |
{group_leader, GroupLeader :: pid()} |
{heap_size, Size :: integer() >= 0} |
{initial_call, mfa()} |
{links, PidsAndPorts :: [pid() | port()]} |
{last_calls, false | (Calls :: [mfa()])} |
{memory, Size :: integer() >= 0} |
{message_queue_len, MessageQueueLen :: integer() >= 0} |
{messages, MessageQueue :: [term()]} |
{min_heap_size, MinHeapSize :: integer() >= 0} |
{min_bin_vheap_size, MinBinVHeapSize :: integer() >= 0} |
{max_heap_size, MaxHeapSize :: max_heap_size()} |
{monitored_by,
MonitoredBy :: [pid() | port() | nif_resource()]} |
{monitors,
Monitors ::
[{process | port,
Pid ::
pid() |
port() |
{RegName :: atom(), Node :: node()}}]} |
{message_queue_data, MQD :: message_queue_data()} |
{priority, Level :: priority_level()} |
{reductions, Number :: integer() >= 0} |
{registered_name, [] | (Atom :: atom())} |
{sequential_trace_token,
[] | (SequentialTraceToken :: term())} |
{stack_size, Size :: integer() >= 0} |
{status,
Status ::
exiting | garbage_collecting | waiting | running |
runnable | suspended} |
{suspending,
SuspendeeList ::
[{Suspendee :: pid(),
ActiveSuspendCount :: integer() >= 0,
OutstandingSuspendCount :: integer() >= 0}]} |
{total_heap_size, Size :: integer() >= 0} |
{trace, InternalTraceFlags :: integer() >= 0} |
{trap_exit, Boolean :: boolean()}
stack_item() =
{Module :: module(),
Function :: atom(),
Arity :: arity() | (Args :: [term()]),
Location ::
[{file, Filename :: string()} |
{line, Line :: integer() >= 1}]}
priority_level() = low | normal | high | max
max_heap_size() =
integer() >= 0 |
#{size => integer() >= 0,
kill => boolean(),
error_logger => boolean()}
message_queue_data() = off_heap | on_heap
Returns information about the process identified by Pid, as specified by Item or ItemList. Returns undefined if the process is not alive.
If the process is alive and a single Item is specified, the returned value is the corresponding InfoTuple, unless Item =:= registered_name and the process has no registered name. In this case, [] is returned. This strange behavior is because of historical reasons, and is kept for backward compatibility.
If ItemList is specified, the result is InfoTupleList. The InfoTuples in InfoTupleList are included with the corresponding Items in the same order as the Items were included in ItemList. Valid Items can be included multiple times in ItemList.
Valid InfoTuples with corresponding Items:
The message queue is on the heap depending on the process flag message_queue_data.
Size is the size in bytes of the process. This includes call stack, heap, and internal structures.
ActiveSuspendCount is the number of times Suspendee has been suspended by Pid. OutstandingSuspendCount is the number of not yet completed suspend requests sent by Pid, that is:
Notice that ActiveSuspendCount and OutstandingSuspendCount are not the total suspend count on Suspendee, only the parts contributed by Pid.
Notice that not all implementations support all these Items.
Failures:
processes() -> [pid()]
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>]
purge_module(Module) -> true
Types:
Removes old code for Module. Before this BIF is used, check_process_code/2 is to be called to check that no processes execute old code in the module.
Failure: badarg if there is no old code for Module.
put(Key, Val) -> term()
Types:
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}
erlang:raise(Class, Reason, Stacktrace) -> no_return()
Types:
raise_stacktrace() =
[{module(), atom(), arity() | [term()]} |
{function(), [term()]}] |
[{module(), atom(), arity() | [term()], [{atom(), term()}]} |
{function(), [term()], [{atom(), term()}]}]
Stops the execution of the calling process with an exception of the specified class, reason, and call stack backtrace (stacktrace).
Class is error, exit, or throw. So, if it were not for the stacktrace, erlang:raise(Class, Reason, Stacktrace) is equivalent to erlang:Class(Reason).
Reason can be any term.
Stacktrace is a list as provided in a try-catch clause.
try
... catch Class:Reason:Stacktrace ->
... end
That is, a list of four-tuples {Module, Function, Arity | Args, Location}, where Module and Function are atoms, and the third element is an integer arity or an argument list. The stacktrace can also contain {Fun, Args, Location} tuples, where Fun is a local fun and Args is an argument list.
Element Location at the end is optional. Omitting it is equivalent to specifying an empty list.
The stacktrace is used as the exception stacktrace for the calling process; it is truncated to the current maximum stacktrace depth.
As evaluating this function causes the process to terminate, it has no return value unless the arguments are invalid, in which case the function returns the error reason badarg. If you want to be sure not to return, you can call error(erlang:raise(Class, Reason, Stacktrace)) and hope to distinguish exceptions later.
erlang:read_timer(TimerRef) -> Result
Types:
Reads the state of a timer. The same as calling erlang:read_timer(TimerRef, []).
erlang:read_timer(TimerRef, Options) -> Result | ok
Types:
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.
ref_to_list(Ref) -> string()
Types:
Returns a string corresponding to the text representation of Ref.
register(RegName, PidOrPort) -> true
Types:
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:
registered() -> [RegName]
Types:
Returns a list of names that have been registered using register/2, for example:
> registered(). [code_server, file_server, init, user, my_db]
erlang:resume_process(Suspendee) -> true
Types:
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:
round(Number) -> integer()
Types:
Returns an integer by rounding Number, for example:
round(5.5). 6
Allowed in guard tests.
self() -> pid()
Returns the process identifier of the calling process, for example:
> self(). <0.26.0>
Allowed in guard tests.
erlang:send(Dest, Msg) -> Msg
Types:
dst() =
pid() |
port() |
(RegName :: atom()) |
{RegName :: atom(), Node :: node()}
Sends a message and returns Msg. This is the same as using the send operator: Dest ! Msg.
Dest can be a remote or local process identifier, a (local) port, a locally registered name, or a tuple {RegName, Node} for a registered name at another node.
The function fails with a badarg run-time error if Dest is an atom name, but this name is not registered. This is the only case when send fails for an unreachable destination Dest (of correct type).
erlang:send(Dest, Msg, Options) -> Res
Types:
dst() =
pid() |
port() |
(RegName :: atom()) |
{RegName :: atom(), Node :: node()}
Either sends a message and returns ok, or does not send the message but returns something else (see below). Otherwise the same as erlang:send/2. For more detailed explanation and warnings, see erlang:send_nosuspend/2,3.
Options:
erlang:send_after(Time, Dest, Msg) -> TimerRef
Types:
Starts a timer. The same as calling erlang:send_after(Time, Dest, Msg, []).
erlang:send_after(Time, Dest, Msg, Options) -> TimerRef
Types:
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.
erlang:send_nosuspend(Dest, Msg) -> boolean()
Types:
dst() =
pid() |
port() |
(RegName :: atom()) |
{RegName :: atom(), Node :: node()}
The same as erlang:send(Dest, Msg, [nosuspend]), but returns true if the message was sent and false if the message was not sent because the sender would have had to be suspended.
This function is intended for send operations to an unreliable remote node without ever blocking the sending (Erlang) process. If the connection to the remote node (usually not a real Erlang node, but a node written in C or Java) is overloaded, this function does not send the message and returns false.
The same occurs if Dest refers to a local port that is busy. For all other destinations (allowed for the ordinary send operator '!'), this function sends the message and returns true.
This function is only to be used in rare circumstances where a process communicates with Erlang nodes that can disappear without any trace, causing the TCP buffers and the drivers queue to be over-full before the node is shut down (because of tick time-outs) by net_kernel. The normal reaction to take when this occurs is some kind of premature shutdown of the other node.
Notice that ignoring the return value from this function would result in an unreliable message passing, which is contradictory to the Erlang programming model. The message is not sent if this function returns false.
In many systems, transient states of overloaded queues are normal. Although this function returns false does not mean that the other node is guaranteed to be non-responsive, it could be a temporary overload. Also, a return value of true does only mean that the message can be sent on the (TCP) channel without blocking; the message is not guaranteed to arrive at the remote node. For a disconnected non-responsive node, the return value is true (mimics the behavior of operator !). The expected behavior and the actions to take when the function returns false are application- and hardware-specific.
erlang:send_nosuspend(Dest, Msg, Options) -> boolean()
Types:
dst() =
pid() |
port() |
(RegName :: atom()) |
{RegName :: atom(), Node :: node()}
The same as erlang:send(Dest, Msg, [nosuspend | Options]), but with a Boolean return value.
This function behaves like erlang:send_nosuspend/2, but takes a third parameter, a list of options. The only option is noconnect, which makes the function return false if the remote node is not currently reachable by the local node. The normal behavior is to try to connect to the node, which can stall the process during a short period. The use of option noconnect makes it possible to be sure not to get the slightest delay when sending to a remote process. This is especially useful when communicating with nodes that expect to always be the connecting part (that is, nodes written in C or Java).
Whenever the function returns false (either when a suspend would occur or when noconnect was specified and the node was not already connected), the message is guaranteed not to have been sent.
erlang:set_cookie(Node, Cookie) -> true
Types:
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.
setelement(Index, Tuple1, Value) -> Tuple2
Types:
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}
size(Item) -> integer() >= 0
Types:
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.
spawn(Fun) -> pid()
Types:
Returns the process identifier of a new process started by the application of Fun to the empty list []. Otherwise works like spawn/3.
spawn(Node, Fun) -> pid()
Types:
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.
spawn(Module, Function, Args) -> pid()
Types:
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>
spawn(Node, Module, Function, Args) -> pid()
Types:
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.
spawn_link(Fun) -> pid()
Types:
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.
spawn_link(Node, Fun) -> pid()
Types:
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.
spawn_link(Module, Function, Args) -> pid()
Types:
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.
spawn_link(Node, Module, Function, Args) -> pid()
Types:
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.
spawn_monitor(Fun) -> {pid(), reference()}
Types:
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.
spawn_monitor(Node, Fun) -> {pid(), reference()}
Types:
Returns the process identifier of a new process, started by the application of Fun to the empty list [] on the node Node, and a reference for a monitor created to the new process. Otherwise works like spawn/3.
If the node identified by Node does not support distributed spawn_monitor(), the call will fail with a notsup exception.
spawn_monitor(Module, Function, Args) -> {pid(), reference()}
Types:
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.
spawn_monitor(Node, Module, Function, Args) ->
{pid(), reference()}
Types:
A new process is started by the application of Module:Function to Args on the node Node. The process is monitored at the same time. Returns the process identifier and a reference for the monitor. Otherwise works like spawn/3.
If the node identified by Node does not support distributed spawn_monitor(), the call will fail with a notsup exception.
spawn_opt(Fun, Options) -> pid() | {pid(), reference()}
Types:
priority_level() = low | normal | high | max
max_heap_size() =
integer() >= 0 |
#{size => integer() >= 0,
kill => boolean(),
error_logger => boolean()}
message_queue_data() = off_heap | on_heap
spawn_opt_option() =
link | monitor |
{priority, Level :: priority_level()} |
{fullsweep_after, Number :: integer() >= 0} |
{min_heap_size, Size :: integer() >= 0} |
{min_bin_vheap_size, VSize :: integer() >= 0} |
{max_heap_size, Size :: max_heap_size()} |
{message_queue_data, MQD :: message_queue_data()}
Returns the process identifier (pid) of a new process started by the application of Fun to the empty list []. Otherwise works like spawn_opt/4.
If option monitor is specified, the newly created process is monitored, and both the pid and reference for the monitor are returned.
spawn_opt(Node, Fun, Options) -> pid() | {pid(), reference()}
Types:
Returns the process identifier (pid) 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_opt/4.
Valid options depends on what options are supported by the node identified by Node. A description of valid Options for the local node of current OTP version can be found in the documentation of spawn_opt/4.
spawn_opt(Module, Function, Args, Options) ->
pid() | {pid(), reference()}
Types:
priority_level() = low | normal | high | max
max_heap_size() =
integer() >= 0 |
#{size => integer() >= 0,
kill => boolean(),
error_logger => boolean()}
message_queue_data() = off_heap | on_heap
spawn_opt_option() =
link | monitor |
{priority, Level :: priority_level()} |
{fullsweep_after, Number :: integer() >= 0} |
{min_heap_size, Size :: integer() >= 0} |
{min_bin_vheap_size, VSize :: integer() >= 0} |
{max_heap_size, Size :: max_heap_size()} |
{message_queue_data, MQD :: message_queue_data()}
Works as spawn/3, except that an extra option list is specified when creating the process.
If option monitor is specified, the newly created process is monitored, and both the pid and reference for the monitor are returned.
Options:
The Erlang runtime system uses a generational garbage collection scheme, using an "old heap" for data that has survived at least one garbage collection. When there is no more room on the old heap, a fullsweep garbage collection is done.
Option fullsweep_after makes it possible to specify the maximum number of generational collections before forcing a fullsweep, even if there is room on the old heap. Setting the number to zero disables the general collection algorithm, that is, all live data is copied at every garbage collection.
A few cases when it can be useful to change fullsweep_after:
Gives a minimum heap size, in words. Setting this value higher than the system default can speed up some processes because less garbage collection is done. However, setting a too high value can waste memory and slow down the system because of worse data locality. Therefore, use this option only for fine-tuning an application and to measure the execution time with various Size values.
Gives a minimum binary virtual heap size, in words. Setting this value higher than the system default can speed up some processes because less garbage collection is done. However, setting a too high value can waste memory. Therefore, use this option only for fine-tuning an application and to measure the execution time with various VSize values.
spawn_opt(Node, Module, Function, Args, Options) ->
pid() | {pid(), reference()}
Types:
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_opt/4.
Valid options depends on what options are supported by the node identified by Node. A description of valid Options for the local node of current OTP version can be found in the documentation of spawn_opt/4.
spawn_request(Fun) -> ReqId
Types:
The same as the call spawn_request(node(),Fun,[]). That is, a spawn request on the local node with no options.
spawn_request(Fun, Options) -> ReqId
Types:
The same as the call spawn_request(node(),Fun,Options). That is, a spawn request on the local node.
spawn_request(Node, Fun) -> ReqId
Types:
The same as the call spawn_request(Node,Fun,[]). That is, a spawn request with no options.
spawn_request(Node, Fun, Options) -> ReqId
Types:
The same as spawn_request(Node,erlang,apply,[Fun,[]],Options). That is, a spawn request using the fun Fun of arity zero as entry point.
This function will fail with a badarg exception if:
spawn_request(Module, Function, Args) -> ReqId
Types:
The same as the call spawn_request(node(),Module,Function,Args,[]). That is, a spawn request on the local node with no options.
spawn_request(Node, Module, Function, Args) -> ReqId
Types:
The same as the call spawn_request(Node,Module,Function,Args,[]). That is, a spawn request with no options.
spawn_request(Module, Function, Args, Options) -> ReqId
Types:
The same as the call spawn_request(node(),Module,Function,Args,Options). That is, a spawn request on the local node.
spawn_request(Node, Module, Function, Args, Options) -> ReqId
Types:
Asynchronously send a spawn request. Returns a request identifier ReqId.
If the spawn operation succeeds, a new process is created on the node identified by Node. When a spawn operation succeeds, the caller will by default be sent a message on the form {ReplyTag, ReqId, ok, Pid} where Pid is the process identifier of the newly created process. Such a message is referred to as a success message below in the text. ReplyTag is by default the atom spawn_reply unless modified by the {reply_tag, ReplyTag} option. The new process is started by the application of Module:Function to Args.
The spawn operation fails either if creation of a new process failed or if the spawn operation was interrupted by a connection failure. When a spawn operation fails, the caller will by default be sent a message on the form {ReplyTag, ReqId, error, Reason} where Reason is the error reason. Such a message is referred to as an error message below in the text. Currently the following spawn error Reasons are defined, but other reasons can appear at any time without prior notice:
Valid Options:
The monitor will not be activated for the calling process until the spawn operation has succeeded. The monitor can not be demonitored before the operation has succeeded. A 'DOWN' message for the corresponding monitor is guaranteed not to be delivered before a success message that corresponds to the spawn operation. If the spawn operation fails, no 'DOWN' message will be delivered.
If the connection between the nodes involved in the spawn operation is lost during the spawn operation, the spawn operation will fail with an error reason of noconnection. A new process may or may not have been created.
The link will not be activated for the calling process until the spawn operation has succeeded. The link can not be removed before the operation has succeeded. An exit signal due to the link is guaranteed not to be delivered before a success message that corresponds to the spawn operation. If the spawn operation fails, no exit signal due to the link will be delivered to the caller of spawn_request().
If the connection between the nodes involved in the spawn operation is lost during the spawn operation, the spawn operation will fail with an error reason of noconnection. A new process may or may not have been created. If it has been created, it will be delivered an exit signal with an exit reason of noconnection.
This function will fail with a badarg exception if:
Note that not all individual Options are checked when the spawn request is sent. Some Options can only be checked on reception of the request. Therefore an invalid option does not cause a badarg exception, but will cause the spawn operation to fail with an error reason of badopt.
A spawn request can be abandoned by calling spawn_request_abandon/1.
spawn_request_abandon(ReqId :: reference()) -> boolean()
Abandon a previously issued spawn request. ReqId corresponds to a request identifier previously returned by spawn_request() in a call from current process. That is, only the process that has made the request can abandon the request.
A spawn request can only be successfully abandoned until the spawn request has completed. When a spawn request has been successfully abandoned, the caller will not be effected by future direct effects of the spawn request itself. For example, it will not receive a spawn reply message. The request is however not withdrawn, so a new process may or may not be created due to the request. If a new process is created after the spawn request was abandoned, no monitors nor links will be set up to the caller of spawn_request_abandon/1 due to the spawn request. If the spawn request included the link option, the process created due to this request will be sent an exit signal from its parent with the exit reason abandoned when it is detected that the spawn operation has succeeded.
Return values:
This function fail with a badarg exception if ReqId is not a reference.
split_binary(Bin, Pos) -> {binary(), binary()}
Types:
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
erlang:start_timer(Time, Dest, Msg) -> TimerRef
Types:
Starts a timer. The same as calling erlang:start_timer(Time, Dest, Msg, []).
erlang:start_timer(Time, Dest, Msg, Options) -> TimerRef
Types:
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.
statistics(Item :: active_tasks) -> [ActiveTasks]
Types:
Returns the same as statistics(active_tasks_all) with the exception that no information about the dirty IO run queue and its associated schedulers is part of the result. That is, only tasks that are expected to be CPU bound are part of the result.
statistics(Item :: active_tasks_all) -> [ActiveTasks]
Types:
Returns a list where each element represents the amount of active processes and ports on each run queue and its associated schedulers. That is, the number of processes and ports that are ready to run, or are currently running. Values for normal run queues and their associated schedulers are located first in the resulting list. The first element corresponds to scheduler number 1 and so on. If support for dirty schedulers exist, an element with the value for the dirty CPU run queue and its associated dirty CPU schedulers follow and then as last element the value for the the dirty IO run queue and its associated dirty IO schedulers follow. 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), statistics(run_queue_lengths_all), statistics(total_run_queue_lengths), and statistics(total_run_queue_lengths_all).
statistics(Item :: context_switches) -> {ContextSwitches, 0}
Types:
Returns the total number of context switches since the system started.
statistics(Item :: exact_reductions) ->
{Total_Exact_Reductions,
Exact_Reductions_Since_Last_Call}
Types:
Returns the number of exact reductions.
statistics(Item :: garbage_collection) ->
{Number_of_GCs, Words_Reclaimed, 0}
Types:
Returns information about garbage collection, for example:
> statistics(garbage_collection).
{85,23961,0}
This information can be invalid for some implementations.
statistics(Item :: io) -> {{input, Input}, {output, Output}}
Types:
Returns Input, which is the total number of bytes received through ports, and Output, which is the total number of bytes output to ports.
statistics(Item :: microstate_accounting) ->
[MSAcc_Thread] | undefined
Types:
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(3erl) 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.
statistics(Item :: reductions) ->
{Total_Reductions, Reductions_Since_Last_Call}
Types:
Returns information about reductions, for example:
> statistics(reductions).
{2046,11}
statistics(Item :: run_queue) -> integer() >= 0
Returns the total length of all normal and dirty CPU run queues. That is, queued work that is expected to be CPU bound. 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.
statistics(Item :: run_queue_lengths) -> [RunQueueLength]
Types:
Returns the same as statistics(run_queue_lengths_all) with the exception that no information about the dirty IO run queue is part of the result. That is, only run queues with work that is expected to be CPU bound is part of the result.
statistics(Item :: run_queue_lengths_all) -> [RunQueueLength]
Types:
Returns a list where each element represents the amount of processes and ports ready to run for each run queue. Values for normal run queues are located first in the resulting list. The first element corresponds to the normal run queue of scheduler number 1 and so on. If support for dirty schedulers exist, values for the dirty CPU run queue and the dirty IO run queue follow (in that order) at the end. 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(run_queue_lengths), statistics(total_run_queue_lengths_all), statistics(total_run_queue_lengths), statistics(active_tasks), statistics(active_tasks_all), and statistics(total_active_tasks), statistics(total_active_tasks_all).
statistics(Item :: runtime) ->
{Total_Run_Time, Time_Since_Last_Call}
Types:
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}
statistics(Item :: scheduler_wall_time) ->
[{SchedulerId, ActiveTime, TotalTime}] | undefined
Types:
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 will as default have more schedulers than logical processors. This due to the dirty schedulers.
statistics(Item :: scheduler_wall_time_all) ->
[{SchedulerId, ActiveTime, TotalTime}] | undefined
Types:
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).
statistics(Item :: total_active_tasks) -> ActiveTasks
Types:
The same as calling lists:sum(statistics(active_tasks)), but more efficient.
statistics(Item :: total_active_tasks_all) -> ActiveTasks
Types:
The same as calling lists:sum(statistics(active_tasks_all)), but more efficient.
statistics(Item :: total_run_queue_lengths) ->
TotalRunQueueLengths
Types:
The same as calling lists:sum(statistics(run_queue_lengths)), but more efficient.
statistics(Item :: total_run_queue_lengths_all) ->
TotalRunQueueLengths
Types:
The same as calling lists:sum(statistics(run_queue_lengths_all)), but more efficient.
statistics(Item :: wall_clock) ->
{Total_Wallclock_Time,
Wallclock_Time_Since_Last_Call}
Types:
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.
erlang:suspend_process(Suspendee) -> true
Types:
Suspends the process identified by Suspendee. The same as calling erlang:suspend_process(Suspendee, []).
erlang:suspend_process(Suspendee, OptList) -> boolean()
Types:
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):
Appart from the reply message, the {asynchronous, ReplyTag} option behaves exactly the same as the asynchronous option without reply tag.
If the suspend count on the process identified by Suspendee is increased, true is returned, otherwise false.
Failures:
erlang:system_flag(Flag :: backtrace_depth, Depth) -> OldDepth
Types:
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.
erlang:system_flag(Flag :: cpu_topology, CpuTopology) ->
OldCpuTopology
Types:
cpu_topology() = [LevelEntry :: level_entry()] | undefined
level_entry() =
{LevelTag :: level_tag(), SubLevel :: sub_level()} |
{LevelTag :: level_tag(),
InfoList :: info_list(),
SubLevel :: sub_level()}
level_tag() = core | node | processor | thread
sub_level() =
[LevelEntry :: level_entry()] |
(LogicalCpuId :: {logical, integer() >= 0})
info_list() = []
When this argument is removed, a final CPU topology to use is determined at emulator boot time.
Sets the user-defined CpuTopology. The user-defined CPU topology overrides any automatically detected CPU topology. By passing undefined as CpuTopology, the system reverts to the CPU topology automatically detected. The returned value equals the value returned from erlang:system_info(cpu_topology) before the change was made.
Returns the old value of the flag.
The CPU topology is used when binding schedulers to logical processors. If schedulers are already bound when the CPU topology is changed, the schedulers are sent a request to rebind according to the new CPU topology.
The user-defined CPU topology can also be set by passing command-line argument +sct to erl(1).
For information on type CpuTopology and more, see erlang:system_info(cpu_topology) as well as command-line flags +sct and +sbt in erl(1).
erlang:system_flag(Flag :: dirty_cpu_schedulers_online,
DirtyCPUSchedulersOnline) ->
OldDirtyCPUSchedulersOnline
Types:
Sets the number of dirty CPU schedulers online. Range is 1 <= DirtyCPUSchedulersOnline <= N, 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).
erlang:system_flag(Flag :: erts_alloc, Value :: {Alloc, F, V}) ->
ok | notsup
Types:
Sets system flags for erts_alloc(3erl). Alloc is the allocator to affect, for example binary_alloc. F is the flag to change and V is the new value.
Only a subset of all erts_alloc flags can be changed at run time. This subset is currently only the flag sbct.
Returns ok if the flag was set or notsup if not supported by erts_alloc.
erlang:system_flag(Flag :: fullsweep_after, Number) -> OldNumber
Types:
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.
erlang:system_flag(Flag :: microstate_accounting, Action) ->
OldState
Types:
Turns on/off microstate accounting measurements. When passing reset, all counters are reset to 0.
For more information see statistics(microstate_accounting).
erlang:system_flag(Flag :: min_heap_size, MinHeapSize) ->
OldMinHeapSize
Types:
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.
erlang:system_flag(Flag :: min_bin_vheap_size, MinBinVHeapSize) ->
OldMinBinVHeapSize
Types:
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.
erlang:system_flag(Flag :: max_heap_size, MaxHeapSize) ->
OldMaxHeapSize
Types:
max_heap_size() =
integer() >= 0 |
#{size => integer() >= 0,
kill => boolean(),
error_logger => boolean()}
Sets the default maximum heap size settings for processes. The size is specified in words. The new max_heap_size effects only processes spawned efter the change has been made. max_heap_size can be set for individual processes using spawn_opt/2,3,4 or process_flag/2.
Returns the old value of the flag.
erlang:system_flag(Flag :: multi_scheduling, BlockState) ->
OldBlockState
Types:
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).
erlang:system_flag(Flag :: scheduler_bind_type, How) ->
OldBindType
Types:
scheduler_bind_type() =
no_node_processor_spread | no_node_thread_spread | no_spread |
processor_spread | spread | thread_spread |
thread_no_node_processor_spread | unbound
Controls if and how schedulers are bound to logical processors.
When erlang:system_flag(scheduler_bind_type, How) is called, an asynchronous signal is sent to all schedulers online, causing them to try to bind or unbind as requested.
Schedulers can be bound on newer Linux, Solaris, FreeBSD, and Windows systems, but more systems will be supported in future releases.
In order for the runtime system to be able to bind schedulers, the CPU topology must be known. If the runtime system fails to detect the CPU topology automatically, it can be defined. For more information on how to define the CPU topology, see command-line flag +sct in erl(1).
The runtime system does by default not bind schedulers to logical processors.
Schedulers can be bound in different ways. Argument How determines how schedulers are bound and can be any of the following:
The returned value equals How before flag scheduler_bind_type was changed.
Failures:
The scheduler bind type can also be set by passing command-line argument +sbt to erl(1).
For more information, see erlang:system_info(scheduler_bind_type), erlang:system_info(scheduler_bindings), as well as command-line flags +sbt and +sct in erl(1).
erlang:system_flag(Flag :: scheduler_wall_time, Boolean) ->
OldBoolean
Types:
Turns on or off scheduler wall time measurements.
For more information, see statistics(scheduler_wall_time).
erlang:system_flag(Flag :: schedulers_online, SchedulersOnline) ->
OldSchedulersOnline
Types:
Sets the number of schedulers online. Range is 1 <= SchedulersOnline <= erlang:system_info(schedulers).
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).
erlang:system_flag(Flag :: system_logger, Logger) -> PrevLogger
Types:
Sets the process that will receive the logging messages generated by ERTS. If set to undefined, all logging messages generated by ERTS will be dropped. The messages will be in the format:
{log,Level,Format,ArgList,Metadata} where
Level = atom(),
Format = string(),
ArgList = list(term()),
Metadata = #{ pid => pid(),
group_leader => pid(),
time := logger:timestamp(),
error_logger := #{ emulator := true, tag := atom() }
If the system_logger process dies, this flag will be reset to logger.
The default is the process named logger.
Returns the old value of the flag.
erlang:system_flag(Flag :: trace_control_word, TCW) -> OldTCW
Types:
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.
erlang:system_flag(Flag :: time_offset, Value :: finalize) ->
OldState
Types:
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:
erlang:system_info(Item :: overview) -> boolean()
Returns information about the current system. The documentation of this function is broken into the following sections in order to make it easier to navigate.
erlang:system_info(Item :: allocated_areas) -> [tuple()]
erlang:system_info(Item :: allocator) ->
{Allocator, Version, Features, Settings}
erlang:system_info(Item :: {allocator, Alloc}) -> [term()]
erlang:system_info(Item :: alloc_util_allocators) -> [Alloc]
erlang:system_info(Item :: {allocator_sizes, Alloc}) -> [term()]
erlang:system_info(Item :: elib_malloc) -> false
Types:
Returns various information about the memory allocators of the current system (emulator) as specified by Item:
Each tuple contains an atom describing the type of memory as first element and the amount of allocated memory in bytes as second element. When information about allocated and used memory is present, also a third element is present, containing the amount of used memory in bytes.
erlang:system_info(allocated_areas) is intended for debugging, and the content is highly implementation-dependent. The content of the results therefore changes when needed without prior notice.
Notice that the sum of these values is not the total amount of memory allocated by the emulator. Some values are part of other values, and some memory areas are not part of the result. For information about the total amount of memory allocated by the emulator, see erlang:memory/0,1.
See also "System Flags Effecting erts_alloc" in erts_alloc(3erl).
Notice that the information returned is highly implementation-dependent and can be changed or removed at any time without prior notice. It was initially intended as a tool when developing new allocators, but as it can be of interest for others it has been briefly documented.
The recognized allocators are listed in erts_alloc(3erl). Information about super carriers can be obtained from ERTS 8.0 with {allocator, erts_mmap} or from ERTS 5.10.4; the returned list when calling with {allocator, mseg_alloc} also includes an {erts_mmap, _} tuple as one element in the list.
After reading the erts_alloc(3erl) documentation, the returned information more or less speaks for itself, but it can be worth explaining some things. Call counts are presented by two values, the first value is giga calls, and the second value is calls. mbcs and sbcs denote multi-block carriers, and single-block carriers, respectively. Sizes are presented in bytes. When a size is not presented, it is the amount of something. Sizes and amounts are often presented by three values:
If only one value is present, it is the current value. fix_alloc memory block types are presented by two values. The first value is the memory pool size and the second value is the used memory size.
erlang:system_info(Item :: cpu_topology) -> CpuTopology
erlang:system_info(Item ::
{cpu_topology, defined | detected | used}) ->
CpuTopology
erlang:system_info(Item ::
logical_processors |
logical_processors_available |
logical_processors_online) ->
unknown | integer() >= 1
erlang:system_info(Item :: update_cpu_info) -> changed | unchanged
Types:
cpu_topology() = [LevelEntry :: level_entry()] | undefined
level_entry() =
{LevelTag :: level_tag(), SubLevel :: sub_level()} |
{LevelTag :: level_tag(),
InfoList :: info_list(),
SubLevel :: sub_level()}
level_tag() = core | node | processor | thread
sub_level() =
[LevelEntry :: level_entry()] |
(LogicalCpuId :: {logical, integer() >= 0})
info_list() = []
Returns various information about the CPU topology of the current system (emulator) as specified by Item:
node refers to Non-Uniform Memory Access (NUMA) nodes. thread refers to hardware threads (for example, Intel hyper-threads).
A level in term CpuTopology can be omitted if only one entry exists and InfoList is empty.
thread can only be a sublevel to core. core can be a sublevel to processor or node. processor can be on the top level or a sublevel to node. node can be on the top level or a sublevel to processor. That is, NUMA nodes can be processor internal or processor external. A CPU topology can consist of a mix of processor internal and external NUMA nodes, as long as each logical CPU belongs to one NUMA node. Cache hierarchy is not part of the CpuTopology type, but will be in a future release. Other things can also make it into the CPU topology in a future release. So, expect the CpuTopology type to change.
Returns the user-defined CpuTopology. For more information, see command-line flag +sct in erl(1) and argument cpu_topology.
Returns the automatically detected CpuTopologyy. The emulator detects the CPU topology on some newer Linux, Solaris, FreeBSD, and Windows systems. On Windows system with more than 32 logical processors, the CPU topology is not detected.
For more information, see argument cpu_topology.
If the CPU information has changed since the last time it was read, the atom changed is returned, otherwise the atom unchanged. If the CPU information has changed, you probably want to adjust the number of schedulers online. You typically want to have as many schedulers online as logical processors available.
erlang:system_info(Item :: fullsweep_after) ->
{fullsweep_after, integer() >= 0}
erlang:system_info(Item :: garbage_collection) ->
[{atom(), integer()}]
erlang:system_info(Item :: heap_sizes) -> [integer() >= 0]
erlang:system_info(Item :: heap_type) -> private
erlang:system_info(Item :: max_heap_size) ->
{max_heap_size,
MaxHeapSize :: max_heap_size()}
erlang:system_info(Item :: message_queue_data) ->
message_queue_data()
erlang:system_info(Item :: min_heap_size) ->
{min_heap_size,
MinHeapSize :: integer() >= 1}
erlang:system_info(Item :: min_bin_vheap_size) ->
{min_bin_vheap_size,
MinBinVHeapSize :: integer() >= 1}
erlang:system_info(Item :: procs) -> binary()
Types:
message_queue_data() = off_heap | on_heap
max_heap_size() =
integer() >= 0 |
#{size => integer() >= 0,
kill => boolean(),
error_logger => boolean()}
Returns information about the default process heap settings:
erlang:system_info(Item :: atom_count) -> integer() >= 1
erlang:system_info(Item :: atom_limit) -> integer() >= 1
erlang:system_info(Item :: ets_count) -> integer() >= 1
erlang:system_info(Item :: ets_limit) -> integer() >= 1
erlang:system_info(Item :: port_count) -> integer() >= 0
erlang:system_info(Item :: port_limit) -> integer() >= 1
erlang:system_info(Item :: process_count) -> integer() >= 1
erlang:system_info(Item :: process_limit) -> integer() >= 1
Returns information about the current system (emulator) limits as specified by Item:
erlang:system_info(Item :: end_time) -> integer() >= 0
erlang:system_info(Item :: os_monotonic_time_source) ->
[{atom(), term()}]
erlang:system_info(Item :: os_system_time_source) ->
[{atom(), term()}]
erlang:system_info(Item :: start_time) -> integer()
erlang:system_info(Item :: time_correction) -> true | false
erlang:system_info(Item :: time_offset) ->
preliminary | final | volatile
erlang:system_info(Item :: time_warp_mode) ->
no_time_warp | single_time_warp |
multi_time_warp
erlang:system_info(Item :: tolerant_timeofday) ->
enabled | disabled
Returns information about the current system (emulator) time as specified by Item:
If [] is returned, no OS monotonic time is available. The list contains two-tuples with Keys as first element, and Values as second element. The order of these tuples is undefined. The following tuples can be part of the list, but more tuples can be introduced in the future:
The list contains two-tuples with Keys as first element, and Values as second element. The order of these tuples is undefined. The following tuples can be part of the list, but more tuples can be introduced in the future:
See also erlang:system_info(end_time).
erlang:system_info(Item :: dirty_cpu_schedulers) ->
integer() >= 0
erlang:system_info(Item :: dirty_cpu_schedulers_online) ->
integer() >= 0
erlang:system_info(Item :: dirty_io_schedulers) ->
integer() >= 0
erlang:system_info(Item :: multi_scheduling) ->
disabled | blocked | blocked_normal |
enabled
erlang:system_info(Item :: multi_scheduling_blockers) ->
[Pid :: pid()]
erlang:system_info(Item :: otp_release) -> string()
erlang:system_info(Item :: scheduler_bind_type) ->
spread | processor_spread | thread_spread |
thread_no_node_processor_spread |
no_node_processor_spread |
no_node_thread_spread | no_spread | unbound
erlang:system_info(Item :: scheduler_bindings) -> tuple()
erlang:system_info(Item :: scheduler_id) ->
SchedulerId :: integer() >= 1
erlang:system_info(Item :: schedulers | schedulers_online) ->
integer() >= 1
erlang:system_info(Item :: smp_support) -> boolean()
erlang:system_info(Item :: threads) -> boolean()
erlang:system_info(Item :: thread_pool_size) -> integer() >= 0
Returns information about schedulers, scheduling and threads in the current system as specified by Item:
The number of dirty CPU scheduler threads is determined at emulator boot time and cannot be changed after that. However, the number of dirty CPU scheduler threads online can be changed at any time. The number of dirty CPU schedulers can be set at startup by passing command-line flag +SDcpu or +SDPcpu in erl(1).
See also erlang:system_flag(dirty_cpu_schedulers_online, DirtyCPUSchedulersOnline), erlang:system_info(dirty_cpu_schedulers_online), erlang:system_info(dirty_io_schedulers), erlang:system_info(schedulers), erlang:system_info(schedulers_online), and erlang:system_flag(schedulers_online, SchedulersOnline).
The number of dirty CPU schedulers online can be set at startup by passing command-line flag +SDcpu in erl(1).
For more information, see erlang:system_info(dirty_cpu_schedulers), erlang:system_info(dirty_io_schedulers), erlang:system_info(schedulers_online), and erlang:system_flag(dirty_cpu_schedulers_online, DirtyCPUSchedulersOnline).
This value can be set at startup by passing command-line argument +SDio in erl(1).
For more information, see erlang:system_info(dirty_cpu_schedulers), erlang:system_info(dirty_cpu_schedulers_online), and erlang:system_flag(dirty_cpu_schedulers_online, DirtyCPUSchedulersOnline).
See also erlang:system_flag(multi_scheduling, BlockState), erlang:system_info(multi_scheduling_blockers), erlang:system_info(normal_multi_scheduling_blockers), and erlang:system_info(schedulers).
See also erlang:system_flag(multi_scheduling, BlockState), erlang:system_info(multi_scheduling), erlang:system_info(normal_multi_scheduling_blockers), and erlang:system_info(schedulers).
See also erlang:system_flag(multi_scheduling, BlockState), erlang:system_info(multi_scheduling), erlang:system_info(multi_scheduling_blockers), and erlang:system_info(schedulers).
Notice that although a user has requested schedulers to be bound, they can silently have failed to bind. To inspect the scheduler bindings, call erlang:system_info(scheduler_bindings).
For more information, see command-line argument +sbt in erl(1) and erlang:system_info(scheduler_bindings).
A tuple of a size equal to erlang:system_info(schedulers) is returned. The tuple elements are integers or the atom unbound. Logical processor identifiers are represented as integers. The Nth element of the tuple equals the current binding for the scheduler with the scheduler identifier equal to N. For example, if the schedulers are bound, element(erlang:system_info(scheduler_id), erlang:system_info(scheduler_bindings)) returns the identifier of the logical processor that the calling process is executing on.
Notice that only schedulers online can be bound to logical processors.
For more information, see command-line argument +sbt in erl(1) and erlang:system_info(schedulers_online).
See also erlang:system_info(schedulers).
The number of scheduler threads is determined at emulator boot time and cannot be changed later. However, the number of schedulers online can be changed at any time.
See also erlang:system_flag(schedulers_online, SchedulersOnline), erlang:system_info(schedulers_online), erlang:system_info(scheduler_id), erlang:system_flag(multi_scheduling, BlockState), erlang:system_info(multi_scheduling), erlang:system_info(normal_multi_scheduling_blockers) and erlang:system_info(multi_scheduling_blockers).
For more information, see erlang:system_info(schedulers) and erlang:system_flag(schedulers_online, SchedulersOnline).
Returns the number of async threads in the async thread pool used for asynchronous driver calls (erl_driver:driver_async()). The value is given as an integer.
erlang:system_info(Item :: creation) -> integer()
erlang:system_info(Item :: delayed_node_table_gc) ->
infinity | integer() >= 0
erlang:system_info(Item :: dist) -> binary()
erlang:system_info(Item :: dist_buf_busy_limit) ->
integer() >= 0
erlang:system_info(Item :: dist_ctrl) ->
{Node :: node(),
ControllingEntity :: port() | pid()}
Returns information about Erlang Distribution in the current system as specified by Item:
erlang:system_info(Item :: build_type) ->
opt | debug | purify | quantify | purecov |
gcov | valgrind | gprof | lcnt | frmptr
erlang:system_info(Item :: c_compiler_used) -> {atom(), term()}
erlang:system_info(Item :: check_io) -> [term()]
erlang:system_info(Item :: compat_rel) -> integer()
erlang:system_info(Item :: debug_compiled) -> boolean()
erlang:system_info(Item :: driver_version) -> string()
erlang:system_info(Item :: dynamic_trace) ->
none | dtrace | systemtap
erlang:system_info(Item :: dynamic_trace_probes) -> boolean()
erlang:system_info(Item :: info) -> binary()
erlang:system_info(Item :: kernel_poll) -> boolean()
erlang:system_info(Item :: loaded) -> binary()
erlang:system_info(Item :: machine) -> string()
erlang:system_info(Item :: modified_timing_level) ->
integer() | undefined
erlang:system_info(Item :: nif_version) -> string()
erlang:system_info(Item :: otp_release) -> string()
erlang:system_info(Item :: port_parallelism) -> boolean()
erlang:system_info(Item :: system_architecture) -> string()
erlang:system_info(Item :: system_logger) ->
logger | undefined | pid()
erlang:system_info(Item :: system_version) -> string()
erlang:system_info(Item :: trace_control_word) ->
integer() >= 0
erlang:system_info(Item :: version) -> string()
erlang:system_info(Item ::
wordsize |
{wordsize, internal} |
{wordsize, external}) ->
4 | 8
Returns various information about the current system (emulator) as specified by Item:
Returns a string containing the OTP release number of the OTP release that the currently executing ERTS application is part of.
As from Erlang/OTP 17, the OTP release number corresponds to the major OTP version number. No erlang:system_info() argument gives the exact OTP version. This is because the exact OTP version in the general case is difficult to determine. For more information, see the description of versions in System principles in System Documentation.
erlang:system_monitor() -> MonSettings
Types:
system_monitor_option() =
busy_port | busy_dist_port |
{long_gc, integer() >= 0} |
{long_schedule, integer() >= 0} |
{large_heap, integer() >= 0}
Returns the current system monitoring settings set by erlang:system_monitor/2 as {MonitorPid, Options}, or undefined if no settings exist. The order of the options can be different from the one that was set.
erlang:system_monitor(Arg) -> MonSettings
Types:
system_monitor_option() =
busy_port | busy_dist_port |
{long_gc, integer() >= 0} |
{long_schedule, integer() >= 0} |
{large_heap, integer() >= 0}
When called with argument undefined, all system performance monitoring settings are cleared.
Calling the function with {MonitorPid, Options} as argument is the same as calling erlang:system_monitor(MonitorPid, Options).
Returns the previous system monitor settings just like erlang:system_monitor/0.
erlang:system_monitor(MonitorPid, Options) -> MonSettings
Types:
system_monitor_option() =
busy_port | busy_dist_port |
{long_gc, integer() >= 0} |
{long_schedule, integer() >= 0} |
{large_heap, integer() >= 0}
Sets the system performance monitoring options. MonitorPid is a local process identifier (pid) receiving system monitor messages. The second argument is a list of monitoring options:
One of the tuples is {timeout, GcTime}, where GcTime is the time for the garbage collection in milliseconds. The other tuples are tagged with heap_size, heap_block_size, stack_size, mbuf_size, old_heap_size, and old_heap_block_size. These tuples are explained in the description of trace message gc_minor_start (see erlang:trace/3). New tuples can be added, and the order of the tuples in the Info list can be changed at any time without prior notice.
If a pid(), the tuples {timeout, Millis}, {in, Location}, and {out, Location} are present, where Location is either an MFA ({Module, Function, Arity}) describing the function where the process was scheduled in/out, or the atom undefined.
If a port(), the tuples {timeout, Millis} and {port_op,Op} are present. Op is one of proc_sig, timeout, input, output, event, or dist_cmd, depending on which driver callback was executing.
proc_sig is an internal operation and is never to appear, while the others represent the corresponding driver callbacks timeout, ready_input, ready_output, event, and outputv (when the port is used by distribution). Value Millis in tuple timeout informs about the uninterrupted execution time of the process or port, which always is equal to or higher than the Time value supplied when starting the trace. New tuples can be added to the Info list in a future release. The order of the tuples in the list can be changed at any time without prior notice.
This can be used to detect problems with NIFs or drivers that take too long to execute. 1 ms is considered a good maximum time for a driver callback or a NIF. However, a time-sharing system is usually to consider everything < 100 ms as "possible" and fairly "normal". However, longer schedule times can indicate swapping or a misbehaving NIF/driver. Misbehaving NIFs and drivers can cause bad resource utilization and bad overall system performance.
The monitor message is sent if the sum of the sizes of all memory blocks allocated for all heap generations after a garbage collection is equal to or higher than Size.
When a process is killed by max_heap_size, it is killed before the garbage collection is complete and thus no large heap message is sent.
Returns the previous system monitor settings just like erlang:system_monitor/0.
The arguments to system_monitor/2 specifies how all system monitoring on the node should be done, not how it should be changed. This means only one process at a time (MonitorPid) can be the receiver of system monitor messages. Also, the way to clear a specific monitor option is to not include it in the list Options. All system monitoring will, however, be cleared if the process identified by MonitorPid terminates.
There are no special option values (like zero) to clear an option. Some of the options have a unspecified minimum value. Lower values will be adjusted to the minimum value. For example, it is currently not possible to monitor all garbage collections with {long_gc, 0}.
Keep the monitoring process neat and do not set the system monitor limits too tight.
Failures:
erlang:system_profile() -> ProfilerSettings
Types:
system_profile_option() =
exclusive | runnable_ports | runnable_procs | scheduler |
timestamp | monotonic_timestamp | strict_monotonic_timestamp
Returns the current system profiling settings set by erlang:system_profile/2 as {ProfilerPid, Options}, or undefined if there are no settings. The order of the options can be different from the one that was set.
erlang:system_profile(ProfilerPid, Options) -> ProfilerSettings
Types:
system_profile_option() =
exclusive | runnable_ports | runnable_procs | scheduler |
timestamp | monotonic_timestamp | strict_monotonic_timestamp
Sets system profiler options. ProfilerPid is a local process identifier (pid) or port receiving profiling messages. The receiver is excluded from all profiling. The second argument is a list of profiling options:
erlang:system_time() -> integer()
Returns current Erlang system time in native time unit.
Calling erlang:system_time() is equivalent to erlang:monotonic_time() + erlang:time_offset().
erlang:system_time(Unit) -> integer()
Types:
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).
term_to_binary(Term) -> ext_binary()
Types:
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.
term_to_binary(Term, Options) -> ext_binary()
Types:
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:
This version encode atoms that can be represented by a latin1 string using latin1 encoding while only atoms that cannot be represented by latin1 are encoded using utf8.
This version encode atoms that can be represented by a latin1 string using latin1 encoding while only atoms that cannot be represented by latin1 are encoded using utf8.
See also binary_to_term/1.
term_to_iovec(Term) -> ext_iovec()
Types:
Returns the encoding of Term according to the Erlang external term format as ext_iovec().
This function produce the same encoding as term_to_binary/1, but with another return type. The call iolist_to_binary(term_to_iovec(Term)) will produce exactly the same result as the call term_to_binary(Term).
term_to_iovec() is a pure optimization of the functionality term_to_binary() provide. term_to_iovec() can for example refer directly to off heap binaries instead of copying the binary data into the result.
See also term_to_binary/1.
term_to_iovec(Term, Options) -> ext_iovec()
Types:
Returns the encoding of Term according to the Erlang external term format as ext_iovec().
This function produce the same encoding as term_to_binary/2, but with another return type. The call iolist_to_binary(term_to_iovec(Term, Opts)) will produce exactly the same result as term_to_binary(Term, Opts).
Currently recognised options are all options recognised by term_to_binary/2.
term_to_iovec() is a pure optimization of the functionality term_to_binary() provide. term_to_iovec() can for example refer directly to off heap binaries instead of copying the binary data into the result.
See also term_to_binary/2.
throw(Any) -> no_return()
Types:
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.
time() -> Time
Types:
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}
erlang:time_offset() -> integer()
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.
If the runtime system is in multi-time warp mode, the time offset is changed when the runtime system detects that the OS system time has changed. The runtime system will, however, not detect this immediately when it occurs. A task checking the time offset is scheduled to execute at least once a minute; so, under normal operation this is to be detected within a minute, but during heavy load it can take longer time.
erlang:time_offset(Unit) -> integer()
Types:
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.
erlang:timestamp() -> Timestamp
Types:
timestamp() =
{MegaSecs :: integer() >= 0,
Secs :: integer() >= 0,
MicroSecs :: integer() >= 0}
Returns current Erlang system time on the format {MegaSecs, Secs, MicroSecs}. This format is the same as os:timestamp/0 and the deprecated erlang:now/0 use. The reason for the existence of erlang:timestamp() is purely to simplify use for existing code that assumes this time stamp format. Current Erlang system time can more efficiently be retrieved in the time unit of your choice using erlang:system_time/1.
The erlang:timestamp() BIF is equivalent to:
timestamp() ->
ErlangSystemTime = erlang:system_time(microsecond),
MegaSecs = ErlangSystemTime div 1000_000_000_000,
Secs = ErlangSystemTime div 1000_000 - MegaSecs*1000_000,
MicroSecs = ErlangSystemTime rem 1000_000,
{MegaSecs, Secs, MicroSecs}.
It, however, uses a native implementation that does not build garbage on the heap and with slightly better performance.
tl(List) -> term()
Types:
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 [].
erlang:trace(PidPortSpec, How, FlagList) -> integer()
Types:
trace_flag() =
all | send | 'receive' | procs | ports | call | arity |
return_to | silent | running | exiting | running_procs |
running_ports | garbage_collection | timestamp |
cpu_timestamp | monotonic_timestamp |
strict_monotonic_timestamp | set_on_spawn |
set_on_first_spawn | set_on_link | set_on_first_link |
{tracer, pid() | port()} |
{tracer, module(), term()}
Turns on (if How == true) or off (if How == false) the trace flags in FlagList for the process or processes represented by PidPortSpec.
PidPortSpec is either a process identifier (pid) for a local process, a port identifier, or one of the following atoms:
FlagList can contain any number of the following flags (the "message tags" refers to the list of trace messages):
Message tags: send and send_to_non_existing_process.
Message tags: 'receive'.
Message tags: call and return_from.
Silent mode is inhibited by executing erlang:trace(_, false, [silent|_]), or by a match specification executing the function {silent, false}.
The silent trace flag facilitates setting up a trace on many or even all processes in the system. The trace can then be activated and deactivated using the match specification function {silent,Bool}, giving a high degree of control of which functions with which arguments that trigger the trace.
Message tags: call, return_from, and return_to. Or rather, the absence of.
The semantics is that a trace message is sent when a call traced function returns, that is, when a chain of tail recursive calls ends. Only one trace message is sent per chain of tail recursive calls, so the properties of tail recursiveness for function calls are kept while tracing with this flag. Using call and return_to trace together makes it possible to know exactly in which function a process executes at any time.
To get trace messages containing return values from functions, use the {return_trace} match specification action instead.
Message tags: return_to.
Message tags: spawn, spawned, exit, register, unregister, link, unlink, getting_linked, and getting_unlinked.
Message tags: open, closed, register, unregister, getting_linked, and getting_unlinked.
Message tags: in and out.
Message tags: in_exiting, out_exiting, and out_exited.
Message tags: in and out.
Message tags: in and out.
Message tags: gc_minor_start, gc_max_heap_size, and gc_minor_end.
If no tracer is specified, the calling process receives all the trace messages.
The effect of combining set_on_first_link with set_on_link is the same as set_on_first_link alone. Likewise for set_on_spawn and set_on_first_spawn.
The tracing process receives the trace messages described in the following list. Pid is the process identifier of the traced process in which the traced event has occurred. The third tuple element is the message tag.
If flag timestamp, strict_monotonic_timestamp, or monotonic_timestamp is specified, the first tuple element is trace_ts instead, and the time stamp is added as an extra element last in the message tuple. If multiple time stamp flags are passed, timestamp has precedence over strict_monotonic_timestamp, which in turn has precedence over monotonic_timestamp. All time stamp flags are remembered, so if two are passed and the one with highest precedence later is disabled, the other one becomes active.
If a match specification (applicable only for call, send and 'receive' tracing) contains a {message} action function with a non-boolean value, that value is added as an extra element to the message tuple either in the last position or before the timestamp (if it is present).
Trace messages:
Trace flag arity can be used to change the contents of this message, so that Arity is specified instead of Args.
Args is supposed to be the argument list, but can be any term if the spawn is erroneous.
Args is supposed to be the argument list, but can be any term if the spawn is erroneous.
Driver is the name of the driver as an atom.
The possible commands are call, close, command, connect, control, flush, info, link, open, and unlink.
Sent when a young garbage collection is about to be started. Info is a list of two-element tuples, where the first element is a key, and the second is the value. Do not depend on any order of the tuples. The following keys are defined:
All sizes are in words.
If the tracing process/port dies or the tracer module returns remove, the flags are silently removed.
Each process can only be traced by one tracer. Therefore, attempts to trace an already traced process fail.
Returns a number indicating the number of processes that matched PidPortSpec. If PidPortSpec is a process identifier, the return value is 1. If PidPortSpec is all or existing, the return value is the number of processes running. If PidPortSpec is new, the return value is 0.
Failure: badarg if the specified arguments are not supported. For example, cpu_timestamp is not supported on all platforms.
erlang:trace_delivered(Tracee) -> Ref
Types:
The delivery of trace messages (generated by erlang:trace/3, seq_trace(3erl), or erlang:system_profile/2) is dislocated on the time-line compared to other events in the system. If you know that Tracee has passed some specific point in its execution, and you want to know when at least all trace messages corresponding to events up to this point have reached the tracer, use erlang:trace_delivered(Tracee).
When it is guaranteed that all trace messages are delivered to the tracer up to the point that Tracee reached at the time of the call to erlang:trace_delivered(Tracee), then a {trace_delivered, Tracee, Ref} message is sent to the caller of erlang:trace_delivered(Tracee) .
Notice that message trace_delivered does not imply that trace messages have been delivered. Instead it implies that all trace messages that are to be delivered have been delivered. It is not an error if Tracee is not, and has not been traced by someone, but if this is the case, no trace messages have been delivered when the trace_delivered message arrives.
Notice that Tracee must refer to a process currently or previously existing on the same node as the caller of erlang:trace_delivered(Tracee) resides on. The special Tracee atom all denotes all processes that currently are traced in the node.
When used together with a Tracer Module, any message sent in the trace callback is guaranteed to have reached its recipient before the trace_delivered message is sent.
Example: Process A is Tracee, port B is tracer, and process C is the port owner of B. C wants to close B when A exits. To ensure that the trace is not truncated, C can call erlang:trace_delivered(A) when A exits, and wait for message {trace_delivered, A, Ref} before closing B.
Failure: badarg if Tracee does not refer to a process (dead or alive) on the same node as the caller of erlang:trace_delivered(Tracee) resides on.
erlang:trace_info(PidPortFuncEvent, Item) -> Res
Types:
trace_info_return() =
undefined |
{flags, [trace_info_flag()]} |
{tracer, pid() | port() | []} |
{tracer, module(), term()} |
trace_info_item_result() |
{all, [trace_info_item_result()] | false | undefined}
trace_info_item_result() =
{traced, global | local | false | undefined} |
{match_spec, trace_match_spec() | false | undefined} |
{meta, pid() | port() | false | undefined | []} |
{meta, module(), term()} |
{meta_match_spec, trace_match_spec() | false | undefined} |
{call_count, integer() >= 0 | boolean() | undefined} |
{call_time,
[{pid(),
integer() >= 0,
integer() >= 0,
integer() >= 0}] |
boolean() |
undefined}
trace_info_flag() =
send | 'receive' | set_on_spawn | call | return_to | procs |
set_on_first_spawn | set_on_link | running |
garbage_collection | timestamp | monotonic_timestamp |
strict_monotonic_timestamp | arity
trace_match_spec() =
[{[term()] | '_' | match_variable(), [term()], [term()]}]
match_variable() = atom()
Returns trace information about a port, process, function, or event.
To get information about a port or process, PidPortFuncEvent is to be a process identifier (pid), port identifier, or one of the atoms new, new_processes, or new_ports. The atom new or new_processes means that the default trace state for processes to be created is returned. The atom new_ports means that the default trace state for ports to be created is returned.
Valid Items for ports and processes:
To get information about a function, PidPortFuncEvent is to be the three-element tuple {Module, Function, Arity} or the atom on_load. No wildcards are allowed. Returns undefined if the function does not exist, or false if the function is not traced. If PidPortFuncEvent is on_load, the information returned refers to the default value for code that will be loaded.
Valid Items for functions:
See also erlang:trace_pattern/3.
See also erlang:trace_pattern/3.
To get information about an event, PidPortFuncEvent is to be one of the atoms send or 'receive'.
One valid Item for events exists:
The return value is {Item, Value}, where Value is the requested information as described earlier. If a pid for a dead process was specified, or the name of a non-existing function, Value is undefined.
erlang:trace_pattern(MFA, MatchSpec) -> integer() >= 0
Types:
trace_pattern_mfa() = {atom(), atom(), arity() | '_'} | on_load
trace_match_spec() =
[{[term()] | '_' | match_variable(), [term()], [term()]}]
match_variable() = atom()
The same as erlang:trace_pattern(Event, MatchSpec, []), retained for backward compatibility.
erlang:trace_pattern(MFA :: send, MatchSpec, FlagList :: []) ->
integer() >= 0
Types:
trace_match_spec() =
[{[term()] | '_' | match_variable(), [term()], [term()]}]
match_variable() = atom()
Sets trace pattern for message sending. Must be combined with erlang:trace/3 to set the send trace flag for one or more processes. By default all messages sent from send traced processes are traced. To limit traced send events based on the message content, the sender and/or the receiver, use erlang:trace_pattern/3.
Argument MatchSpec can take the following forms:
Argument FlagList must be [] for send tracing.
The return value is always 1.
Examples:
Only trace messages to a specific process Pid:
> erlang:trace_pattern(send, [{[Pid, '_'],[],[]}], []).
1
Only trace messages matching {reply, _}:
> erlang:trace_pattern(send, [{['_', {reply,'_'}],[],[]}], []).
1
Only trace messages sent to the sender itself:
> erlang:trace_pattern(send, [{['$1', '_'],[{'=:=','$1',{self}}],[]}], []).
1
Only trace messages sent to other nodes:
> erlang:trace_pattern(send, [{['$1', '_'],[{'=/=',{node,'$1'},{node}}],[]}], []).
1
Fails by raising an error exception with an error reason of:
erlang:trace_pattern(MFA :: 'receive', MatchSpec, FlagList :: []) ->
integer() >= 0
Types:
trace_match_spec() =
[{[term()] | '_' | match_variable(), [term()], [term()]}]
match_variable() = atom()
Sets trace pattern for message receiving. Must be combined with erlang:trace/3 to set the 'receive' trace flag for one or more processes. By default all messages received by 'receive' traced processes are traced. To limit traced receive events based on the message content, the sender and/or the receiver, use erlang:trace_pattern/3.
Argument MatchSpec can take the following forms:
Argument FlagList must be [] for receive tracing.
The return value is always 1.
Examples:
Only trace messages from a specific process Pid:
> erlang:trace_pattern('receive', [{['_',Pid, '_'],[],[]}], []).
1
Only trace messages matching {reply, _}:
> erlang:trace_pattern('receive', [{['_','_', {reply,'_'}],[],[]}], []).
1
Only trace messages from other nodes:
> erlang:trace_pattern('receive', [{['$1', '_', '_'],[{'=/=','$1',{node}}],[]}], []).
1
Fails by raising an error exception with an error reason of:
erlang:trace_pattern(MFA, MatchSpec, FlagList) ->
integer() >= 0
Types:
trace_pattern_mfa() = {atom(), atom(), arity() | '_'} | on_load
trace_match_spec() =
[{[term()] | '_' | match_variable(), [term()], [term()]}]
trace_pattern_flag() =
global | local | meta |
{meta, Pid :: pid()} |
{meta, TracerModule :: module(), TracerState :: term()} |
call_count | call_time
match_variable() = atom()
Enables or disables call tracing for one or more functions. Must be combined with erlang:trace/3 to set the call trace flag for one or more processes.
Conceptually, call tracing works as follows. Inside the Erlang virtual machine, a set of processes and a set of functions are to be traced. If a traced process calls a traced function, the trace action is taken. Otherwise, nothing happens.
To add or remove one or more processes to the set of traced processes, use erlang:trace/3.
To add or remove functions to the set of traced functions, use erlang:trace_pattern/3.
The BIF erlang:trace_pattern/3 can also add match specifications to a function. A match specification comprises a pattern that the function arguments must match, a guard expression that must evaluate to true, and an action to be performed. The default action is to send a trace message. If the pattern does not match or the guard fails, the action is not executed.
Argument MFA is to be a tuple, such as {Module, Function, Arity}, or the atom on_load (described below). It can be the module, function, and arity for a function (or a BIF in any module). The atom '_' can be used as a wildcard in any of the following ways:
Other combinations, such as {Module,'_',Arity}, are not allowed. Local functions match wildcards only if option local is in FlagList.
If argument MFA is the atom on_load, the match specification and flag list are used on all modules that are newly loaded.
Argument MatchSpec can take the following forms:
Parameter FlagList is a list of options. The following are the valid options:
Meta-tracing traces all processes and does not care about the process trace flags set by erlang:trace/3, the trace flags are instead fixed to [call, timestamp].
The match specification function {return_trace} works with meta-trace and sends its trace message to the same tracer.
If call count tracing is started while already running, the count is restarted from zero. To pause running counters, use MatchSpec == pause. Paused and running counters can be restarted from zero with MatchSpec == restart.
To read the counter value, use erlang:trace_info/2.
If call time tracing is started while already running, the count and time restart from zero. To pause running counters, use MatchSpec == pause. Paused and running counters can be restarted from zero with MatchSpec == restart.
To read the counter value, use erlang:trace_info/2.
The options global and local are mutually exclusive, and global is the default (if no options are specified). The options call_count and meta perform a kind of local tracing, and cannot be combined with global. A function can be globally or locally traced. If global tracing is specified for a set of functions, then local, meta, call time, and call count tracing for the matching set of local functions is disabled, and conversely.
When disabling trace, the option must match the type of trace set on the function. That is, local tracing must be disabled with option local and global tracing with option global (or no option), and so on.
Part of a match specification list cannot be changed directly. If a function has a match specification, it can be replaced with a new one. To change an existing match specification, use the BIF erlang:trace_info/2 to retrieve the existing match specification.
Returns the number of functions matching argument MFA. This is zero if none matched.
Fails by raising an error exception with an error reason of:
trunc(Number) -> integer()
Types:
Returns an integer by truncating Number, for example:
> trunc(5.5). 5
Allowed in guard tests.
tuple_size(Tuple) -> integer() >= 0
Types:
Returns an integer that is the number of elements in Tuple, for example:
> tuple_size({morni, mulle, bwange}).
3
Allowed in guard tests.
tuple_to_list(Tuple) -> [term()]
Types:
Returns a list corresponding to Tuple. Tuple can contain any Erlang terms. Example:
> tuple_to_list({share, {'Ericsson_B', 163}}).
[share,{'Ericsson_B',163}]
erlang:unique_integer() -> integer()
Generates and returns an integer unique on current runtime system instance. The same as calling erlang:unique_integer([]).
erlang:unique_integer(ModifierList) -> integer()
Types:
Generates and returns an integer unique on current runtime system instance. The integer is unique in the sense that this BIF, using the same set of modifiers, does not return the same integer more than once on the current runtime system instance. Each integer value can of course be constructed by other means.
By default, when [] is passed as ModifierList, both negative and positive integers can be returned. This to use the range of integers that do not need heap memory allocation as much as possible. By default the returned integers are also only guaranteed to be unique, that is, any returned integer can be smaller or larger than previously returned integers.
Modifiers:
Notice that by passing the positive modifier you will get heap allocated integers (bignums) quicker.
These values can be used to determine order between events on the runtime system instance. That is, if both X = erlang:unique_integer([monotonic]) and Y = erlang:unique_integer([monotonic]) are executed by different processes (or the same process) on the same runtime system instance and X < Y, we know that X was created before Y.
All valid Modifiers can be combined. Repeated (valid) Modifiers in the ModifierList are ignored.
Failures:
erlang:universaltime() -> DateTime
Types:
Returns the current date and time according to Universal Time Coordinated (UTC) in the form {{Year, Month, Day}, {Hour, Minute, Second}} if supported by the underlying OS. Otherwise erlang:universaltime() is equivalent to erlang:localtime(). Example:
> erlang:universaltime().
{{1996,11,6},{14,18,43}}
erlang:universaltime_to_localtime(Universaltime) -> Localtime
Types:
Converts Universal Time Coordinated (UTC) date and time to local date and time in the form {{Year, Month, Day}, {Hour, Minute, Second}} if supported by the underlying OS. Otherwise no conversion is done, and Universaltime is returned. Example:
> erlang:universaltime_to_localtime({{1996,11,6},{14,18,43}}).
{{1996,11,7},{15,18,43}}
Failure: badarg if Universaltime denotes an invalid date and time.
unlink(Id) -> true
Types:
Removes the link, if there is one, between the calling process and the process or port referred to by Id.
Returns true and does not fail, even if there is no link to Id, or if Id does not exist.
Once unlink(Id) has returned, it is guaranteed that the link between the caller and the entity referred to by Id has no effect on the caller in the future (unless the link is setup again). If the caller is trapping exits, an {'EXIT', Id, _} message from the link can have been placed in the caller's message queue before the call.
Notice that the {'EXIT', Id, _} message can be the result of the link, but can also be the result of Id calling exit/2. Therefore, it can be appropriate to clean up the message queue when trapping exits after the call to unlink(Id), as follows:
unlink(Id), receive
{'EXIT', Id, _} ->
true after 0 ->
true end
The current behavior can be viewed as two combined operations: asynchronously send an "unlink signal" to the linked entity and ignore any future results of the link.
unregister(RegName) -> true
Types:
Removes the registered name RegName associated with a process identifier or a port identifier, for example:
> unregister(db). true
Users are advised not to unregister system processes.
Failure: badarg if RegName is not a registered name.
whereis(RegName) -> pid() | port() | undefined
Types:
Returns the process identifier or port identifier with the registered name RegName. Returns undefined if the name is not registered. Example:
> whereis(db). <0.43.0>
erlang:yield() -> true
Voluntarily lets other processes (if any) get a chance to execute. Using this function is similar to receive after 1 -> true end, except that yield() is faster.
| erts 11.1.8 | Ericsson AB |