| Age | Commit message (Collapse) | Author |
|---|
|
* jj1bdx/stdlib/rand-jump/PR-1235/OTP-14038:
Add jump functions to rand module
|
|
* tokitori/stdlib/optimize-sets/PR-1212/OTP-14035:
Speed up sets:add_element/2 and sets:del_element/2
|
|
Jump functions returns the state after performing jump calculation to a
rand module internal state, which is equivalent to perform a large
number of calls of calculating new states for XorShift*/+ algorithms.
This commit add jump functions for exsplus and exs1024 algorithms, and a
wrapper function jump/1. The wrapper function will cause error with
reason "not_implemented" if the jump function for the algorithm is not
implemented.
This commit adds following new functionalities:
- Add new functions rand:jump/0 and rand:jump/1
- Add the member jump to type alg_handler(), a fun for performing
the jump function
- Add jump functions for exsplus, equivalent to 2^64 calls
- Add jump functions for exs1024, equivalent to 2^512 calls
- Revise seed_put/1, seed/1, seed/2
See <https://github.com/erlang/otp/pull/1235#discussion_r86950557>
- Add dummy jump function for exs64 calling
erlang:error(not_implemented)
- Add jump function test cases as follows:
* Add Common Test group reference_jump
* Add tests for jump/0 to reference_jump_procdict/1
* Rename tests for jump/1 to reference_jump_state/1
* Rename gen_jump/1 to gen_jump_1/1
* Add Common Tests reference_jump_procdict and reference_jump_state
to the group reference_jump
- Add jump function documentation
This commit also changes the Copyright year for Kenji Rikitake's code
from 2015 to 2015-2016.
|
|
* siri/appups-20.0:
Update sasl/test/test_lib.hrl with recent versions of kernel and stdlib
Update appups in kernel, stdlib and sasl for OTP-20
|
|
Optimize sets:add_element/2 when adding an element that is already present, and
sets:del_element/2 when the element to be deleted is not present. This optimization
can make certain operations, such as sets:union/2 with many overlapping elements,
up to two orders of magnitude faster.
|
|
|
|
* gandrade/fmod/PR-1216/OTP-14000:
Add test cases for math:fmod/2 BIF
Support math:fmod/2 BIF on compiler
Add math:fmod/2 BIF
|
|
Returns the (floating point) remainder of first argument divided
by second argument.
|
|
This makes proc_lib behaves like a normal process as far
as the propagation of exceptions is concerned.
Before this commit, the following difference could be
observed:
6> spawn_link(fun() -> ssl:send(a,b) end).
<0.43.0>
7> flush().
Shell got {'EXIT',<0.43.0>,
{function_clause,
[{ssl,send,[a,b],[{file,"..."},{line,275}]}]}}
ok
8> proc_lib:spawn_link(fun() -> ssl:send(a,b) end).
<0.46.0>
9> flush().
Shell got {'EXIT',<0.46.0>,function_clause}
After this commit, we get the following instead:
3> flush().
Shell got {'EXIT',<0.61.0>,
{function_clause,
[{ssl,send,[a,b],[{file,"..."},{line,275}]},
{proc_lib,init_p,3,[{file,"..."},{line,232}]}]}}
The stacktrace will show minor differences of course
but the form is now the same as without proc_lib.
The rationale behind this commit is that:
* We now have a single form regardless of how the process
was started
* We can use the stacktrace to programmatically alter behavior
(for example an HTTP server identifying problems in input
decoding to send back a generic 400, or a 500 otherwise)
* We can access the stacktrace to print it somewhere (for
example an HTTP server could send it back to the client
when a debug mode is enabled)
|
|
|
|
Do not start an event timer unless there are no enqueued events.
|
|
Handling of timers and timeouts has been cleaned up
and generalized.
Semantic change regarding state timeout zero:
Previously if one state caused a state timeout zero and
managed to stay in the same state to insert additional
timeout zero(s) in the next state callback invocation, then
there would be only one timeout zero event. The mindset
was that the machine was faster then the timeout zero.
This has changed with the mindset that all state callback
invocations should be independent, so now the machine will
get one state timeout zero event per started state timeout
zero.
Note that just using zero timeouts is fairly esoteric...
|
|
|
|
* maint:
dbg:fun2ms: allow empty list as head
|
|
* gomoripeti/stdlib/ms_fix/PR-1203/OTP-13974:
dbg:fun2ms: allow empty list as head
|
|
|
|
* raimo/gen_statem-improvements/OTP-13929:
Fix race condition in cancel_timer/1
Use parameterized types
Implement state timeouts
Improve docs and types
Change state entry events into state enter calls
Improve docs
Improve docs
Implement state entry events
Implement call/3 dirty_timeout
|
|
|
|
Running 'dbg:fun2ms(fun([]) -> return_trace() end' resulted in an error
"dbg:fun2ms requires fun with single variable or list parameter"
But the empty list is actually a list and it is a valid value as a
match-spec head (matching on arity-0 functions).
Although its practical use is questionable this commit eliminates a
small limitation of ms_transform which is not present in the match-spec
grammar.
|
|
|
|
|
|
|
|
|
|
* rickard/time-unit/OTP-13831:
Replace usage of deprecated time units
|
|
* maint:
parsetools: Correct handling of Unicode in Leex
Don't report error for shutdown exit tuple
|
|
'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
|
|
* maint:
stdlib: Add a testcase for Unicode expander
Support for unicode expander
|
|
* 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.
|
|
|
|
* bjorn/floor-ceiling/OTP-13692:
Add math:floor/1 and math:ceil/1
Implement the new ceil/1 and floor/1 guard BIFs
|
|
Add math:floor/1 and math:ceil/1 to avoid unnecessary conversions
in floating point expressions. That is, instead of having to write
float(floor(X)) as part of a floating point expressions, we can
write simply math:floor(X).
|
|
Implement as ceil/1 and floor/1 as new guard BIFs (essentially part of
Erlang language). They are guard BIFs because trunc/1 is a guard
BIF. It would be strange to have trunc/1 as a part of the language, but
not ceil/1 and floor/1.
|
|
The filters in a list comprehension can be guard expressions or
an ordinary expressions.
If a guard expression is used as a filter, an exception will basically
mean the same as 'false':
t() ->
L = [{some_tag,42},an_atom],
[X || X <- L, element(1, X) =:= some_tag]
%% Returns [{some_tag,42}]
On the other hand, if an ordinary expression is used as a filter, there
will be an exception:
my_element(N, T) -> element(N, T).
t() ->
L = [{some_tag,42},an_atom],
[X || X <- L, my_element(1, X) =:= some_tag]
%% Causes a 'badarg' exception when element(1, an_atom) is evaluated
It has been allowed for several releases to override a BIF with
a local function. Thus, if we define a function called element/2,
it will be called instead of the BIF element/2 within the module.
We must use the "erlang:" prefix to call the BIF.
Therefore, the following code is expected to work the same way as in
our second example above:
-compile({no_auto_import,[element/2]}).
element(N, T) ->
erlang:element(N, T).
t() ->
L = [{some_tag,42},an_atom],
[X || X <- L, element(1, X) =:= some_tag].
%% Causes a 'badarg' exception when element(1, an_atom) is evaluated
But the compiler refuses to compile the code with the following
diagnostic:
call to local/imported function element/2 is illegal in guard
|
|
The compiler would crash in v3_codegen when trying to compile the
following code:
is_port(_) -> false.
foo(P) when port(P) -> ok.
We *could* have the compiler interpret the code as:
is_port(_) -> false.
foo(P) when erlang:is_port(P) -> ok.
But that would encourage using the obsolete form of the guard tests.
Note that the following code is illegal:
is_port(_) -> false.
foo(P) when is_port(P) -> ok.
It produces the following diagnostic:
call to local/imported function is_port/1 is illegal in guard
Therefore, we should refuse to compile the code.
|
|
The previous commits have made sys_pre_expand superfluous. Since
sys_pre_expand is undocumented and unsupported it can be removed in
a major release without prior deprecation.
Also remove code in erl_parse that handles abstract code that has
passed through sys_pre_expand.
We considered deprecating sys_pre_expand just in case, but decided
against it for the following reasons:
- Anyone brave and knowledgeable enough to use sys_pre_expand should
be able to cope with sys_pre_expand being removed.
- If we kept it, but didn't test it anywhere in OTP, it could
potentially stop working. So we would probably have to add some test
cases.
|
|
erl_expand_records now adds "erlang:" to calls to BIFs, so we
can simplify the code.
|
|
As the next step in eliminating sys_pre_expand, teach
erl_expand_records to handle calls without explicit module name. If
such call refer to a BIF or imported function, add an explicit module
name.
That means that any subsequent pass will know that a call without
a module name is always to a local function defined in the module.
|
|
The sys_pre_expand module used to do a lot more (translate records and
funs, for example), but now it does very little. Most of the code is
an identify transformation of the abstract format.
The identity transformation part of the code must be maintained and
kept correct when new forms are added to the abstract format. That
adds to the maintance burden. It also adds (slightly) to compilation
times. Therefore, we want to eliminate sys_pre_expand, moving all of
its (non-identity) transformations to better places.
As a preliminary first step, move the code that adds the pre-defined
functions (such as module_info/0) to a new function in erl_internal.
|
|
* maint:
beam_lib: Correct type for the abstract code chunk
|
|
The abstract_code chunk can also contain {eof,_}, {error,_}, and
{warning,_} in addition to the abstract forms that make up the Erlang
syntax proper.
|
|
|
|
|
