| Age | Commit message (Collapse) | Author |
|---|
|
|
|
|
|
This refactor was done using the unifdef tool like this:
for file in $(find erts/ -name *.[ch]); do unifdef -t -f defile -o $file $file; done
where defile contained:
#define ERTS_SMP 1
#define USE_THREADS 1
#define DDLL_SMP 1
#define ERTS_HAVE_SMP_EMU 1
#define SMP 1
#define ERL_BITS_REENTRANT 1
#define ERTS_USE_ASYNC_READY_Q 1
#define FDBLOCK 1
#undef ERTS_POLL_NEED_ASYNC_INTERRUPT_SUPPORT
#define ERTS_POLL_ASYNC_INTERRUPT_SUPPORT 0
#define ERTS_POLL_USE_WAKEUP_PIPE 1
#define ERTS_POLL_USE_UPDATE_REQUESTS_QUEUE 1
#undef ERTS_HAVE_PLAIN_EMU
#undef ERTS_SIGNAL_STATE
|
|
|
|
CFLAGS weren't updated to include the sys/common directory for this build
target.
|
|
* john/erts/runtime-lcnt:
Document rt_mask and add warnings about copy_save
Add an emulator test suite for lock counting
Break erts_debug:lock_counters/1 into separate BIFs
Allow toggling lock counting at runtime
Move lock flags to a common header
Enable register_SUITE for lcnt builds
Enable lcnt smoke test on all builds that have lcnt enabled
Make lock counter info independent of the locks being counted
OTP-14412
OTP-13170
OTP-14413
|
|
The implementation is still hidden behind ERTS_ENABLE_LOCK_COUNT, and
all categories are still enabled by default, but the actual counting can be
toggled at will.
OTP-13170
|
|
|
|
* rickard/escript-space-path-fix/OTP-14433:
escript: Do not split path to Erlang system into multiple words
|
|
Fix erlang system lookup from escript bug introduced in PR #1293
OTP-14201
|
|
escript failed to start Erlang systems with spaces in the
absolute path (when absolute path was used).
|
|
Erlang system found in PATH was used even when explicitly pointing out
the escript binary in another Erlang system.
|
|
Changing argv[0] from emu name to progname if ESCRIPT_NAME was not set
caused to many failing scripts, revert that part of the change.
See 86f6a9856
|
|
Add the option -emu_type to start an emulator of a certain
type. For exampe, "-emu_type lcnt" will start beam.lcnt.smp.
Any string will be accepted after -emu_type. If there is no
corresponding emulator, there will be an error similar to:
erlexec: The emulator '.../bin/x86_64-unknown-linux-gnu/beam.foo.smp' does not exist.
On Windows, there is an undocumented option "-debug". Remove
that option, because -emu_type can be used instead.
|
|
|
|
* dgud/erts/erlscript_name:
Rename argv[0] from beam to invoking program name
OTP-14381
|
|
OTP-14380
* rickard/ds-stack-size:
Suggested stack size options for dirty schedulers
|
|
Allows ps and htop to display the invoking program/script name
instead of beam[.smp].
|
|
|
|
* bjorn/dialyzer/add-typer/OTP-14336:
Add smoke test for TypER
Add back TypEr to the main OTP repository
|
|
It turned out that the dependencies between Dialyzer
and TypEr makes it impractical to have TypEr in a
separate repository.
Add it back to the OTP repository, but put the Erlang
module 'typer' in the dialyzer application.
|
|
|
|
|
|
* lukas/erts/hide-debug-consoles:
erts: Only show debug consoles if ERL_CONSOLE_MODE is defined
|
|
The application now has an own repo, https://github.com/erlang/typer
|
|
|
|
|
|
The code has been rearranged to make use of the actual path
"get_default_emulator(scriptname)" to the escript instead of
the given one "get_default_emulator(argv[0])".
TL;DR
Assume a source system with some Erlang applications (app1, app2 etc.)
and an escript called "mytool". When generating a standalone target
system (with reltool for example), the escript(s) are located in the
same top bin directory as "erl". See mytool* below.
In such a system the original "mytool" escript is given the extension
".escript" and the file with the same name as the original escript is
a copy of the "escript" executable. One purpose of the escript
executable is to determine which "erl" to use to start the system.
In a standalone system we want it to find the runtime system bundled
with the escript(s). This is done by analyzing the path in order to
find the "erl" located in the same directory as the escript.
A dilemma here is that we do not want to put the top bin directory
in the execution path (PATH env var) as we then would cause other
Erlang applications to make use of our bundled run-time system.
One way of solving this is to choose some suitable bin directory in
the execution path (such as /user/local/bin) and put a symbolic link
there to our mytool executable.
Unfortunately this did not work as the escript executable (in this
case called mytool) would try to find "erl" in /usr/local/bin and when
it did not find such a file it resorted to use the command "erl" which
would find some (unwanted) "erl" in the execution path.
My fix solves that problem.
├── bin/
│ ├── erl* (dyn_erl.c)
│ ├── mytool* (escript.c)
│ ├── mytool.escript* (original mytool escript)
│ └── start_clean.boot
├── erts-vsn/
│ └── bin/
│ ├── beam*
│ ├── beam.smp*
│ ├── erl*
│ ├── erl_child_setup*
│ ├── erlexec*
│ └── inet_gethost*
└── lib/
├── app1-vsn
├── app2-vsn
└── ...
|
|
Hardware watchdog support was removed from heart in R13A, but there were
still some vestiges in the code and the documentation.
- Remove mentions of the HW_WD_DISABLE variable, as it's no longer used.
- Remove the HEART_BEAT_BOOT_DELAY variable, as it was only used for the
hardware watchdog.
|
|
* dotsimon/erts/heart_no_kill/OTP-13650:
erts: Fix HEART_NO_KILL logic
|
|
|
|
* dotsimon/erts/heart_no_kill/OTP-13650:
erts: make HEART_NO_KILL have to be set to TRUE
Don't kill old erlang if HEART_NO_KILL is set
Conflicts:
lib/kernel/doc/src/heart.xml
|
|
|
|
If the environment variable HEART_NO_KILL is set then
heart won't kill the old erlang process. This is desirable
if the command executed by heart takes care of this.
|
|
Add a command line option that lets you disable automatic starting of
epmd when starting a distributed node.
This differs from the undocumented setting -no_epmd, in that it does
not affect the starting of an erl_epmd process within
erl_distribution: the newly started node will expect an epmd instance
to have been started previously.
|
|
* rickard/ds-proc-exit/OTP-13123:
Add dirty_heap_access test case
Add dirty_call_while_terminated test case
Move dirty nif test cases into dirty_nif_SUITE
Add better support for communication with a process executing dirty NIF
Remove conditional dirty schedulers API
|
|
|
|
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}
|
|
|
|
|
|
that uses its own super carrier (erts_exec_mmapper)
to guarantee low addressed and executable memory (PROT_EXEC).
Currently only used on x86_64 that needs low memory
for HiPE/AMD64's small code model.
By initializing erts_exec_mapper early we secure
its low memory area before erts_literal_mmapper might
steal it.
|
|
* henrik/update-copyrightyear:
update copyright-year
|
|
* msantos/erts/cli-abort-on-alloc-fail/PR-948/OTP-13486:
erts/common: check for OOM on Windows
|
|
|
|
* sverk/literal-alloc-polish:
erts: Add emulator flag +MIscs for literal super carrier size
erts: Refactor init of erts_literal_mmapper
erts: Make literal_alloc documented and configurable
|
|
Conflicts:
erts/emulator/beam/erl_alloc.types
erts/emulator/beam/erl_bif_info.c
erts/emulator/beam/erl_process.c
erts/preloaded/ebin/erts_internal.beam
|
|
|
|
Except it cannot be disabled and cannot be multi-threaded.
The bit-vector 'erts_literal_vspace_map' on 32-bit is currently only
protected by the literal allocator mutex. We could allow multiple
instances on 64-bit (I think), but what would be the point?
|
|
|
|
Fix the command line tools to abort on allocation failures when run
on Windows. Modify the malloc() wrapper to consistently return void*
across all the tools.
|
