Computes and returns the adler32 checksum for Data.

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

The following code:

- would assign the same value to Y as this would:

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:

- would assign the same value to Z as this would:

Returns a new tuple which 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.

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

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

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

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

> apply(lists, reverse, [[a, b, c]]).
[c,b,a]

apply can be used to evaluate BIFs by using the module name erlang.

> apply(erlang, atom_to_list, ['Erlang']).
"Erlang"

Note: 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 the error_handler is undefined, or if the user has redefined the default error_handler so the replacement module is undefined, an error with the reason undef is generated.

Returns a binary which corresponds to the text representation of Atom. If Encoding is latin1, there will be one byte for each character in the text representation. If Encoding is utf8 or unicode, the characters will be encoded using UTF-8 (meaning that characters from 16#80 up to 0xFF will be encoded in two bytes).

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

Returns a string which corresponds to the text representation of Atom.

> atom_to_list('Erlang').
"Erlang"

Extracts the part of the binary described by PosLen.

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

If PosLen in any way references outside the binary, a badarg exception is raised.

Start is zero-based, i.e.:

See the STDLIB module binary for details about the PosLen semantics.

Allowed in guard tests.

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

Allowed in guard tests.

Returns the atom whose text representation is Binary. If Encoding is latin1, no translation of bytes in the binary is done. If Encoding is utf8 or unicode, the binary must contain valid UTF-8 sequences; furthermore, only Unicode characters up to 0xFF are allowed.

> binary_to_atom(<<"Erlang">>, latin1).
'Erlang'
> binary_to_atom(<<1024/utf8>>, utf8).
** exception error: bad argument
     in function  binary_to_atom/2
        called as binary_to_atom(<<208,128>>,utf8)

Works like binary_to_atom/2, but the atom must already exist.

Failure: badarg if the atom does not already exist.

Returns a list of integers which correspond to the bytes of Binary.

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

Returns a list of integers which correspond to the bytes of Bitstring. If the number of bits in the binary is not divisible by 8, the last element of the list will be a bitstring containing the remaining bits (1 up to 7 bits).

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

See also term_to_binary/1 and binary_to_term/2.

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

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.

Returns an integer which is the size in bits of Bitstring.

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

Allowed in guard tests.

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, and a context switch is forced when the counter reaches the maximum number of reductions for a process (2000 reductions in R12B).

Returns an integer which 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 will be rounded up.)

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

Allowed in guard tests.

Cancels a timer, where TimerRef was returned by either erlang:send_after/3 or erlang:start_timer/3. If the timer is there to be removed, the function returns the time in milliseconds left until the timer would have expired, otherwise false (which means that TimerRef was never a timer, that it has already been cancelled, or that it has already delivered its message).

See also erlang:send_after/3, erlang:start_timer/3, and erlang:read_timer/1.

Note: Cancelling a timer does not guarantee that the message has not already been delivered to the message queue.

Returns true if the Module has old code, and false otherwise.

See also code(3).

Returns true if the process Pid is executing old code for Module. That is, if the current call of the process executes old code for this module, or if the process has references to old code for this module, or if the process contains funs that references old code for this module. Otherwise, it returns false.

> check_process_code(Pid, lists).
false

See also code(3).

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

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

The following code:

- would assign the same value to Y as this would:

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:

- would assign the same value to Z as this would:

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

The time zone and daylight saving time correction depend on the underlying OS.

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

Decodes the binary Bin according to the packet protocol specified by Type. Very similar to the packet handling done by sockets with the 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 not known. 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.

The following values of Type are valid:

The following options are available:

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

Returns a new tuple with element at Index removed from tuple Tuple1.

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

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

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

If MonitorRef is a reference which 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 due to the monitor will be placed in the caller's message queue in the future. A {'DOWN', MonitorRef, _, _, _} message might have been placed in the caller's message queue prior to the call, though. Therefore, in most cases, it is advisable to remove such a 'DOWN' message from the message queue after monitoring has been stopped. demonitor(MonitorRef, [flush]) can be used instead of demonitor(MonitorRef) if this cleanup is wanted.

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

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

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

Currently the following Options are valid:

Failure: badarg if OptionList is not a list, or if Option is not a valid option, or the same failure as for demonitor/1

Forces the disconnection of a node. This will appear 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, the function returns ignored.

Prints a text representation of Term on the standard output.

Returns the Nth element (numbering from 1) of Tuple.

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

Allowed in guard tests.

Returns the process dictionary and deletes it.

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

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

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

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

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

Stops the execution of the calling process with the reason Reason, where Reason is any term. The actual exit reason will be {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 will be used to provide the actual arguments for the current function in the Where term. Since evaluating this function causes the process to terminate, it has no return value.

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

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

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

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

If Pid is not trapping exits, Pid itself will exit with exit reason Reason. If Pid is trapping exits, the exit signal is transformed into a message {'EXIT', From, Reason} and delivered to the message queue of Pid. From is the pid of the process which sent the exit signal. See also process_flag/2.

If Reason is the atom normal, Pid will 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 will unconditionally exit with exit reason killed.

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

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

This is equivalent to a call to: erlang:external_size(Term, [])

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
          

The option {minor_version, Version} specifies how floats are encoded. See term_to_binary/2 for a more detailed description.

Returns a float by converting Number to a float.

> float(55).
55.0

Allowed in guard tests.

Returns a string which corresponds to the text representation of Float.

> float_to_list(7.0).
"7.00000000000000000000e+00"

Returns a list containing information about the fun Fun. Each element of the list is a tuple. The order of the tuples is not defined, and more tuples may be added in a future release.

There are two types of funs with slightly different semantics:

A fun created by fun M:F/A is called an external fun. Calling it will always call the function F with arity A in the latest code for module M. Note that module M does not even need to be loaded when the fun fun M:F/A is created.

All other funs are called local. When a local fun is called, the same version of the code that created the fun will be called (even if newer version of the module has been loaded).

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

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

Returns a string which corresponds to the text representation of Fun.

Returns true if the module Module is loaded and contains an exported function Function/Arity; otherwise false.

Returns false for any BIF (functions implemented in C rather than in Erlang).

Forces an immediate garbage collection of the currently executing process. The function should not 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. Improper use may seriously degrade system performance.

Compatibility note: In versions of OTP prior to R7, the garbage collection took place at the next context switch, not immediately. To force a context switch after a call to erlang:garbage_collect(), it was sufficient to make any function call.

Works like erlang:garbage_collect() but on any process. The same caveats apply. Returns false if Pid refers to a dead process; true otherwise.

Returns the process dictionary as a list of {Key, Val} tuples.

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

Returns the value Valassociated with Key in the process dictionary, or undefined if Key does not exist.

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

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

Returns a list of keys which are associated with the value Val in the process dictionary.

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

Returns the pid of the group leader for the process which evaluates the function.

Every process is a member of some process group and all groups have a group leader. All IO 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 start-up, init is both its own group leader and the group leader of all processes.

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

See also group_leader/0.

The same as halt(0, []).

> halt().
os_prompt% 

The same as halt(Status, []).

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

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

Note that on many platforms, only the status codes 0-255 are supported by the operating system.

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 the flush option is ignored and flushing is not done.

Returns a hash value for Term within the range 1..Range. The allowed range is 1..2^27-1.

Returns the head of List, that is, the first element.

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

Allowed in guard tests.

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

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

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

If the process has any message in its message queue, the process will be awaken immediately in the same way as described above.

In more technical terms, what erlang:hibernate/3 does is the following. It discards the call stack for the process. Then it garbage collects the process. After the garbage collection, all live data is in one continuous heap. The heap is then shrunken to the exact same size as the live data which 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 has been awaken will ensure that the heap size is changed to a size not smaller than the minimum heap size.

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

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

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

Returns a string which corresponds to the text representation of Integer.

> integer_to_list(77).
"77"

Returns a string which corresponds to the text representation of Integer in base Base.

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

Returns a binary which is made from the integers and binaries in IoListOrBinary.

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

Returns an integer which is the size in bytes of the binary that would be the result of iolist_to_binary(Item).

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

Returns true if the local node is alive; that is, if the node can be part of a distributed system. Otherwise, it returns false.

Returns true if Term is an atom; otherwise returns false.

Allowed in guard tests.

Returns true if Term is a binary; otherwise returns false.

A binary always contains a complete number of bytes.

Allowed in guard tests.

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

Allowed in guard tests.

Returns true if Term is either the atom true or the atom false (i.e. a boolean); otherwise returns false.

Allowed in guard tests.

Returns true if Module:Function/Arity is a BIF implemented in C; otherwise returns false. This BIF is useful for builders of cross reference tools.

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

Allowed in guard tests.

Returns true if Term is a fun; otherwise returns false.

Allowed in guard tests.

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

Allowed in guard tests.

Returns true if Term is an integer; otherwise returns false.

Allowed in guard tests.

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

Allowed in guard tests.

Returns true if Term is either an integer or a floating point number; otherwise returns false.

Allowed in guard tests.

Returns true if Term is a pid (process identifier); otherwise returns false.

Allowed in guard tests.

Returns true if Term is a port identifier; otherwise returns false.

Allowed in guard tests.

Pid must refer to a process at the local node. Returns true if the process exists and is alive, that is, is not exiting and has not exited. Otherwise, returns false.

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

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

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

Allowed in guard tests, provided that RecordTag is a literal atom and Size is a literal integer.

Returns true if Term is a reference; otherwise returns false.

Allowed in guard tests.

Returns true if Term is a tuple; otherwise returns false.

Allowed in guard tests.

Returns the length of List.

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

Allowed in guard tests.

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

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

Returns the atom whose text representation is String.

String may only contain ISO-latin-1 characters (i.e. numbers below 256) as the current implementation does not allow unicode characters >= 256 in atoms. For more information on Unicode support in atoms see note on UTF-8 encoded atoms in the chapter about the external term format in the ERTS User's Guide.

> list_to_atom("Erlang").
'Erlang'

Returns a binary which is made from the integers and binaries in IoList.

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

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

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

Returns the float whose text representation is String.

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

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

Returns an integer whose text representation is String.

> list_to_integer("123").
123

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

Returns an integer whose text representation in base Base is String.

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

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

Returns a pid whose text representation is String.

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

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

Returns a tuple which corresponds to List. List can contain any Erlang terms.

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

If Binary contains the object code for the module Module, this BIF loads that object code. Also, if the code for the 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 may still be processes which are executing that code. It returns either {module, Module}, or {error, Reason} if loading fails. Reason is one of the following:

Loads and links a dynamic library containing native implemented functions (NIFs) for a module. Path is a file path to the sharable object/dynamic library file minus the OS-dependent file extension (.so for Unix and .dll for Windows). See erl_nif on how to implement a NIF library.

LoadInfo can be any term. It will be 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 atoms below, while Text is a human readable string that may give some more information about the failure.

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

See also code(3).

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

The time zone and daylight saving time correction depend on the underlying OS.

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

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

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

Failure: badarg if Localtime does not denote a valid date and time.

Converts local date and time to Universal Time Coordinated (UTC) just like erlang:localtime_to_universaltime/1, but the caller decides if daylight saving time is active or not.

If IsDst == true the Localtime is during daylight saving time, if IsDst == false it is not, and if IsDst == undefined the underlying OS may guess, which is the same as calling erlang:localtime_to_universaltime(Localtime).

> 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 does not denote a valid date and time.

Returns an almost unique reference.

The returned reference will re-occur after approximately 2^82 calls; therefore it is unique enough for practical purposes.

> make_ref().
#Ref<0.0.0.135>

Returns a new tuple of the given Arity, where all elements are InitialValue.

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

erlang:make_tuple first creates a tuple of size Arity where each element has the value DefaultValue. It 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 last occurrence will be used.

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

Return the largest of Term1 and Term2; if the terms compare equal, Term1 will be returned.

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

See The MD5 Message Digest Algorithm (RFC 1321) for more information about MD5.

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

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

Updates an MD5 Context with Data, and returns a NewContext.

Return the smallest of Term1 and Term2; if the terms compare equal, Term1 will be returned.

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

The calling process starts monitoring Item which is an object of type Type.

Currently only processes can be monitored, i.e. the only allowed Type is process, but other types may be allowed in the future.

Item can be:

A 'DOWN' message will be sent to the monitoring process if Item dies, if Item does not exist, or if the connection is lost to the node which Item resides on. A 'DOWN' message has the following pattern:

where MonitorRef and Type are the same as described above, and:

The monitoring is turned off either when the 'DOWN' message is sent, or when demonitor/1 is called.

If an attempt is made to monitor a process on an older node (where remote process monitoring is not implemented or one where remote process monitoring by registered name is not implemented), the call fails with badarg.

Making several calls to monitor/2 for the same Item is not an error; it results in as many, completely independent, monitorings.

Monitors 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, completely independent, monitorings.

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, there will be an attempt to create one. If this fails, a nodedown message is delivered.

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

Failure: badargif the local node is not alive.

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

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

Works exactly like erlang: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 will not generate false warnings.

Works exactly like erlang: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 will not generate false warnings.

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

Allowed in guard tests.

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

Allowed in guard tests.

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

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

NodeType can be any of the following:

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

If the local node is not alive, nodes(this) == nodes(known) == [nonode@nohost], for any other Arg the empty list [] is returned.

Returns a port identifier as the result of opening a new Erlang port. A port can be seen as an external Erlang process. PortName is one of the following:

PortSettings is a list of settings for the port. Valid settings are:

The default is stream for all types of port 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 which 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}. See file(3) for possible values of PosixCode.

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

Portable hash function that will give 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). Range can be between 1 and 2^32, the function returns a hash value for Term within the range 1..Range.

This BIF could be used instead of the old deprecated erlang:hash/2 BIF, as it calculates better hashes for all data-types, but consider using phash2/1,2 instead.

Returns a string which corresponds to the text representation of Pid.

Closes an open port. Roughly the same as Port ! {self(), close} except for the error behaviour (see below), being synchronous, and that the port does not reply with {Port, closed}. Any process may close a port with port_close/1, not only the port owner (the connected process).

For comparison: Port ! {self(), close} fails with badarg if Port cannot be sent to (i.e., Port refers neither to a port nor to 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, but if the calling process is not the port owner the port owner fails with badsig.

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

As of OTP-R16 Port ! {PortOwner, close} is truly asynchronous. Note 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. This due to its error behavior.

Failure: badarg if Port is not an open port or the registered name of an open port.

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

For comparison: Port ! {PortOwner, {command, Data}} fails with badarg if Port cannot be sent to (i.e., Port refers neither to a port nor to 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 not a valid IO list.

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

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

As of OTP-R16 Port ! {PortOwner, {command, Data}} is truly asynchronous. Note 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. This due to its error behavior.

Failures:

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

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

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

Currently the following Options are valid:

Failures:

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

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

For comparison: Port ! {self(), {connect, Pid}} fails with badarg if Port cannot be sent to (i.e., Port refers neither to a port nor to 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. Note that the old port owner is still linked to the port, and that 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 pid.

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

As of OTP-R16 Port ! {PortOwner, {connect, Pid}} is truly asynchronous. Note 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. This due to its error behavior.

Failure: badarg if Port is not an open port or the registered name of an open port, or if Pid is not an existing local pid.

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

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

Failure: badarg if Port is not an open port or the registered name of an open port, if Operation cannot fit in a 32-bit integer, if the port driver does not support synchronous control operations, or if the port driver so decides for any reason (probably something wrong with Operation or Data).

Performs a synchronous call to a port. The meaning of Operation and Data depends on the port, i.e., 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.

Failure: badarg if Port is not an open port or the registered name of an open port, if Operation cannot fit in a 32-bit integer, if the port driver does not support synchronous control operations, or if the port driver so decides for any reason (probably something wrong with Operation or Data).

Returns a list containing tuples with information about the Port, or undefined if the port is not open. The order of the tuples is not defined, nor are all the tuples mandatory.

Currently the result will containt information about the following Items: registered_name (if the port has a registered name), id, connected, links, name, input, and output. For more information about the different Items, see port_info/2.

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

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

If the port identified by Port is not open, undefined is returned.

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

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

If the port identified by Port is not open, undefined is returned.

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

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

If the port identified by Port is not open, undefined is returned.

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

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

If the port identified by Port is not open, undefined is returned.

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

Locking is currently either false (emulator without SMP support), port_level (port specific locking), or driver_level (driver specific locking). Note that these results are highly implementation specific and might change in the future.

If the port identified by Port is not open, undefined is returned.

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

Bytes is the total amount of memory, in bytes, allocated for this port by the runtime system. Note that the port itself might have allocated memory which is not included in Bytes.

If the port identified by Port is not open, undefined is returned.

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

Monitors represent processes that this port is monitoring.

If the port identified by Port is not open, undefined is returned.

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

Name is the command name set by open_port/2.

If the port identified by Port is not open, undefined is returned.

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

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

If the port identified by Port is not open, undefined is returned.

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

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

If the port identified by Port is not open, undefined is returned.

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

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

Bytes is the total amount of data, in bytes, queued by the port using the ERTS driver queue implementation.

If the port identified by Port is not open, undefined is returned.

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

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

If the port identified by Port is not open, undefined is returned.

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

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

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

Note that a port that is exiting, exists but is not open.

Returns a list of Erlang modules which are pre-loaded 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 pre-loaded.

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

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

Returns the old value of the flag.

See also exit/2.

This is used by a process to redefine the error handler for undefined function calls and undefined registered processes. Inexperienced users should not use this flag since code auto-loading is dependent on the correct operation of the error handling module.

Returns the old value of the flag.

This changes the minimum heap size for the calling process.

Returns the old value of the flag.

This changes the minimum binary virtual heap size for the calling process.

Returns the old value of the flag.

N must be an integer in the interval 0..10000. If N > 0, call saving is made active for the process, which 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: a tuple {Module, Function, Arity} for function calls, and the mere atoms send, 'receive' and timeout for sends and receives ('receive' when a message is received and timeout when a receive times out). 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.

Set or clear the sensitive flag for the current process. When a process has been marked as sensitive by calling process_flag(sensitive, true), features in the run-time system that can be used for examining the data and/or inner working of the process are silently disabled.

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

Tracing: Trace flags can still be set for the process, but no trace messages of any kind will be generated. (If the sensitive flag is turned off, trace messages will again be generated if there are any trace flags set.)

Sequential tracing: The sequential trace token will be propagated as usual, but no sequential trace messages will be generated.

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

Stack back-traces cannot be displayed for the process.

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

If {save_calls,N} has been set for the process, no function calls will be saved to the call saving list. (The call saving list will not be cleared; furthermore, send, receive, and timeout events will still be added to the list.)

Returns the old value of the flag.

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

Failure: badarg if Pid is not a local process.

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

Note that a process that is exiting, exists but is not alive, i.e., is_process_alive/1 will return false for a process that is exiting, but its process identifier will be part of the result returned from processes/0.

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

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

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

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

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

TimerRef is a timer reference returned by erlang:send_after/3 or erlang:start_timer/3. If the timer is active, the function returns the time in milliseconds left until the timer will expire, otherwise false (which means that TimerRef was never a timer, that it has been cancelled, or that it has already delivered its message).

See also erlang:send_after/3, erlang:start_timer/3, and erlang:cancel_timer/1.

Returns a string which corresponds to the text representation of Ref.

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

> register(db, Pid).
true

Failure: badarg if PidOrPort is not an existing, local process or port, if RegName is already in use, if the process or port is already registered (already has a name), or if RegName is the atom undefined.

Returns a list of names which have been registered using register/2.

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

Decreases the suspend count on the process identified by Suspendee. Suspendee should previously have been suspended via erlang:suspend_process/2, or erlang:suspend_process/1 by the process calling erlang:resume_process(Suspendee). When the suspend count on Suspendee reach zero, Suspendee will be resumed, i.e., the state of the Suspendee is changed from suspended into the state Suspendee was in before it was suspended.

Failures:

Returns an integer by rounding Number.

> round(5.5).
6

Allowed in guard tests.

Returns the pid (process identifier) of the calling process.

> self().
<0.26.0>

Allowed in guard tests.

Starts a timer which will send the message Msg to Dest after Time milliseconds.

If Dest is a pid() it has to be a pid() of a local process, dead or alive.

The Time value can, in the current implementation, not be greater than 4294967295.

If Dest is an atom(), it is supposed to be the name of a registered process. The process referred to by the name is looked up at the time of delivery. No error is given if the name does not refer to a process.

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

See also erlang:start_timer/3, erlang:cancel_timer/1, and erlang:read_timer/1.

Failure: badarg if the arguments does not satisfy the requirements specified above.

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 Distributed Erlang in the Erlang Reference Manual).

Failure: function_clause if the local node is not alive.

Returns a tuple which is a copy of the argument Tuple1 with the element given by the integer argument Index (the first element is the element with index 1) replaced by the argument Value.

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

Returns an integer which is the size of the argument Item, which must be either a tuple or a binary.

> size({morni, mulle, bwange}).
3

Allowed in guard tests.

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

Returns the 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/3.

Returns the pid of a new process started by the application of Module:Function to Args. The new process created will be placed in the system scheduler queue and be run some time later.

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 its replacement is undefined, a failure with the reason undef will occur.

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

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

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

Returns the 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 due to the link, an exit signal with exit reason noconnection will be received). Otherwise works like spawn/3.

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

Returns the 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 due to the link, an exit signal with exit reason noconnection will be received). Otherwise works like spawn/3.

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

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

Returns the pid of a new process started by the application of Fun to the empty list []. Otherwise works like spawn_opt/4.

If the option monitor is given, the newly created process will be monitored and both the pid and reference for the monitor will be returned.

Returns the 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.

Works exactly like spawn/3, except that an extra option list is given when creating the process.

If the option monitor is given, the newly created process will be monitored and both the pid and reference for the monitor will be returned.

Returns the 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.

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

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

Starts a timer which will send the message {timeout, TimerRef, Msg} to Dest after Time milliseconds.

If Dest is a pid() it has to be a pid() of a local process, dead or alive.

The Time value can, in the current implementation, not be greater than 4294967295.

If Dest is an atom(), it is supposed to be the name of a registered process. The process referred to by the name is looked up at the time of delivery. No error is given if the name does not refer to a process.

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

See also erlang:send_after/3, erlang:cancel_timer/1, and erlang:read_timer/1.

Failure: badarg if the arguments does not satisfy the requirements specified above.

ContextSwitches is the total number of context switches since the system started.

This information may not be valid for all implementations.

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

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

> statistics(reductions).
{2046,11}

Returns the length of the run queue, that is, the number of processes that are ready to run.

Note that the run-time is the sum of the run-time for all threads in the Erlang run-time system and may therefore be greater than the wall-clock time.

> statistics(runtime).
{1690,1620}

Returns a list of tuples with {SchedulerId, ActiveTime, TotalTime}, where SchedulerId is an integer id of the scheduler, ActiveTime is the duration the scheduler has been busy, TotalTime is the total time duration since scheduler_wall_time activation. The time unit is not defined and may be subject to change between releases, operating systems and system restarts. scheduler_wall_time should only 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 or not scheduling (selecting) a process or port, meaning; executing process code, executing linked-in-driver or NIF code, executing built-in-functions or any other runtime handling, garbage collecting or handling any other memory management. Note, a scheduler may also be busy even if the operating system has scheduled out the scheduler thread.

Returns undefined if the system flag scheduler_wall_time is turned off.

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

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 we will take another snapshot and calculate scheduler-utilization per scheduler.

> 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)), A/T.
0.9769136803764825

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

Increases the suspend count on the process identified by Suspendee and puts it in the suspended state if it isn't already in the suspended state. A suspended process will not be 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 will not leave the suspended state until its suspend count reach 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 will automatically be decreased when the process terminates.

Currently the following options (Opts) are available:

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

Failures:

Suspends the process identified by Suspendee. The same as calling erlang:suspend_process(Suspendee, []). For more information see the documentation of erlang:suspend_process/2.

Sets the maximum depth of call stack back-traces in the exit reason element of 'EXIT' tuples.

Returns the old value of the flag.

Number is a non-negative integer which indicates how many times generational garbage collections can be done without forcing a fullsweep collection. The value applies to new processes; 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.

An alternative way to set this value is through the (operating system) environment variable ERL_FULLSWEEP_AFTER.

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

Returns the old value of the flag.

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

Returns the old value of the flag.

If multi-scheduling is enabled, more than one scheduler thread is used by the emulator. Multi-scheduling can be blocked. When multi-scheduling has been blocked, only one scheduler thread will schedule Erlang processes.

If BlockState =:= block, multi-scheduling will be blocked. If BlockState =:= unblock and no-one else is blocking multi-scheduling and this process has only blocked one time, multi-scheduling will be unblocked. One process can block multi-scheduling multiple times. If a process has blocked multiple times, it has to 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 exits, it will release its blocking of multi-scheduling.

The return values are disabled, blocked, or enabled. The returned value describes the state just after the call to erlang:system_flag(multi_scheduling, BlockState) has been made. The return values are described in the documentation of erlang:system_info(multi_scheduling).

NOTE: Blocking of multi-scheduling should normally not be needed. If you feel that you need to block multi-scheduling, think through the problem at least a couple of times again. Blocking multi-scheduling should only be used as a last resort since it will most likely be a very inefficient way to solve the problem.

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

Turns on/off scheduler wall time measurements.

For more information see, erlang:statistics(scheduler_wall_time).

Sets the amount of schedulers online. Valid range is .

Returns the old value of the flag.

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

Sets the value of the node's trace control word to TCW. TCW should be an unsigned integer. For more information see documentation of the set_tcw function in the match specification documentation in the ERTS User's Guide.

Returns the old value of the flag.

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

This can be used for a variety of 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.

See also binary_to_term/1.

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

If the option compressed is provided, the external term format will be compressed. The compressed format is automatically recognized by binary_to_term/1 in R7B and later.

It is also possible to specify a compression level by giving the option {compressed, Level}, where Level is an integer from 0 through 9. 0 means that no compression will be done (it is the same as not giving any compressed option); 1 will take the least time but may not compress as well as the higher levels; 9 will take the most time and may produce a smaller result. Note the "mays" in the preceding sentence; depending on the input term, level 9 compression may or may not produce a smaller result than level 1 compression.

Currently, compressed gives the same result as {compressed, 6}.

The option {minor_version, Version} can be use to control some details of the encoding. This option was introduced in R11B-4. Currently, the allowed values for Version are 0 and 1.

{minor_version, 1} forces any floats in the term to be encoded in a more space-efficient and exact way (namely in the 64-bit IEEE format, rather than converted to a textual representation). binary_to_term/1 in R11B-4 and later is able decode the new representation.

{minor_version, 0} is currently the default, meaning that floats will be encoded using a textual representation; this option is useful if you want to ensure that releases prior to R11B-4 can decode resulting binary.

See also binary_to_term/1.

A non-local return from a function. If evaluated within a catch, catch will return the value Any.

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

Failure: nocatch if not evaluated within a catch.

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

The time zone and daylight saving time correction depend on the underlying OS.

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

Returns the tail of List, that is, the list minus the first element.

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

Allowed in guard tests.

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

The delivery of trace messages is dislocated on the time-line compared to other events in the system. If you know that the 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 you can use erlang:trace_delivered(Tracee). A {trace_delivered, Tracee, Ref} message is sent to the caller of erlang:trace_delivered(Tracee) when it is guaranteed that all trace messages have been delivered to the tracer up to the point that the Tracee had reached at the time of the call to erlang:trace_delivered(Tracee).

Note that the trace_delivered message does not imply that trace messages have been delivered; instead, it implies that all trace messages that should be delivered have been delivered. It is not an error if Tracee isn't, and hasn't been traced by someone, but if this is the case, no trace messages will have been delivered when the trace_delivered message arrives.

Note that Tracee has to 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.

An 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. C can ensure that the trace isn't truncated by calling erlang:trace_delivered(A) when A exits and wait for the {trace_delivered, A, Ref} message 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.

Returns an integer by the truncating Number.

> trunc(5.5).
5

Allowed in guard tests.

Returns an integer which is the number of elements in Tuple.

> tuple_size({morni, mulle, bwange}).
3

Allowed in guard tests.

Returns a list which corresponds to Tuple. Tuple may contain any Erlang terms.

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

Returns the current date and time according to Universal Time Coordinated (UTC), also called GMT, in the form {{Year, Month, Day}, {Hour, Minute, Second}} if supported by the underlying operating system. If not, erlang:universaltime() is equivalent to erlang:localtime().

> erlang:universaltime().
{{1996,11,6},{14,18,43}}

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

> erlang:universaltime_to_localtime({{1996,11,6},{14,18,43}}).
{{1996,11,7},{15,18,43}}

Failure: badarg if Universaltime does not denote a valid date and time.

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 caller is trapping exits, an {'EXIT', Id, _} message due to the link might have been placed in the caller's message queue prior to the call, though. Note, the {'EXIT', Id, _} message can be the result of the link, but can also be the result of Id calling exit/2. Therefore, it may be appropriate to cleanup the message queue when trapping exits after the call to unlink(Id), as follow:

Removes the registered name RegName, associated with a pid or a port identifier.

> unregister(db).
true

Users are advised not to unregister system processes.

Failure: badarg if RegName is not a registered name.

Returns the pid or port identifier with the registered name RegName. Returns undefined if the name is not registered.

> whereis(db).
<0.43.0>

Voluntarily let other processes (if any) get a chance to execute. Using erlang:yield() is similar to receive after 1 -> ok end, except that yield() is faster.