| Age | Commit message (Collapse) | Author |
|---|
|
Inspiration from module lager_format.
Also some improvements of Unicode handling.
io_lib:format/3 and io_lib:fwrite/3 are new functions. The
representation of the options is a list, but we are considering using
a map instead. If we change, it will happen after Erlang/OTP 21.0-rc1
is released.
|
|
A bug fix: limited maps end with "...", not "...=>...".
A modification: wW separate pairs with " => ", not "=>".
When the output is limited on number of characters, the term is
balanced by wW the same way as is done with pP (see commit bc38638).
|
|
|
|
The name of the io_lib_pretty:print/2 option 'max_chars' is changed to
'line_max_chars' (used by module shell only).
The new option for limiting the number of returned characters of
io_lib_pretty:print() is called 'chars_limit'.
|
|
* hasse/stdlib/map_guards_shell/OTP-15035/ERL-613:
erts: Correct abstract format doc regarding map creation
stdlib: Correct the linter's check of map guard expressions
|
|
* 'map-get-bif' of git://github.com/michalmuskala/otp:
Introduce map_get guard-safe function
OTP-15037
|
|
The check is used by evaluating modules such as erl_eval.
An example: "if map_size(#{}) =:= 0 -> ok end.".
|
|
* raimo/stdlib/gen_statem-dev/OTP-14015:
Fix after feedback
Improve pointer to User's Guide
Fix after feedback on 'When to use'
Add a 'When to use' section
Fix timeout parsing and doc feedback
Improve doc, change images to .svg
erl_docgen: Implement width in image tag
Update User's Guide and pointers to it
Improve error reasons from state enter call
|
|
Rationale
Today all compound data types except for maps can be deconstructed in guards.
For tuples we have `element/2` and for lists `hd/1` and `tl/1`. Maps are
completely opaque to guards. This means matching on maps can't be
abstracted into macros, which is often done with repetitive guards. It
also means that maps have to be always selected whole from ETS tables,
even when only one field would be enough, which creates a potential
efficiency issue.
This PR introduces an `erlang:map_get/2` guard-safe function that allows
extracting a map field in guard. An alternative to this function would be
to introduce the syntax for extracting a value from a map that was planned
in the original EEP: `Map#{Key}`.
Even outside of guards, since this function is a guard-BIF it is more
efficient than using `maps:get/2` (since it does not need to set up the
stack), and more convenient from pattern matching on the map (compare:
`#{key := Value} = Map, Value` to `map_get(key, Map)`).
Performance considerations
A common concern against adding this function is the notion that "guards
have to be fast" and ideally execute in constant time. While there are
some counterexamples (`length/1`), what is more important is the fact
that adding those functions does not change in any way the time
complexity of pattern matching - it's already possible to match on map
fields today directly in patterns - adding this ability to guards will
niether slow down or speed up the execution, it will only make certain
programs more convenient to write.
This first version is very naive and does not perform any optimizations.
|
|
Currently, in sys:stat/2, the message out only count for system events with format
{out, Msg, To}. However, the gen_server:reply/5 will call sys:handle_debug/4
with format {out, Reply, To, State}. That will make the message out count fail
to pattern matching.
Also update sys_SUITE.erl and relevant docs.
|
|
|
|
and not the name. For more sane named table semantics.
Applies to both select/1 continuation and trap context.
|
|
Deprecate erlang:get_stacktrace/1
|
|
|
|
|
|
Those warnings don't make sense any more since erlang:get_stacktrace/0
is now deprecated.
|
|
|
|
for erts, stdlib, kernel and runtime_tools.
|
|
|
|
|
|
In order to get line numbers into the ghlink we have to add a post
processing step for all xml files.
|
|
It was switched to monotnic_time from timestamp 3 years ago
in d927209aa36fe370eb4ecf0a081923b0b951458b
|
|
Compile external fun expressions to literals
OTP-15003
|
|
Change-Id: I5328d5feeac3b7279a8770e8fc27e2d9e8eed359
|
|
* dgud/revert-string-depr:
Revert "Deprecate old string functions"
|
|
The expressions fun M:F/A, when all elements are literals are also
treated as a literal. Since they have consistent representation and
don't depend on the code currently loaded in the VM, this is safe.
This can provide significant performance improvements in code using such
functions extensively - a full function call to erlang:make_fun/3 is
replaced by a single move instruction and no register shuffling or
saving registers to stack is necessary. Additionally, compound data
types that contain such external functions as elements can be treated as
literals too.
The commit also changes the representation of external funs to be a
valid Erlang syntax and adds support for literal external funs to core
Erlang.
|
|
* raimo/type-posix-0-overhaul/ERL_550/OTP-14019:
Update types for posix error codes
|
|
I have read the man pages for most socket and file operations
on recent Linux, FreeBSD, OpenBSD and Solaris 10 and noted
the possible error codes.
Which error codes that are possible for file operations have
been updated in file:posix/0. Error codes for socket operations
in inet:posix/0. The latter refers to the former so it is
a superset, assuming that e.g sendfile and AF_UNIX socket
operations could cause socket operations to return any file
error code. That is not entirely true, but could be,
especially in the future.
Added to file:posix/0 are:
ebadmsg edeadlk edeadlock eftype emultihop enobufs enolck enolink
enosr enostr enosys eopnotsupp eoverflow erange etxtbsy
Added to inet:posix/0 are all but:
exbadport exbadseq file:posix()
These are still possible according to erl_posix_str.c,
but are not in file:posix/0 nor in inet:posix/0,
and many of them are not file nor inet related, but some might be:
e2big eadv ealign ebade ebadfd ebadr ebadrpc ebadrqc
ebadslt ebfont echild echrng ecomm edirty
edom edotdot eduppkg eidrm einit eisnam
elbin el2hlt el2nsync el3hlt el3rst
elibacc elibbad elibexec elibmax elibscn elnrng
enavail enet enoano enocsi enodata enoexec
enonet enosym enotempty enotnam enotuniq
eproclim eprocunavail eprogmismatch eprogunavail
erefused eremchg eremdev eremote eremoteio
eremoterelease erpcmismatch erremote eshutdown
esrmnt esuccesss etime etoomanyrefs
euclean eunatch eusers eversion exfull
sysnotready vernotsupported ediscon enomore
ecancelled einvalidproctable einvalidprovider eproviderfailedinit
syscallfailure service_not_found type_not_found e_no_more
e_cancelled unknown
|
|
[ERL-557] add is_empty/1 to sets and ordsets
OTP-14996, ERL-557, PR-1703
|
|
|
|
It has been decided that it was to early to deprecate the old
string functions.
This partially reverts commit ccb3f7f9768d3c28783c771df47eec1829e51802.
|
|
|
|
|
|
* maint:
Updated OTP version
Update release notes
Update version numbers
ssh: Fix bad spec for double_algs() in ssh.hrl
Test event insert from init
Fix init to allow all actions
Conflicts:
OTP_VERSION
|
|
|
|
|
|
statistics(runtime) does not seem to work on some virtual machines.
|
|
Implementation of true asynchronous signaling between processes
|
|
Communication between Erlang processes has conceptually always been
performed through asynchronous signaling. The runtime system
implementation has however previously preformed most operation
synchronously. In a system with only one true thread of execution, this
is not problematic (often the opposite). In a system with multiple threads
of execution (as current runtime system implementation with SMP support)
it becomes problematic. This since it often involves locking of structures
when updating them which in turn cause resource contention. Utilizing
true asynchronous communication often avoids these resource contention
issues.
The case that triggered this change was contention on the link lock due
to frequent updates of the monitor trees during communication with a
frequently used server. The signal order delivery guarantees of the
language makes it hard to change the implementation of only some signals
to use true asynchronous signaling. Therefore the implementations
of (almost) all signals have been changed.
Currently the following signals have been implemented as true
asynchronous signals:
- Message signals
- Exit signals
- Monitor signals
- Demonitor signals
- Monitor triggered signals (DOWN, CHANGE, etc)
- Link signals
- Unlink signals
- Group leader signals
All of the above already defined as asynchronous signals in the
language. The implementation of messages signals was quite
asynchronous to begin with, but had quite strict delivery constraints
due to the ordering guarantees of signals between a pair of processes.
The previously used message queue partitioned into two halves has been
replaced by a more general signal queue partitioned into three parts
that service all kinds of signals. More details regarding the signal
queue can be found in comments in the erl_proc_sig_queue.h file.
The monitor and link implementations have also been completely replaced
in order to fit the new asynchronous signaling implementation as good
as possible. More details regarding the new monitor and link
implementations can be found in the erl_monitor_link.h file.
|
|
stdlib: Add function lists:search/2
|
|
|
|
|
|
|
|
|
|
make erlang:process_info/1 not retrieve messages
|
|
|
|
Conflicts:
OTP_VERSION
|
|
|
|
Allow multiple modifier characters in io:format control sequences
OTP-14971
|
|
This makes it possible to print unicode atoms at the same time as
suppressing detection of printable lists.
|
