| Age | Commit message (Collapse) | Author |
|---|
|
|
|
|
|
* hasse/stdlib/chars_limit_io/OTP-14983:
stdlib: Modify the printing of map associations with wWpP
stdlib: Introduce characters limit of formated strings
stdlib: Modify ~w/~W when number of characters is limited
stdlib: io_lib{_pretty}: Avoid tuple_to_list when possible
stdlib: Introduce characters limit of formatted strings
|
|
Use the same depth for all (printed) elements of a map.
Since the order of keys can vary when printing a map--maps:iterator/1
and maps:next/1 are used--it is more consistent to print all
associations with the same depth.
If the associations printed are limited by the depth, the selection
of associations is arbitrary, as before.
|
|
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.
|
|
Remove config test of MAP_NORESERVE for hipe on x86_64
|
|
* hans/ssh/type_changes/OTP-15002:
ssh: Changes suggested by dialyzer
ssh: New -spec and -type
|
|
|
|
|
|
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
|
|
Do not use lists:concat where lists:append is intended
|
|
|
|
|
|
* 'map-get-bif' of git://github.com/michalmuskala/otp:
Introduce map_get guard-safe function
OTP-15037
|
|
IngelaAndin/ingela/ssl/hello-pause/ERL-169/OTP-14372
Add new API functions to enable smoother user customizations based on TLS hello extensions
|
|
* lukas/erts/poll-thread/OTP-14346:
erts: nif resource stop from poll-thread is a indirect call
|
|
* lukas/erts/dump_SUITE_fix:
erts: Increase file read timeout for signal_abort test
|
|
* john/erts/fix-lcnt-toggle-test:
Disregard locks that can't be toggled in lcnt_SUITE
|
|
Improve memory instrumentation
OTP-15024
OTP-14961
|
|
|
|
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
|
|
* maint:
Updated OTP version
Prepare release
ssh: Fix server crashes for exit-normal signals
|
|
* maint-18:
Updated OTP version
Prepare release
ssh: Fix server crashes for exit-normal signals
Conflicts:
OTP_VERSION
lib/ssh/doc/src/notes.xml
lib/ssh/src/ssh_connection_handler.erl
lib/ssh/vsn.mk
otp_versions.table
|
|
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.
|
|
* lukas/erl_docgen/add_github_contrib_link/OTP-14979:
erl_docgen: Fix title link with '?'
|
|
* peterdmv/httpd_reload_config/ERL-578/OTP-15025:
inets: Fix httpd:reload_config/2
Change-Id: Ib02587ac75f7f9f4ce665c6ead54b5ab11560411
|
|
erl_interface: fix bad memset
|
|
* peterdmv/relative_path_script_alias/ERL-574/OTP-15021:
inets: Fix handling of relative paths in script_alias
Change-Id: I6874d37f538bde0e54276f2841dbb763e1d19ff6
|
|
fix integer truncation bugs in error logger path
|
|
|
|
|
|
|
|
|
|
* sverker/valgrind-uninit-run_queue-ptr:
erts: Fix run queue pointer in proxy process
|
|
* sverker/ets-cherries/OTP-15031:
erts: Use table ref for select continuation
erts: Refactor erl_db_hash next() into next_live()
erts: Change wrong alloc_fnf
|
|
This commit replaces the old memory instrumentation with a new
implementation that scans carriers instead of wrapping
erts_alloc/erts_free. The old implementation could not extract
information without halting the emulator, had considerable runtime
overhead, and the memory maps it produced were noisy and lacked
critical information.
Since the new implementation walks through existing data structures
there's no longer a need to start the emulator with special flags to
get information about carrier utilization/fragmentation. Memory
fragmentation is also easier to diagnose as it's presented on a
per-carrier basis which eliminates the need to account for "holes"
between mmap segments.
To help track allocations, each allocation can now be tagged with
what it is and who allocated it at the cost of one extra word per
allocation. This is controlled on a per-allocator basis with the
+M<S>atags option, and is enabled by default for binary_alloc and
driver_alloc (which is also used by NIFs).
|
|
|
|
* hans/ssh/remove_dead_files/OTP-15028:
ssh: Remove unused ssh_client_key.erl and ssh_server_key.erl
|
|
|
|
|
|
* hans/ssh/server_exit_normal_exit/OTP-15018:
ssh: Fix server crashes for exit-normal signals
|
|
- Add proper handling of path() as the first argument to
httpd:reload_config/2.
Change-Id: Ia5779bdd55bff974e8eb0dd16ef26edf1f52fcff
|
|
* lukas/erts/seq_tracer_nif/OTP-15029:
Fix seq_trace erl_tracer bug
Fix makefile mkdir warning
|
|
* john/erts/fix-sbwt-links:
Fix seealso tags for +sbwt/+swt
|
|
Compiling OTP-20.3.4 with GCC-7 generates the following warning:
CC /tmp/otp_src_20.3.4/lib/erl_interface/obj.st/x86_64-unknown-linux-gnu/erl_marshal.o
legacy/erl_marshal.c: In function 'erl_init_marshal':
legacy/erl_marshal.c:110:5: warning: 'memset' used with length equal to number of elements without multiplication by element size [-Wmemset-elt-size]
memset(cmp_array, 0, CMP_ARRAY_SIZE);
^~~~~~
CMP_ARRAY_SIZE (256) is the number of elements in that array, but the
elements are not char but enum, which is 4 bytes on e.g. x86-64.
This results in 3/4 of the array not being correctly initialized.
Idiomatic C is to pass sizeof cmp_array to memset(), so that's what I did.
|
|
Sending a large term to the error logger has two problems related
to the size and sign of the variables used to represent lengths:
- the API functions (erts_send_error_term_to_logger() et al) perform
an unchecked narrowing conversion from size_t to int when passing
dsbufp->str_len to the internal functions; this may both truncate
the length and make it negative
- do_send_term_to_logger() and do_send_to_logger() multiply the
int-typed length by 2 before widening it to Uint and adding a few
more values; the intermediate product may overflow causing loss
of high bits and a change of sign; if the intermediate product is
negative the final size will be an extremely large positive value
The end result is that the computed buffer size can be arbitrarily
wrong, either too small or too large.
While reviewing this code I also found and fixed a potential narrowing
bug in erts_set_hole_marker().
|
