otp.git - Mirror of Erlang/OTP repository.

Age	Commit message (Collapse)	Author
2017-03-10	Update copyright year	Rickard Green

2017-01-17	Merge branch 'rickard/no-harddebug' into maint	Rickard Green
	* rickard/no-harddebug: Do not automatically define HARDDEBUG when DEBUG is defined
2017-01-13	Do not automatically define HARDDEBUG when DEBUG is defined	Rickard Green

2017-01-13	Fix memory leak of temporary heap	Rickard Green
	This bug was introduced in previous commit, and has never been released in an official OTP version.
2016-05-10	erts: Implement max_heap_size process flag	Lukas Larsson
	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}
2016-05-04	Ensure correct reduction counting	Rickard Green

2016-03-15	update copyright-year	Henrik Nord

2015-11-16	erts: Add garbage_collection_info to process_info/2	Lukas Larsson
	This info request returns greater details about the current gc state. This info is not included in the default process_info/1 as it would clutter the default printout with too much information.
2015-11-12	Bump reductions on GC	Rickard Green

2015-11-12	Fragmented young heap generation and off_heap_message_queue option	Rickard Green
	* The youngest generation of the heap can now consist of multiple blocks. Heap fragments and message fragments are added to the youngest generation when needed without triggering a GC. After a GC the youngest generation is contained in one single block. * The off_heap_message_queue process flag has been added. When enabled all message data in the queue is kept off heap. When a message is selected from the queue, the message fragment (or heap fragment) containing the actual message is attached to the youngest generation. Messages stored off heap is not part of GC.
2015-11-12	Introduce literal tag	Rickard Green

2015-06-18	Change license text to APLv2	Bruce Yinhe

2015-03-25	erts: Combine flat and hash maps under one unifying tag	Björn-Egil Dahlberg

2015-03-12	erts: Refactor maps naming convention	Sverker Eriksson
	flatmap: Small map hashmap: Large map map: flatmap or hashmap
2015-03-12	Initial Persistent HAMT - Map framework	Björn-Egil Dahlberg
	Conflicts: erts/emulator/Makefile.in erts/emulator/beam/bif.tab erts/emulator/beam/erl_gc.c erts/emulator/beam/erl_gc.h erts/emulator/beam/erl_printf_term.c erts/emulator/beam/erl_term.c erts/emulator/beam/erl_term.h
2014-10-24	erts: Make hipe_{un}reserve_beam_trap_frame INLINE	Sverker Eriksson

2014-01-28	erts: Initial Map instructions, type and structure	Björn-Egil Dahlberg

2011-12-09	Update copyright years	Björn-Egil Dahlberg

2011-12-02	Get cerl and distribution working in Win64	Patrik Nyblom
	Can still not setup -a, but cerl works.
2010-06-03	OTP-8555 Send message from NIF	Sverker Eriksson
	New NIF features: Send messages from a NIF, or from thread created by NIF, to any local process (enif_send) Store terms between NIF calls (enif_alloc_env, enif_make_copy) Create binary terms with user defined memory management (enif_make_resource_binary)
2009-11-20	The R13B03 release.OTP_R13B03	Erlang/OTP