| Age | Commit message (Collapse) | Author |
|---|
|
'legoscia/dynamic-child-shutdown-tuple/ERL-163/PR-1158/OTP-13907' into maint
* legoscia/dynamic-child-shutdown-tuple/ERL-163/PR-1158/OTP-13907:
Don't report error for shutdown exit tuple
|
|
* andrey/stdlib/fix_edlin_expand/ERL-1152:
stdlib: Add a testcase for Unicode expander
Support for unicode expander
|
|
|
|
OTP-13633
|
|
When a simple_one_for_one supervisor is shutting down, and a child
exits with an exit reason of the form {shutdown, Term}, handle it as
if the exit reason were 'shutdown', without printing an error report.
This makes the behaviour of wait_dynamic_children match that of
do_restart.
This fixes ERL-163.
|
|
|
|
The abstract_code chunk can also contain {eof,_}, {error,_}, and
{warning,_} in addition to the abstract forms that make up the Erlang
syntax proper.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
'raimo/stdlib/gen_statem-types-and-templates/ERL-172_ERL-187/OTP-13746' into maint
* raimo/stdlib/gen_statem-types-and-templates/ERL-172_ERL-187/OTP-13746:
Fix type and template errors from bugs.erlang.org: ERL-172 and ERL-187
|
|
|
|
|
|
ets:match_object/1 and ets:match_object/3 return list of matches
|
|
See also ERL-182.
|
|
|
|
* bjorn/stdlib/deprecate-queue-lait/OTP-13658:
Deprecate queue:lait/1
|
|
|
|
* hasse/dialyzer/improve_from_form/OTP-13547:
Update primary bootstrap
stdlib: Correct types and specs
dialyzer: Minor adjustments
dialyzer: Suppress unmatched_return for send/2
dialyzer: Improve the translation of forms to types
dialyzer: Use a cache when translating forms to types
dialyzer: Prepare erl_types:t_from_form() for a cache
dialyzer: Optimize erl_types:t_form_form()
dialyzer: Correct types
syntax_tools: Correct types
erts: Correct character repr in doc of the abstract format
stdlib: Correct types and specs
|
|
It is possible that '...' is added later (OTP 20.0), but for now we
are not sure of all details.
|
|
|
|
|
|
* josevalim/supervisor-get-callback-module/PR-1000/OTP-13619:
Return callback module in supervisor format_status
|
|
The previous implementation of supervisor:get_callback_module/1
used sys:get_status/1 to get the supervisor inner state and
retrieve the callback module. Such implementation forbids any
other supervisor implementation that has an internal state
different than the #state{} record in supervisor.erl.
This patch allows supervisors to return the callback module
as part of the sys:get_status/1 data, no longer coupling the
callback module implementation with the inner #state{} record.
Notice we have kept the clause matching the previous
sys:get_status/1 reply for backwards compatibility purposes.
|
|
* rickard/rt-dep-erts-kernel-stdlib-sasl:
Bumped runtime dependencies between erts, kernel, stdlib, sasl
|
|
* dgud/stdlib/relax-proc_lib-initial-call/OTP-13623:
Relax translation of initial calls
|
|
* kostis/beam_disasm-entry-type/PR-1072:
Declare the type of function entry points
Export label() type
|
|
|
|
|
|
|
|
just to make things simpler.
|
|
Remove the restriction to only do the translation for
gen_server and gen_fsm. This enables user defined
gen based generic callback modules to be displayed nicely in
c:i() and observer.
|
|
* josevalim/supervisor-try-again-restart/PR-1001/OTP-13618:
Avoid potential timer bottleneck on supervisor restart
|
|
* mururu/stdlib/fix-deprecated-warnings/PR-1050/OTP-13594:
Fix deprecated warnings
|
|
The max_heap_size process flag can be used to limit the
growth of a process heap by killing it before it becomes
too large to handle. It is possible to set the maximum
using the `erl +hmax` option, `system_flag(max_heap_size, ...)`,
`spawn_opt(Fun, [{max_heap_size, ...}])` and
`process_flag(max_heap_size, ...)`.
It is possible to configure the behaviour of the process
when the maximum heap size is reached. The process may be
sent an untrappable exit signal with reason kill and/or
send an error_logger message with details on the process
state. A new trace event called gc_max_heap_size is
also triggered for the garbage_collection trace flag
when the heap grows larger than the configured size.
If kill and error_logger are disabled, it is still
possible to see that the maximum has been reached by
doing garbage collection tracing on the process.
The heap size is defined as the sum of the heap memory
that the process is currently using. This includes
all generational heaps, the stack, any messages that
are considered to be part of the heap and any extra
memory the garbage collector may need during collection.
In the current implementation this means that when a process
is set using on_heap message queue data mode, the messages
that are in the internal message queue are counted towards
this value. For off_heap, only matched messages count towards
the size of the heap. For mixed, it depends on race conditions
within the VM whether a message is part of the heap or not.
Below is an example run of the new behaviour:
Eshell V8.0 (abort with ^G)
1> f(P),P = spawn_opt(fun() -> receive ok -> ok end end, [{max_heap_size, 512}]).
<0.60.0>
2> erlang:trace(P, true, [garbage_collection, procs]).
1
3> [P ! lists:duplicate(M,M) || M <- lists:seq(1,15)],ok.
ok
4>
=ERROR REPORT==== 26-Apr-2016::16:25:10 ===
Process: <0.60.0>
Context: maximum heap size reached
Max heap size: 512
Total heap size: 723
Kill: true
Error Logger: true
GC Info: [{old_heap_block_size,0},
{heap_block_size,609},
{mbuf_size,145},
{recent_size,0},
{stack_size,9},
{old_heap_size,0},
{heap_size,211},
{bin_vheap_size,0},
{bin_vheap_block_size,46422},
{bin_old_vheap_size,0},
{bin_old_vheap_block_size,46422}]
flush().
Shell got {trace,<0.60.0>,gc_start,
[{old_heap_block_size,0},
{heap_block_size,233},
{mbuf_size,145},
{recent_size,0},
{stack_size,9},
{old_heap_size,0},
{heap_size,211},
{bin_vheap_size,0},
{bin_vheap_block_size,46422},
{bin_old_vheap_size,0},
{bin_old_vheap_block_size,46422}]}
Shell got {trace,<0.60.0>,gc_max_heap_size,
[{old_heap_block_size,0},
{heap_block_size,609},
{mbuf_size,145},
{recent_size,0},
{stack_size,9},
{old_heap_size,0},
{heap_size,211},
{bin_vheap_size,0},
{bin_vheap_block_size,46422},
{bin_old_vheap_size,0},
{bin_old_vheap_block_size,46422}]}
Shell got {trace,<0.60.0>,exit,killed}
|
|
* bjorn/stdlib/warning-and-error/OTP-13476:
Add documentation
epp: Add the -error and -warning directives
epp: Refactor expansion of header path
|
|
In current deprecated warnings such as `crypto:rand_bytes/1 is deprecated
and will be removed in in a future release; use crypto:strong_rand_bytes/1`,
the word "in" is duplicated.
|
|
* raimo/polish-gen_statem/OTP-13065:
Fix documentation
Clean up terminate functions
Fix callback mode after code change not used
Restructure loop_* to clarify S handling
|
|
|
|
If one of several alternatives configurations are required for
an Erlang module to compile, but none are available, it would
be useful to give a nice error message. For example:
-ifdef(CONFIG_A).
%% Some code if A is true.
-else.
-ifdef(CONFIG_B).
%% Some code if B is true.
-else.
-error("Neither CONFIG_A nor CONFIG_B are available").
-endif.
-endif.
If neither CONFIG_A nor CONFIG_B are defined, the error message
will be:
module.erl:10: -error("Neither CONFIG_A nor CONFIG_B are available").
That is basically the same behavior as for the #error directive in
GCC.
For symmetry with the -error directive, add the -warning
directive to generate a compiler warning. For example:
-ifdef(HAVE_COOL_FEATURE).
%% Code if we have Cool Feature.
-else.
%% Inefficient fallback code.
-warning("Using inefficient fallback").
-endif.
If HAVE_COOL_FEATURE is not defined, the warning message will
be:
module.erl:8: Warning: -warning("Using inefficient fallback").
That is basically the same behavior as for the #warning directive
in GCC.
Conflicts:
lib/stdlib/src/epp.erl
lib/stdlib/test/epp_SUITE.erl
|
|
scan_include_lib/4 uses a helper function find_lib_dir/1, which has a
strange interface. It takes a string and returns a tuple. The caller
must match the tuple and call fname_join/1 to obtain the desired
result. I assume that the strange interface was not noticed because
the function is only used in one place.
Replace the find_lib_dir/1 with a new expand_lib_dir/1 function which
does the entire job in one go. The new function is much easier to
reuse in other places, which we might want to do in a future commit.
|
|
* egil/stdlib/fix-maps-alias/ERL-135/OTP-13534:
stdlib: Strengthen map pattern tests
stdlib: Add lint tests for parallel match of maps
stdlib: Refactor erl_lint_SUITE
stdlib: Fix linting of map key variables
|
|
* lukas/erts/rename_xmqd_to_hmqd/OTP-13366:
erts: Rename erl flag +xmqd to +hmqd in erlexec
Fix proc_lib message_queue_data spec
erts: Fix total_heap_size calculation for on_heap
erts: Rename erl flag +xmqd to +hmqd
|
|
Map keys cannot be bound and then used in parallel matching.
Example:
#{ K := V } = #{ k := K } = M.
This is illegal if 'K' is not already bound.
|
|
* jlouis/stdlib/implement-lists-join/PR-1012/OTP-13523:
Implement lists:join/2
|
|
'...' is allowed at the end of of association types.
|
|
Type information is stored in erl_bif_types for certain BIFs.
This fact must be stated in the type specification for the
stubs that are superceded by erl_bif_types.
* Shadowed by erl_bif_types: maps:from_list/1
* Shadowed by erl_bif_types: maps:get/2
* Shadowed by erl_bif_types: maps:is_key/2
* Shadowed by erl_bif_types: maps:merge/2
* Shadowed by erl_bif_types: maps:put/3
* Shadowed by erl_bif_types: maps:to_list/1
* Shadowed by erl_bif_types: maps:update/3
|
