From ca0425c6ff85262bc15367f5fd9cbc51cde52b20 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Wed, 2 Oct 2013 10:07:27 +0200
Subject: Execution of system tasks in context of another process

A process requesting a system task to be executed in the context of
another process will be notified by a message when the task has
executed. This message will be on the form:
  {RequestType, RequestId, Pid, Result}.

A process requesting a system task to be executed can set priority
on the system task. The requester typically set the same priority
on the task as its own process priority, and by this avoiding
priority inversion. A request for execution of a system task is
made by calling the statically linked in NIF
erts_internal:request_system_task(Pid, Prio, Request). This is an
undocumented ERTS internal function that should remain so. It
should *only* be called from BIF implementations.

Currently defined system tasks are:
* garbage_collect
* check_process_code

Further system tasks can and will be implemented in the future.

The erlang:garbage_collect/[1,2] and erlang:check_process_code/[2,3]
BIFs are now implemented using system tasks. Both the
'garbage_collect' and the 'check_process_code' operations perform
or may perform garbage_collections. By doing these via the
system task functionality all garbage collect operations in the
system will be performed solely in the context of the process
being garbage collected. This makes it possible to later implement
functionality for disabling garbage collection of a process over
context switches.

Newly introduced BIFs:

* erlang:garbage_collect/2 - The new second argument is an option
  list. Introduced option:
  * {async, RequestId} - making it possible for users to issue
    asynchronous garbage collect requests.

* erlang:check_process_code/3 -  The new third argument is an
  option list. Introduced options:
  * {async, RequestId} - making it possible for users to issue
    asynchronous check process code requests.
  * {allow_gc, boolean()} - making it possible to issue requests
    that aren't allowed to garbage collect (operation will abort
    if gc should be needed).
  These options have been introduced as a preparation for
  parallelization of check_process_code operations when the
  code_server is about to purge a module.
---
 erts/preloaded/src/erts_internal.erl | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 8a8cd52d64..c8e8e7e069 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -33,6 +33,10 @@
 -export([port_command/3, port_connect/2, port_close/1,
 	 port_control/3, port_call/3, port_info/1, port_info/2]).
 
+-export([request_system_task/3]).
+
+-export([check_process_code/2]).
+
 %%
 %% Await result of send to port
 %%
@@ -139,3 +143,20 @@ port_info(_Result) ->
 
 port_info(_Result, _Item) ->
     erlang:nif_error(undefined).
+
+-spec request_system_task(Pid, Prio, Request) -> 'ok' when
+      Prio :: 'max' | 'high' | 'normal' | 'low',
+      Request :: {'garbage_collect', term()}
+	       | {'check_process_code', term(), module(), boolean()},
+      Pid :: pid().
+
+request_system_task(_Pid, _Prio, _Request) ->
+    erlang:nif_error(undefined).
+
+-spec check_process_code(Module, OptionList) -> boolean() when
+      Module :: module(),
+      Option :: {allow_gc, boolean()},
+      OptionList :: [Option].
+check_process_code(_Module, _OptionList) ->
+    erlang:nif_error(undefined).
+
-- 
cgit v1.2.3


From d5b6c6f0bd96108d788cdfb9be15059125b3d87f Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Wed, 16 Oct 2013 16:28:21 +0200
Subject: erts: Add erlang wrappers to binary_to_term

to not expose the trapping BIF in the stacktrace
when it throws badarg.
---
 erts/preloaded/src/erts_internal.erl | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index c8e8e7e069..d6a185482e 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -29,7 +29,7 @@
 -module(erts_internal).
 
 -export([await_port_send_result/3]).
-
+-export([binary_to_term/1, binary_to_term/2]).
 -export([port_command/3, port_connect/2, port_close/1,
 	 port_control/3, port_call/3, port_info/1, port_info/2]).
 
@@ -160,3 +160,13 @@ request_system_task(_Pid, _Prio, _Request) ->
 check_process_code(_Module, _OptionList) ->
     erlang:nif_error(undefined).
 
+-spec binary_to_term(Binary) -> term() when
+      Binary :: binary().
+binary_to_term(_Binary) ->
+    erlang:nif_error(undefined).
+
+-spec binary_to_term(Binary, Opts) -> term() when
+      Binary :: binary(),
+      Opts :: [safe].
+binary_to_term(_Binary, _Opts) ->
+    erlang:nif_error(undefined).
-- 
cgit v1.2.3


From 76b8ea8ab1eb4ce099f88ccb8d1721c438d0ada4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Thu, 12 Dec 2013 10:58:59 +0100
Subject: erts: Add BIF erts_internal:cmp_term/2

Compares terms where integer() < float().
---
 erts/preloaded/src/erts_internal.erl | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index d6a185482e..88eb317f1d 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -170,3 +170,13 @@ binary_to_term(_Binary) ->
       Opts :: [safe].
 binary_to_term(_Binary, _Opts) ->
     erlang:nif_error(undefined).
+
+%% term compare where integer() < float() = true
+
+-spec cmp_term(A,B) -> Result when
+    A :: term(),
+    B :: term(),
+    Result :: -1 | 0 | 1.
+
+cmp_term(_A,_B) ->
+    erlang:nif_error(undefined).
-- 
cgit v1.2.3


From 3645dc6b15d4fdd79768b92bb598c264005a8689 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Tue, 14 Jan 2014 12:30:51 +0100
Subject: preloaded: Fixup export cmp_term in erts_internal

---
 erts/preloaded/src/erts_internal.erl | 1 +
 1 file changed, 1 insertion(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 88eb317f1d..edcd50c77e 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -30,6 +30,7 @@
 
 -export([await_port_send_result/3]).
 -export([binary_to_term/1, binary_to_term/2]).
+-export([cmp_term/2]).
 -export([port_command/3, port_connect/2, port_close/1,
 	 port_control/3, port_call/3, port_info/1, port_info/2]).
 
-- 
cgit v1.2.3


From 5b62ab3db6292a731fccfc31eafec7e9fb0906df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Fri, 9 May 2014 18:32:05 +0200
Subject: erts: Add spec for erts_internal:map_to_tuple_keys/1

---
 erts/preloaded/src/erts_internal.erl | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index edcd50c77e..764d7730aa 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -31,6 +31,7 @@
 -export([await_port_send_result/3]).
 -export([binary_to_term/1, binary_to_term/2]).
 -export([cmp_term/2]).
+-export([map_to_tuple_keys/1]).
 -export([port_command/3, port_connect/2, port_close/1,
 	 port_control/3, port_call/3, port_info/1, port_info/2]).
 
@@ -181,3 +182,11 @@ binary_to_term(_Binary, _Opts) ->
 
 cmp_term(_A,_B) ->
     erlang:nif_error(undefined).
+
+%% return the internal key tuple for map keys
+-spec map_to_tuple_keys(M) -> Keys when
+    M :: map(),
+    Keys :: tuple().
+
+map_to_tuple_keys(_M) ->
+    erlang:nif_error(undefined).
-- 
cgit v1.2.3


From 82c048745efcb5d811ec0489858b821ef39ea387 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Mon, 19 May 2014 18:09:13 +0200
Subject: Replace erlang:binary_to_term() Erlang wrappers

Replace the 'erlang:binary_to_term/1' and 'erlang:binary_to_term/2'
Erlang wrappers taking care of failure after yield with management
of this in the hidden yield BIF.
---
 erts/preloaded/src/erts_internal.erl | 12 ------------
 1 file changed, 12 deletions(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index edcd50c77e..e9044503b3 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -29,7 +29,6 @@
 -module(erts_internal).
 
 -export([await_port_send_result/3]).
--export([binary_to_term/1, binary_to_term/2]).
 -export([cmp_term/2]).
 -export([port_command/3, port_connect/2, port_close/1,
 	 port_control/3, port_call/3, port_info/1, port_info/2]).
@@ -161,17 +160,6 @@ request_system_task(_Pid, _Prio, _Request) ->
 check_process_code(_Module, _OptionList) ->
     erlang:nif_error(undefined).
 
--spec binary_to_term(Binary) -> term() when
-      Binary :: binary().
-binary_to_term(_Binary) ->
-    erlang:nif_error(undefined).
-
--spec binary_to_term(Binary, Opts) -> term() when
-      Binary :: binary(),
-      Opts :: [safe].
-binary_to_term(_Binary, _Opts) ->
-    erlang:nif_error(undefined).
-
 %% term compare where integer() < float() = true
 
 -spec cmp_term(A,B) -> Result when
-- 
cgit v1.2.3


From 7a9b4fe58c17c95c9be0ad13d33fce5042db24b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 16 Mar 2015 14:45:17 +0100
Subject: erts: Add map decomposition wrappers

* erts_internal:map_type/1
* erts_internal:map_hashmap_children/1
---
 erts/preloaded/src/erts_internal.erl | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 2c5bd82cf0..5756d80424 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -30,7 +30,7 @@
 
 -export([await_port_send_result/3]).
 -export([cmp_term/2]).
--export([map_to_tuple_keys/1]).
+-export([map_to_tuple_keys/1, map_type/1, map_hashmap_children/1]).
 -export([port_command/3, port_connect/2, port_close/1,
 	 port_control/3, port_call/3, port_info/1, port_info/2]).
 
@@ -178,3 +178,20 @@ cmp_term(_A,_B) ->
 
 map_to_tuple_keys(_M) ->
     erlang:nif_error(undefined).
+
+%% return the internal map type
+-spec map_type(M) -> Type when
+    M :: map(),
+    Type :: 'flatmap' | 'hashmap' | 'hashmap_node'.
+
+map_type(_M) ->
+    erlang:nif_error(undefined).
+
+%% return the internal hashmap sub-nodes from
+%% a hashmap node
+-spec map_hashmap_children(M) -> Children when
+    M :: map(), %% hashmap node
+    Children :: [map() | nonempty_improper_list(term(),term())].
+
+map_hashmap_children(_M) ->
+    erlang:nif_error(undefined).
-- 
cgit v1.2.3


From 6487aac5977cf470bc6a2cd0964da2850ee38717 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Thu, 30 Oct 2014 23:57:01 +0100
Subject: Introduce a new time API

The old time API is based on erlang:now/0. The major issue with
erlang:now/0 is that it was intended to be used for so many
unrelated things. This tied these unrelated operations together
and unnecessarily caused performance, scalability as well as
accuracy, and precision issues for operations that do not need
to have such issues. The new API spreads different functionality
over multiple functions in order to improve on this.

The new API consists of a number of new BIFs:
- erlang:convert_time_unit/3
- erlang:monotonic_time/0
- erlang:monotonic_time/1
- erlang:system_time/0
- erlang:system_time/1
- erlang:time_offset/0
- erlang:time_offset/1
- erlang:timestamp/0
- erlang:unique_integer/0
- erlang:unique_integer/1
- os:system_time/0
- os:system_time/1

and a number of extensions of existing BIFs:
- erlang:monitor(time_offset, clock_service)
- erlang:system_flag(time_offset, finalize)
- erlang:system_info(os_monotonic_time_source)
- erlang:system_info(time_offset)
- erlang:system_info(time_warp_mode)
- erlang:system_info(time_correction)
- erlang:system_info(start_time)

See the "Time and Time Correction in Erlang" chapter of the
ERTS User's Guide for more information.
---
 erts/preloaded/src/erts_internal.erl | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 2c5bd82cf0..30df75b406 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -38,6 +38,10 @@
 
 -export([check_process_code/2]).
 
+-export([flush_monitor_messages/3]).
+
+-export([time_unit/0]).
+
 %%
 %% Await result of send to port
 %%
@@ -178,3 +182,29 @@ cmp_term(_A,_B) ->
 
 map_to_tuple_keys(_M) ->
     erlang:nif_error(undefined).
+
+-spec erts_internal:flush_monitor_messages(Ref, Multi, Res) -> term() when
+      Ref :: reference(),
+      Multi :: boolean(),
+      Res :: term().
+
+%% erlang:demonitor(Ref, [flush]) traps to
+%% erts_internal:flush_monitor_messages(Ref, Res) when
+%% it needs to flush monitor messages.
+flush_monitor_messages(Ref, Multi, Res) when is_reference(Ref) ->
+    receive
+	{_, Ref, _, _, _} ->
+	    case Multi of
+		false ->
+		    Res;
+		_ ->
+		    flush_monitor_messages(Ref, Multi, Res)
+	    end
+    after 0 ->
+	    Res
+    end.
+
+-spec erts_internal:time_unit() -> pos_integer().
+
+time_unit() ->
+    erlang:nif_error(undefined).
-- 
cgit v1.2.3


From 6b1921d767de5cd1a980234f83b36dbfa13d9fc7 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Fri, 13 Feb 2015 00:25:57 +0100
Subject: Erlang based BIF timer implementation for scalability

---
 erts/preloaded/src/erts_internal.erl | 251 +++++++++++++++++++++++++++++++++++
 1 file changed, 251 insertions(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 30df75b406..2c701d75e4 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -42,6 +42,14 @@
 
 -export([time_unit/0]).
 
+-export([bif_timer_server/2]).
+
+-export([get_bif_timer_servers/0, create_bif_timer/0, access_bif_timer/1]).
+
+-export([monitor_process/2]).
+
+-export([is_system_process/1]).
+
 %%
 %% Await result of send to port
 %%
@@ -208,3 +216,246 @@ flush_monitor_messages(Ref, Multi, Res) when is_reference(Ref) ->
 
 time_unit() ->
     erlang:nif_error(undefined).
+
+-spec erts_internal:get_bif_timer_servers() -> Pids when
+      Pid :: pid(),
+      Pids :: [Pid].
+
+get_bif_timer_servers() ->
+    erlang:nif_error(undefined).
+
+-spec erts_internal:create_bif_timer() -> Res when
+      Res :: {reference(), pid(), reference()}.
+
+create_bif_timer() ->
+    erlang:nif_error(undefined).
+
+-spec erts_internal:access_bif_timer(Ref) -> Res when
+      Ref :: reference(),
+      Res :: {reference(), pid(), reference()}.
+
+access_bif_timer(_Ref) ->
+    erlang:nif_error(undefined).
+
+-spec erts_internal:monitor_process(Pid, Ref) -> boolean() when
+      Pid :: pid(),
+      Ref :: reference().
+
+monitor_process(_Pid, _Ref) ->
+    erlang:nif_error(undefined).
+
+-spec erts_internal:is_system_process(Pid) -> boolean() when
+      Pid :: pid().
+
+is_system_process(_Pid) ->
+    erlang:nif_error(undefined).
+
+%%
+%% BIF timer servers
+%%
+
+-record(tsrv_state, {rtab,
+		     ttab,
+		     btr,
+		     unit,
+		     next}).
+
+bif_timer_server(N, BTR) ->
+    try
+	tsrv_loop(tsrv_init_static_state(N, BTR), infinity)
+    catch
+	Type:Reason ->
+	    erlang:display({'BIF_timer_server',
+			    {Type, Reason},
+			    erlang:get_stacktrace()}),
+	    exit(Reason)
+    end.
+
+tsrv_init_static_state(N, BTR) ->
+    process_flag(trap_exit, true),
+    NList = integer_to_list(N),
+    RTabName = list_to_atom("BIF_timer_reference_table_" ++ NList),
+    TTabName = list_to_atom("BIF_timer_time_table_" ++ NList),
+    #tsrv_state{rtab = ets:new(RTabName,
+			       [set, private, {keypos, 2}]),
+		ttab = ets:new(TTabName,
+			       [ordered_set, private, {keypos, 1}]),
+		btr = BTR,
+		unit = erts_internal:time_unit(),
+		next = infinity}.
+    
+
+tsrv_loop(#tsrv_state{unit = Unit} = StaticState, Nxt) ->
+    CallTime = erlang:monotonic_time(),
+    %% 'infinity' is greater than all integers...
+    NewNxt = case CallTime >= Nxt of
+		 true ->
+		     tsrv_handle_timeout(CallTime, StaticState);
+		 false ->
+		     TMO = try
+			       (1000*(Nxt - CallTime - 1)) div Unit + 1
+			   catch
+			       error:badarith when Nxt == infinity -> infinity
+			   end,
+		     receive
+			 Msg ->
+			     tsrv_handle_msg(Msg, StaticState, Nxt)
+		     after TMO ->
+			     Nxt
+		     end
+	     end,
+    tsrv_loop(StaticState, NewNxt).
+
+tsrv_handle_msg({set_timeout, BTR, Proc, Time, TRef, Msg},
+		#tsrv_state{rtab = RTab,
+			    ttab = TTab,
+			    btr = BTR},
+		Nxt) when erlang:is_integer(Time) ->
+    RcvTime = erlang:monotonic_time(),
+    case Time =< RcvTime of
+	true ->
+	    try Proc ! Msg catch _:_ -> ok end,
+	    Nxt;
+	false ->
+	    Ins = case erlang:is_atom(Proc) of
+		      true ->
+			  true;
+		      false ->
+			  try
+			      erts_internal:monitor_process(Proc, TRef)
+			  catch
+			      _:_ -> false
+			  end
+		  end,
+	    case Ins of
+		false ->
+		    Nxt;
+		true ->
+		    TKey = {Time, TRef},
+		    true = ets:insert(RTab, TKey),
+		    true = ets:insert(TTab, {TKey, Proc, Msg}),
+		    case Time < Nxt of
+			true -> Time;
+			false -> Nxt
+		    end
+	    end
+    end;
+tsrv_handle_msg({cancel_timeout, BTR, From, Reply, Req, TRef},
+		#tsrv_state{rtab = RTab,
+			    ttab = TTab,
+			    unit = Unit,
+			    btr = BTR},
+		Nxt) ->
+    case ets:lookup(RTab, TRef) of
+	[] ->
+	    case Reply of
+		false ->
+		    ok;
+		_ ->
+		    try From ! {cancel_timer, Req, false} catch _:_ -> ok end
+	    end,
+	    Nxt;
+	[{Time, TRef} = TKey] ->
+	    ets:delete(RTab, TRef),
+	    ets:delete(TTab, TKey),
+	    erlang:demonitor(TRef),
+	    case Reply of
+		false ->
+		    ok;
+		_ ->
+		    RcvTime = erlang:monotonic_time(),
+		    RT = case Time =< RcvTime of
+			     true ->
+				 0;
+			     false ->
+				 ((1000*(Time - RcvTime)) div Unit)
+			 end,
+		    try From ! {cancel_timer, Req, RT} catch _:_ -> ok end
+	    end,
+	    case Time =:= Nxt of
+		false ->
+		    Nxt;
+		true ->
+		    case ets:first(TTab) of
+			'$end_of_table' -> infinity;
+			{NextTime, _TRef} -> NextTime
+		    end
+	    end
+    end;
+tsrv_handle_msg({read_timeout, BTR, From, Req, TRef},
+		#tsrv_state{rtab = RTab,
+			    unit = Unit,
+			    btr = BTR},
+		Nxt) ->
+    case ets:lookup(RTab, TRef) of
+	[] ->
+	    try From ! {read_timer, Req, false} catch _:_ -> ok end;
+	[{Time, TRef}] ->
+	    RcvTime = erlang:monotonic_time(),
+	    RT = case Time =< RcvTime of
+		     true -> 0;
+		     false -> (1000*(Time - RcvTime)) div Unit
+		 end,
+	    try From ! {read_timer, Req, RT} catch _:_ -> ok end
+    end,
+    Nxt;
+tsrv_handle_msg({'DOWN', TRef, process, _, _},
+		#tsrv_state{rtab = RTab,
+			    ttab = TTab},
+		Nxt) ->
+    case ets:lookup(RTab, TRef) of
+	[] ->
+	    Nxt;
+	[{Time, TRef} = TKey] ->
+	    ets:delete(RTab, TRef),
+	    ets:delete(TTab, TKey),
+	    case Time =:= Nxt of
+		false ->
+		    Nxt;
+		true ->
+		    case ets:first(TTab) of
+			'$end_of_table' -> infinity;
+			{NextTime, _} -> NextTime
+		    end
+	    end
+    end;
+tsrv_handle_msg({cancel_all_timeouts, BTR, From, Ref},
+		#tsrv_state{rtab = RTab,
+			    ttab = TTab,
+			    btr = BTR},
+		_Nxt) ->
+    tsrv_delete_monitor_objects(RTab),
+    ets:delete_all_objects(TTab),
+    try From ! {canceled_all_timeouts, Ref} catch _:_ -> ok end,
+    infinity;
+tsrv_handle_msg(_GarbageMsg, _StaticState, Nxt) ->
+    Nxt.
+
+tsrv_delete_monitor_objects(RTab) ->
+    case ets:first(RTab) of
+	'$end_of_table' ->
+	    ok;
+	TRef ->
+	    erlang:demonitor(TRef),
+	    ets:delete(RTab, TRef),
+	    tsrv_delete_monitor_objects(RTab)
+    end.
+
+tsrv_handle_timeout(CallTime, #tsrv_state{rtab = RTab,
+					  ttab = TTab} = S) ->
+    case ets:first(TTab) of
+	'$end_of_table' ->
+	    infinity;
+	{Time, _TRef} when Time > CallTime ->
+	    Time;
+	{_Time, TRef} = TKey ->
+	    [{TKey, Proc, Msg}] = ets:lookup(TTab, TKey),
+	    case erlang:is_pid(Proc) of
+		false -> ok;
+		_ -> erlang:demonitor(TRef)
+	    end,
+	    ets:delete(TTab, TKey),
+	    ets:delete(RTab, TRef),
+	    try Proc ! Msg catch _:_ -> ok end,
+	    tsrv_handle_timeout(CallTime, S)
+    end.
-- 
cgit v1.2.3


From 2e016f6cde89bf471269c89f0fd2bb40422ce204 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Thu, 26 Mar 2015 12:07:00 +0100
Subject: Misc fixes

---
 erts/preloaded/src/erts_internal.erl | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 2c701d75e4..3580fb542d 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -232,7 +232,7 @@ create_bif_timer() ->
 
 -spec erts_internal:access_bif_timer(Ref) -> Res when
       Ref :: reference(),
-      Res :: {reference(), pid(), reference()}.
+      Res :: {reference(), pid()} | 'undefined'.
 
 access_bif_timer(_Ref) ->
     erlang:nif_error(undefined).
@@ -352,7 +352,7 @@ tsrv_handle_msg({cancel_timeout, BTR, From, Reply, Req, TRef},
 		false ->
 		    ok;
 		_ ->
-		    try From ! {cancel_timer, Req, false} catch _:_ -> ok end
+		    _ = try From ! {cancel_timer, Req, false} catch _:_ -> ok end
 	    end,
 	    Nxt;
 	[{Time, TRef} = TKey] ->
@@ -370,7 +370,7 @@ tsrv_handle_msg({cancel_timeout, BTR, From, Reply, Req, TRef},
 			     false ->
 				 ((1000*(Time - RcvTime)) div Unit)
 			 end,
-		    try From ! {cancel_timer, Req, RT} catch _:_ -> ok end
+		    _ = try From ! {cancel_timer, Req, RT} catch _:_ -> ok end
 	    end,
 	    case Time =:= Nxt of
 		false ->
@@ -389,14 +389,14 @@ tsrv_handle_msg({read_timeout, BTR, From, Req, TRef},
 		Nxt) ->
     case ets:lookup(RTab, TRef) of
 	[] ->
-	    try From ! {read_timer, Req, false} catch _:_ -> ok end;
+	    _ = try From ! {read_timer, Req, false} catch _:_ -> ok end;
 	[{Time, TRef}] ->
 	    RcvTime = erlang:monotonic_time(),
 	    RT = case Time =< RcvTime of
 		     true -> 0;
 		     false -> (1000*(Time - RcvTime)) div Unit
 		 end,
-	    try From ! {read_timer, Req, RT} catch _:_ -> ok end
+	    _ = try From ! {read_timer, Req, RT} catch _:_ -> ok end
     end,
     Nxt;
 tsrv_handle_msg({'DOWN', TRef, process, _, _},
@@ -456,6 +456,6 @@ tsrv_handle_timeout(CallTime, #tsrv_state{rtab = RTab,
 	    end,
 	    ets:delete(TTab, TKey),
 	    ets:delete(RTab, TRef),
-	    try Proc ! Msg catch _:_ -> ok end,
+	    _ = try Proc ! Msg catch _:_ -> ok end,
 	    tsrv_handle_timeout(CallTime, S)
     end.
-- 
cgit v1.2.3


From 9c78f149517dc02457d4c59e90bc9b03d411e28c Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Tue, 5 May 2015 20:05:00 +0200
Subject: Optimized timer implementation

---
 erts/preloaded/src/erts_internal.erl | 255 ++---------------------------------
 1 file changed, 12 insertions(+), 243 deletions(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index e489001532..65a1f1ed3a 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -40,13 +40,9 @@
 
 -export([flush_monitor_messages/3]).
 
--export([time_unit/0]).
-
--export([bif_timer_server/2]).
-
--export([get_bif_timer_servers/0, create_bif_timer/0, access_bif_timer/1]).
+-export([await_result/1]).
 
--export([monitor_process/2]).
+-export([time_unit/0]).
 
 -export([is_system_process/1]).
 
@@ -60,6 +56,16 @@ await_port_send_result(Ref, Busy, Ok) ->
 	{Ref, _} -> Ok
     end.
 
+%%
+%% Await result...
+%%
+
+await_result(Ref) when is_reference(Ref) ->
+    receive
+	{Ref, Result} ->
+	    Result
+    end.
+
 %%
 %% Statically linked port NIFs
 %%
@@ -234,245 +240,8 @@ flush_monitor_messages(Ref, Multi, Res) when is_reference(Ref) ->
 time_unit() ->
     erlang:nif_error(undefined).
 
--spec erts_internal:get_bif_timer_servers() -> Pids when
-      Pid :: pid(),
-      Pids :: [Pid].
-
-get_bif_timer_servers() ->
-    erlang:nif_error(undefined).
-
--spec erts_internal:create_bif_timer() -> Res when
-      Res :: {reference(), pid(), reference()}.
-
-create_bif_timer() ->
-    erlang:nif_error(undefined).
-
--spec erts_internal:access_bif_timer(Ref) -> Res when
-      Ref :: reference(),
-      Res :: {reference(), pid()} | 'undefined'.
-
-access_bif_timer(_Ref) ->
-    erlang:nif_error(undefined).
-
--spec erts_internal:monitor_process(Pid, Ref) -> boolean() when
-      Pid :: pid(),
-      Ref :: reference().
-
-monitor_process(_Pid, _Ref) ->
-    erlang:nif_error(undefined).
-
 -spec erts_internal:is_system_process(Pid) -> boolean() when
       Pid :: pid().
 
 is_system_process(_Pid) ->
     erlang:nif_error(undefined).
-
-%%
-%% BIF timer servers
-%%
-
--record(tsrv_state, {rtab,
-		     ttab,
-		     btr,
-		     unit,
-		     next}).
-
-bif_timer_server(N, BTR) ->
-    try
-	tsrv_loop(tsrv_init_static_state(N, BTR), infinity)
-    catch
-	Type:Reason ->
-	    erlang:display({'BIF_timer_server',
-			    {Type, Reason},
-			    erlang:get_stacktrace()}),
-	    exit(Reason)
-    end.
-
-tsrv_init_static_state(N, BTR) ->
-    process_flag(trap_exit, true),
-    NList = integer_to_list(N),
-    RTabName = list_to_atom("BIF_timer_reference_table_" ++ NList),
-    TTabName = list_to_atom("BIF_timer_time_table_" ++ NList),
-    #tsrv_state{rtab = ets:new(RTabName,
-			       [set, private, {keypos, 2}]),
-		ttab = ets:new(TTabName,
-			       [ordered_set, private, {keypos, 1}]),
-		btr = BTR,
-		unit = erts_internal:time_unit(),
-		next = infinity}.
-    
-
-tsrv_loop(#tsrv_state{unit = Unit} = StaticState, Nxt) ->
-    CallTime = erlang:monotonic_time(),
-    %% 'infinity' is greater than all integers...
-    NewNxt = case CallTime >= Nxt of
-		 true ->
-		     tsrv_handle_timeout(CallTime, StaticState);
-		 false ->
-		     TMO = try
-			       (1000*(Nxt - CallTime - 1)) div Unit + 1
-			   catch
-			       error:badarith when Nxt == infinity -> infinity
-			   end,
-		     receive
-			 Msg ->
-			     tsrv_handle_msg(Msg, StaticState, Nxt)
-		     after TMO ->
-			     Nxt
-		     end
-	     end,
-    tsrv_loop(StaticState, NewNxt).
-
-tsrv_handle_msg({set_timeout, BTR, Proc, Time, TRef, Msg},
-		#tsrv_state{rtab = RTab,
-			    ttab = TTab,
-			    btr = BTR},
-		Nxt) when erlang:is_integer(Time) ->
-    RcvTime = erlang:monotonic_time(),
-    case Time =< RcvTime of
-	true ->
-	    try Proc ! Msg catch _:_ -> ok end,
-	    Nxt;
-	false ->
-	    Ins = case erlang:is_atom(Proc) of
-		      true ->
-			  true;
-		      false ->
-			  try
-			      erts_internal:monitor_process(Proc, TRef)
-			  catch
-			      _:_ -> false
-			  end
-		  end,
-	    case Ins of
-		false ->
-		    Nxt;
-		true ->
-		    TKey = {Time, TRef},
-		    true = ets:insert(RTab, TKey),
-		    true = ets:insert(TTab, {TKey, Proc, Msg}),
-		    case Time < Nxt of
-			true -> Time;
-			false -> Nxt
-		    end
-	    end
-    end;
-tsrv_handle_msg({cancel_timeout, BTR, From, Reply, Req, TRef},
-		#tsrv_state{rtab = RTab,
-			    ttab = TTab,
-			    unit = Unit,
-			    btr = BTR},
-		Nxt) ->
-    case ets:lookup(RTab, TRef) of
-	[] ->
-	    case Reply of
-		false ->
-		    ok;
-		_ ->
-		    _ = try From ! {cancel_timer, Req, false} catch _:_ -> ok end
-	    end,
-	    Nxt;
-	[{Time, TRef} = TKey] ->
-	    ets:delete(RTab, TRef),
-	    ets:delete(TTab, TKey),
-	    erlang:demonitor(TRef),
-	    case Reply of
-		false ->
-		    ok;
-		_ ->
-		    RcvTime = erlang:monotonic_time(),
-		    RT = case Time =< RcvTime of
-			     true ->
-				 0;
-			     false ->
-				 ((1000*(Time - RcvTime)) div Unit)
-			 end,
-		    _ = try From ! {cancel_timer, Req, RT} catch _:_ -> ok end
-	    end,
-	    case Time =:= Nxt of
-		false ->
-		    Nxt;
-		true ->
-		    case ets:first(TTab) of
-			'$end_of_table' -> infinity;
-			{NextTime, _TRef} -> NextTime
-		    end
-	    end
-    end;
-tsrv_handle_msg({read_timeout, BTR, From, Req, TRef},
-		#tsrv_state{rtab = RTab,
-			    unit = Unit,
-			    btr = BTR},
-		Nxt) ->
-    case ets:lookup(RTab, TRef) of
-	[] ->
-	    _ = try From ! {read_timer, Req, false} catch _:_ -> ok end;
-	[{Time, TRef}] ->
-	    RcvTime = erlang:monotonic_time(),
-	    RT = case Time =< RcvTime of
-		     true -> 0;
-		     false -> (1000*(Time - RcvTime)) div Unit
-		 end,
-	    _ = try From ! {read_timer, Req, RT} catch _:_ -> ok end
-    end,
-    Nxt;
-tsrv_handle_msg({'DOWN', TRef, process, _, _},
-		#tsrv_state{rtab = RTab,
-			    ttab = TTab},
-		Nxt) ->
-    case ets:lookup(RTab, TRef) of
-	[] ->
-	    Nxt;
-	[{Time, TRef} = TKey] ->
-	    ets:delete(RTab, TRef),
-	    ets:delete(TTab, TKey),
-	    case Time =:= Nxt of
-		false ->
-		    Nxt;
-		true ->
-		    case ets:first(TTab) of
-			'$end_of_table' -> infinity;
-			{NextTime, _} -> NextTime
-		    end
-	    end
-    end;
-tsrv_handle_msg({cancel_all_timeouts, BTR, From, Ref},
-		#tsrv_state{rtab = RTab,
-			    ttab = TTab,
-			    btr = BTR},
-		_Nxt) ->
-    tsrv_delete_monitor_objects(RTab),
-    ets:delete_all_objects(TTab),
-    try From ! {canceled_all_timeouts, Ref} catch _:_ -> ok end,
-    infinity;
-tsrv_handle_msg(_GarbageMsg, _StaticState, Nxt) ->
-    Nxt.
-
-tsrv_delete_monitor_objects(RTab) ->
-    case ets:first(RTab) of
-	'$end_of_table' ->
-	    ok;
-	TRef ->
-	    erlang:demonitor(TRef),
-	    ets:delete(RTab, TRef),
-	    tsrv_delete_monitor_objects(RTab)
-    end.
-
-tsrv_handle_timeout(CallTime, #tsrv_state{rtab = RTab,
-					  ttab = TTab} = S) ->
-    case ets:first(TTab) of
-	'$end_of_table' ->
-	    infinity;
-	{Time, _TRef} when Time > CallTime ->
-	    Time;
-	{_Time, TRef} = TKey ->
-	    [{TKey, Proc, Msg}] = ets:lookup(TTab, TKey),
-	    case erlang:is_pid(Proc) of
-		false -> ok;
-		_ -> erlang:demonitor(TRef)
-	    end,
-	    ets:delete(TTab, TKey),
-	    ets:delete(RTab, TRef),
-	    _ = try Proc ! Msg catch _:_ -> ok end,
-	    tsrv_handle_timeout(CallTime, S)
-    end.
-- 
cgit v1.2.3


From 74f0d7c8ea47b363136c86de5d7ea78a48c40570 Mon Sep 17 00:00:00 2001
From: Rickard Green <rickard@erlang.org>
Date: Wed, 17 Jun 2015 00:01:14 +0200
Subject: Save IO bytes in scheduler specific data

---
 erts/preloaded/src/erts_internal.erl | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 65a1f1ed3a..cf8edefd7d 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -40,7 +40,7 @@
 
 -export([flush_monitor_messages/3]).
 
--export([await_result/1]).
+-export([await_result/1, gather_io_bytes/2]).
 
 -export([time_unit/0]).
 
@@ -66,6 +66,23 @@ await_result(Ref) when is_reference(Ref) ->
 	    Result
     end.
 
+%%
+%% statistics(io) end up in gather_io_bytes/2
+%%
+
+gather_io_bytes(Ref, No) when is_reference(Ref),
+			      is_integer(No),
+			      No > 0 ->
+    gather_io_bytes(Ref, No, 0, 0).
+
+gather_io_bytes(_Ref, 0, InAcc, OutAcc) ->
+    {{input, InAcc}, {output, OutAcc}};
+gather_io_bytes(Ref, No, InAcc, OutAcc) ->
+    receive
+	{Ref, _SchedId, In, Out} ->
+	    gather_io_bytes(Ref, No-1, InAcc + In, OutAcc + Out)
+    end.
+
 %%
 %% Statically linked port NIFs
 %%
-- 
cgit v1.2.3


From 738c34d4bb8f1a3811acd00af8c6c12107f8315b Mon Sep 17 00:00:00 2001
From: Bruce Yinhe <bruce@erlang.org>
Date: Thu, 18 Jun 2015 11:31:02 +0200
Subject: Change license text to APLv2

---
 erts/preloaded/src/erts_internal.erl | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index cf8edefd7d..7ed4efea4b 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -3,16 +3,17 @@
 %%
 %% Copyright Ericsson AB 2012-2013. All Rights Reserved.
 %%
-%% The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with this software. If not, it can be
-%% retrieved online at http://www.erlang.org/.
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
 %%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
 %%
 %% %CopyrightEnd%
 %%
-- 
cgit v1.2.3


From 2ae91c3ade0538500ff4dbda29ad539e595f64df Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Thu, 15 Oct 2015 20:10:46 +0200
Subject: erts: Change erts_internal:map_type/1 into term_type/1

to support other terms, not just maps
---
 erts/preloaded/src/erts_internal.erl | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 7ed4efea4b..023af1579f 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -31,7 +31,7 @@
 
 -export([await_port_send_result/3]).
 -export([cmp_term/2]).
--export([map_to_tuple_keys/1, map_type/1, map_hashmap_children/1]).
+-export([map_to_tuple_keys/1, term_type/1, map_hashmap_children/1]).
 -export([port_command/3, port_connect/2, port_close/1,
 	 port_control/3, port_call/3, port_info/1, port_info/2]).
 
@@ -215,12 +215,12 @@ cmp_term(_A,_B) ->
 map_to_tuple_keys(_M) ->
     erlang:nif_error(undefined).
 
-%% return the internal map type
--spec map_type(M) -> Type when
-    M :: map(),
-    Type :: 'flatmap' | 'hashmap' | 'hashmap_node'.
+%% return the internal term type
+-spec term_type(M) -> Type when
+    M :: term(),
+    Type :: 'flatmap' | 'hashmap' | 'hashmap_node' | 'small' | 'big' | 'ifloat' | 'hfloat'.
 
-map_type(_M) ->
+term_type(_M) ->
     erlang:nif_error(undefined).
 
 %% return the internal hashmap sub-nodes from
-- 
cgit v1.2.3


From f6eacb9981b40604a031c9d61967b0c3a3588bdb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Fri, 13 Nov 2015 17:41:36 +0100
Subject: erts: Let term_type/1 encompass all types

---
 erts/preloaded/src/erts_internal.erl | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 023af1579f..ce0a6a1d9e 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -216,11 +216,17 @@ map_to_tuple_keys(_M) ->
     erlang:nif_error(undefined).
 
 %% return the internal term type
--spec term_type(M) -> Type when
-    M :: term(),
-    Type :: 'flatmap' | 'hashmap' | 'hashmap_node' | 'small' | 'big' | 'ifloat' | 'hfloat'.
-
-term_type(_M) ->
+-spec term_type(T) -> Type when
+    T :: term(),
+    Type :: 'flatmap' | 'hashmap' | 'hashmap_node'
+          | 'fixnum'  | 'bignum'  | 'hfloat'
+          | 'list' | 'tuple' | 'export' | 'fun'
+          | 'refc_binary' | 'heap_binary' | 'sub_binary'
+          | 'reference'   | 'external_reference'
+          | 'pid' | 'external_pid' | 'port' | 'external_port'
+          | 'atom' | 'catch' | 'nil'.
+
+term_type(_T) ->
     erlang:nif_error(undefined).
 
 %% return the internal hashmap sub-nodes from
-- 
cgit v1.2.3


From 4b98e710b9c45481c1cdc7a4ee68f7ce7fca908a Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas.larsson@erlang-solutions.com>
Date: Mon, 13 Jul 2015 15:38:41 +0200
Subject: erts: Add support for asynchronous open_port

OTP-13086
---
 erts/preloaded/src/erts_internal.erl | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 7ed4efea4b..81202ed3e2 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -32,7 +32,7 @@
 -export([await_port_send_result/3]).
 -export([cmp_term/2]).
 -export([map_to_tuple_keys/1, map_type/1, map_hashmap_children/1]).
--export([port_command/3, port_connect/2, port_close/1,
+-export([open_port/2, port_command/3, port_connect/2, port_close/1,
 	 port_control/3, port_call/3, port_info/1, port_info/2]).
 
 -export([request_system_task/3]).
@@ -88,6 +88,13 @@ gather_io_bytes(Ref, No, InAcc, OutAcc) ->
 %% Statically linked port NIFs
 %%
 
+-spec erts_internal:open_port(PortName, PortSettings) -> Result when
+      PortName :: tuple(),
+      PortSettings :: term(),
+      Result :: port() | reference() | atom().
+open_port(_PortName, _PortSettings) ->
+    erlang:nif_error(undefined).
+
 -spec erts_internal:port_command(Port, Data, OptionList) -> Result when
       Port :: port() | atom(),
       Data :: iodata(),
-- 
cgit v1.2.3


From fa44f865c3fc6253cf4691cf94839c303a3ee40f Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Tue, 15 Dec 2015 20:32:39 +0100
Subject: erts: Make erlang:purge_module/1 safe

Problem: erlang:purge_module/1 is not safe in the sense
that very bad things may happen if the code to be purged
is still referred to by live processes.

Introduce erts_internal:purge_module which is the same as the old
erlang:purge_module BIF (except it returns false if no such old module).

Implement erlang:purge_module in Erlang and let it invoke
erts_code_purger for safe purging where all clogging processes
first are killed.
---
 erts/preloaded/src/erts_internal.erl | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 426749264f..6e649e8395 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -38,6 +38,7 @@
 -export([request_system_task/3]).
 
 -export([check_process_code/2]).
+-export([purge_module/1]).
 
 -export([flush_monitor_messages/3]).
 
@@ -204,6 +205,11 @@ request_system_task(_Pid, _Prio, _Request) ->
 check_process_code(_Module, _OptionList) ->
     erlang:nif_error(undefined).
 
+-spec purge_module(Module) -> boolean() when
+      Module :: module().
+purge_module(_Module) ->
+    erlang:nif_error(undefined).
+
 %% term compare where integer() < float() = true
 
 -spec cmp_term(A,B) -> Result when
-- 
cgit v1.2.3


From dc54c2a27c41930a18e0c7f2b97eda6cd4a0b1c1 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Wed, 16 Dec 2015 19:11:48 +0100
Subject: erts: Move copy_literals/2 from erlang to erts_internal

as it's not a public interface.
---
 erts/preloaded/src/erts_internal.erl | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 6e649e8395..30e9ba304c 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -38,6 +38,7 @@
 -export([request_system_task/3]).
 
 -export([check_process_code/2]).
+-export([copy_literals/2]).
 -export([purge_module/1]).
 
 -export([flush_monitor_messages/3]).
@@ -205,6 +206,12 @@ request_system_task(_Pid, _Prio, _Request) ->
 check_process_code(_Module, _OptionList) ->
     erlang:nif_error(undefined).
 
+-spec copy_literals(Module,Bool) -> 'true' | 'false' | 'aborted' when
+      Module :: module(),
+      Bool :: boolean().
+copy_literals(_Mod, _Bool) ->
+    erlang:nif_error(undefined).
+
 -spec purge_module(Module) -> boolean() when
       Module :: module().
 purge_module(_Module) ->
-- 
cgit v1.2.3


From a4920dc4045f394f6f4ab1cc89d54d55722a66d6 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Tue, 12 Jan 2016 17:02:06 +0100
Subject: erts: Refactor check_process_code/3

Move impl from erlang to erts_internal. Cut and paste.
---
 erts/preloaded/src/erts_internal.erl | 55 +++++++++++++++++++++++++++++++++++-
 1 file changed, 54 insertions(+), 1 deletion(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 30e9ba304c..e32d65ff59 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -37,7 +37,7 @@
 
 -export([request_system_task/3]).
 
--export([check_process_code/2]).
+-export([check_process_code/3]).
 -export([copy_literals/2]).
 -export([purge_module/1]).
 
@@ -49,6 +49,9 @@
 
 -export([is_system_process/1]).
 
+%% Auto import name clash
+-export([check_process_code/2]).
+
 %%
 %% Await result of send to port
 %%
@@ -206,6 +209,56 @@ request_system_task(_Pid, _Prio, _Request) ->
 check_process_code(_Module, _OptionList) ->
     erlang:nif_error(undefined).
 
+-spec check_process_code(Pid, Module, OptionList) -> CheckResult | async when
+      Pid :: pid(),
+      Module :: module(),
+      RequestId :: term(),
+      Option :: {async, RequestId} | {allow_gc, boolean()},
+      OptionList :: [Option],
+      CheckResult :: boolean() | aborted.
+check_process_code(Pid, Module, OptionList)  ->
+    {Async, AllowGC} = get_cpc_opts(OptionList, sync, true),
+    case Async of
+	{async, ReqId} ->
+	    {priority, Prio} = erlang:process_info(erlang:self(),
+						   priority),
+	    erts_internal:request_system_task(Pid,
+					      Prio,
+					      {check_process_code,
+					       ReqId,
+					       Module,
+					       AllowGC}),
+	    async;
+	sync ->
+	    case Pid == erlang:self() of
+		true ->
+		    erts_internal:check_process_code(Module,
+						     [{allow_gc, AllowGC}]);
+		false ->
+		    {priority, Prio} = erlang:process_info(erlang:self(),
+							   priority),
+		    ReqId = erlang:make_ref(),
+		    erts_internal:request_system_task(Pid,
+						      Prio,
+						      {check_process_code,
+						       ReqId,
+						       Module,
+						       AllowGC}),
+		    receive
+			{check_process_code, ReqId, CheckResult} ->
+			    CheckResult
+		    end
+	    end
+    end.
+
+% gets async and allow_gc opts and verify valid option list
+get_cpc_opts([{async, _ReqId} = AsyncTuple | Options], _OldAsync, AllowGC) ->
+    get_cpc_opts(Options, AsyncTuple, AllowGC);
+get_cpc_opts([{allow_gc, AllowGC} | Options], Async, _OldAllowGC) ->
+    get_cpc_opts(Options, Async, AllowGC);
+get_cpc_opts([], Async, AllowGC) ->
+    {Async, AllowGC}.
+
 -spec copy_literals(Module,Bool) -> 'true' | 'false' | 'aborted' when
       Module :: module(),
       Bool :: boolean().
-- 
cgit v1.2.3


From 4c763443365591e170308a1c5f11a4586734ca4e Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Tue, 12 Jan 2016 16:57:59 +0100
Subject: erts: Optimize erlang:check_process_code

by ignoring literals.

erts_internal:check_process_code will be called again anyway
(with option {copy_literals, true}) before the module is actually purged.
No need to check literals twice.
---
 erts/preloaded/src/erts_internal.erl | 42 +++++++++++++++++++++---------------
 1 file changed, 25 insertions(+), 17 deletions(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index e32d65ff59..84dedab930 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -202,22 +202,24 @@ port_info(_Result, _Item) ->
 request_system_task(_Pid, _Prio, _Request) ->
     erlang:nif_error(undefined).
 
--spec check_process_code(Module, OptionList) -> boolean() when
+-define(ERTS_CPC_ALLOW_GC, (1 bsl 0)).
+-define(ERTS_CPC_COPY_LITERALS, (1 bsl 1)).
+
+-spec check_process_code(Module, Flags) -> boolean() when
       Module :: module(),
-      Option :: {allow_gc, boolean()},
-      OptionList :: [Option].
-check_process_code(_Module, _OptionList) ->
+      Flags :: non_neg_integer().
+check_process_code(_Module, _Flags) ->
     erlang:nif_error(undefined).
 
 -spec check_process_code(Pid, Module, OptionList) -> CheckResult | async when
       Pid :: pid(),
       Module :: module(),
       RequestId :: term(),
-      Option :: {async, RequestId} | {allow_gc, boolean()},
+      Option :: {async, RequestId} | {allow_gc, boolean()} | {copy_literals, boolean()},
       OptionList :: [Option],
       CheckResult :: boolean() | aborted.
 check_process_code(Pid, Module, OptionList)  ->
-    {Async, AllowGC} = get_cpc_opts(OptionList, sync, true),
+    {Async, Flags} = get_cpc_opts(OptionList, sync, ?ERTS_CPC_ALLOW_GC),
     case Async of
 	{async, ReqId} ->
 	    {priority, Prio} = erlang:process_info(erlang:self(),
@@ -227,13 +229,12 @@ check_process_code(Pid, Module, OptionList)  ->
 					      {check_process_code,
 					       ReqId,
 					       Module,
-					       AllowGC}),
+					       Flags}),
 	    async;
 	sync ->
 	    case Pid == erlang:self() of
 		true ->
-		    erts_internal:check_process_code(Module,
-						     [{allow_gc, AllowGC}]);
+		    erts_internal:check_process_code(Module, Flags);
 		false ->
 		    {priority, Prio} = erlang:process_info(erlang:self(),
 							   priority),
@@ -243,7 +244,7 @@ check_process_code(Pid, Module, OptionList)  ->
 						      {check_process_code,
 						       ReqId,
 						       Module,
-						       AllowGC}),
+						       Flags}),
 		    receive
 			{check_process_code, ReqId, CheckResult} ->
 			    CheckResult
@@ -251,13 +252,20 @@ check_process_code(Pid, Module, OptionList)  ->
 	    end
     end.
 
-% gets async and allow_gc opts and verify valid option list
-get_cpc_opts([{async, _ReqId} = AsyncTuple | Options], _OldAsync, AllowGC) ->
-    get_cpc_opts(Options, AsyncTuple, AllowGC);
-get_cpc_opts([{allow_gc, AllowGC} | Options], Async, _OldAllowGC) ->
-    get_cpc_opts(Options, Async, AllowGC);
-get_cpc_opts([], Async, AllowGC) ->
-    {Async, AllowGC}.
+% gets async and flag opts and verify valid option list
+get_cpc_opts([{async, _ReqId} = AsyncTuple | Options], _OldAsync, Flags) ->
+    get_cpc_opts(Options, AsyncTuple, Flags);
+get_cpc_opts([{allow_gc, AllowGC} | Options], Async, Flags) ->
+    get_cpc_opts(Options, Async, cpc_flags(Flags, ?ERTS_CPC_ALLOW_GC, AllowGC));
+get_cpc_opts([{copy_literals, CopyLit} | Options], Async, Flags) ->
+    get_cpc_opts(Options, Async, cpc_flags(Flags, ?ERTS_CPC_COPY_LITERALS, CopyLit));
+get_cpc_opts([], Async, Flags) ->
+    {Async, Flags}.
+
+cpc_flags(OldFlags, Bit, true) ->
+    OldFlags bor Bit;
+cpc_flags(OldFlags, Bit, false) ->
+    OldFlags band (bnot Bit).
 
 -spec copy_literals(Module,Bool) -> 'true' | 'false' | 'aborted' when
       Module :: module(),
-- 
cgit v1.2.3


From 70e92b321feb10b5976c9a9f571a273155ebcf79 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Mon, 25 Jan 2016 15:45:13 +0100
Subject: erts: Fix harmless dialyzer warnings

---
 erts/preloaded/src/erts_internal.erl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 84dedab930..2b15abe0fb 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -49,7 +49,7 @@
 
 -export([is_system_process/1]).
 
-%% Auto import name clash
+%% Auto-import name clash
 -export([check_process_code/2]).
 
 %%
@@ -196,7 +196,7 @@ port_info(_Result, _Item) ->
 -spec request_system_task(Pid, Prio, Request) -> 'ok' when
       Prio :: 'max' | 'high' | 'normal' | 'low',
       Request :: {'garbage_collect', term()}
-	       | {'check_process_code', term(), module(), boolean()},
+	       | {'check_process_code', term(), module(), non_neg_integer()},
       Pid :: pid().
 
 request_system_task(_Pid, _Prio, _Request) ->
-- 
cgit v1.2.3


From eea5f896780e07f7ca76685061d01e7be5a7abaa Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Thu, 11 Sep 2014 18:26:26 +0200
Subject: erts, kernel: Add os:perf_counter function

The perf_counter is a very very cheap and high resolution timer
that can be used to timestamp system events. It does not have
monoticity guarantees, but should on most OS's expose a monotonous
time.

A special instruction has been created for this counter to further
speed up fetching it.

OTP-12908
---
 erts/preloaded/src/erts_internal.erl | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 84dedab930..c3a14d272d 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -45,7 +45,7 @@
 
 -export([await_result/1, gather_io_bytes/2]).
 
--export([time_unit/0]).
+-export([time_unit/0, perf_counter_unit/0]).
 
 -export([is_system_process/1]).
 
@@ -345,6 +345,11 @@ flush_monitor_messages(Ref, Multi, Res) when is_reference(Ref) ->
 time_unit() ->
     erlang:nif_error(undefined).
 
+-spec erts_internal:perf_counter_unit() -> pos_integer().
+
+perf_counter_unit() ->
+    erlang:nif_error(undefined).
+
 -spec erts_internal:is_system_process(Pid) -> boolean() when
       Pid :: pid().
 
-- 
cgit v1.2.3


From 664ed2a6fd2b324bb6b56db3d3eca853cfda8f61 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Fri, 12 Sep 2014 16:38:00 +0200
Subject: erts: Add microstate accounting

Microstate accounting is a way to track which state the
different threads within ERTS are in. The main usage area
is to pin point performance bottlenecks by checking which
states the threads are in and then from there figuring out
why and where to optimize.

Since checking whether microstate accounting is on or off is
relatively expensive if done in a short loop only a few of the
states are enabled by default and more states can be enabled
through configure.

I've done some benchmarking and the overhead with it turned off
is not noticible and with it on it is a fraction of a percent.
If you enable the extra states, depending on the benchmark,
the ovehead when turned off is about 1% and when turned on
somewhere inbetween 5-15%.

OTP-12345
---
 erts/preloaded/src/erts_internal.erl | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index c3a14d272d..a15355bb10 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -49,6 +49,9 @@
 
 -export([is_system_process/1]).
 
+-export([await_microstate_accounting_modifications/3,
+	 gather_microstate_accounting_result/2]).
+
 %% Auto import name clash
 -export([check_process_code/2]).
 
@@ -355,3 +358,28 @@ perf_counter_unit() ->
 
 is_system_process(_Pid) ->
     erlang:nif_error(undefined).
+
+-spec await_microstate_accounting_modifications(Ref, Result, Threads) -> boolean() when
+      Ref :: reference(),
+      Result :: boolean(),
+      Threads :: pos_integer().
+
+await_microstate_accounting_modifications(Ref, Result, Threads) ->
+    _ = microstate_accounting(Ref,Threads),
+    Result.
+
+-spec gather_microstate_accounting_result(Ref, Threads) -> [#{}] when
+      Ref :: reference(),
+      Threads :: pos_integer().
+
+gather_microstate_accounting_result(Ref, Threads) ->
+    microstate_accounting(Ref, Threads).
+
+microstate_accounting(_Ref, 0) ->
+    [];
+microstate_accounting(Ref, Threads) ->
+    receive
+        Ref -> microstate_accounting(Ref, Threads - 1);
+        {Ref, Res} ->
+	    [Res | microstate_accounting(Ref, Threads - 1)]
+    end.
-- 
cgit v1.2.3


From 4ea67ffdac2629255b1b0ed4e9423823f62c0947 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 15 Feb 2016 18:12:48 +0100
Subject: erts: Add BIF erts_internal:system_check/1

This commit implements erts_internal:system_check(schedulers) with the
intent of a basic responsiveness test check of the schedulers.
---
 erts/preloaded/src/erts_internal.erl | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 7ed4efea4b..6db77a8482 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -35,6 +35,9 @@
 -export([port_command/3, port_connect/2, port_close/1,
 	 port_control/3, port_call/3, port_info/1, port_info/2]).
 
+-export([system_check/1,
+         gather_system_check_result/1]).
+
 -export([request_system_task/3]).
 
 -export([check_process_code/2]).
@@ -197,6 +200,23 @@ request_system_task(_Pid, _Prio, _Request) ->
 check_process_code(_Module, _OptionList) ->
     erlang:nif_error(undefined).
 
+-spec system_check(Type) -> 'ok' when
+      Type :: 'schedulers'.
+
+system_check(_Type) ->
+    erlang:nif_error(undefined).
+
+gather_system_check_result(Ref) when is_reference(Ref) ->
+    gather_system_check_result(Ref, erlang:system_info(schedulers)).
+
+gather_system_check_result(_Ref, 0) ->
+    ok;
+gather_system_check_result(Ref, N) ->
+    receive
+        Ref ->
+            gather_system_check_result(Ref, N - 1)
+    end.
+
 %% term compare where integer() < float() = true
 
 -spec cmp_term(A,B) -> Result when
-- 
cgit v1.2.3


From 6664eed554974336909d3ffe03f20349cc4c38fd Mon Sep 17 00:00:00 2001
From: Henrik Nord <henrik@erlang.org>
Date: Tue, 15 Mar 2016 15:19:56 +0100
Subject: update copyright-year

---
 erts/preloaded/src/erts_internal.erl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 330fcc4a9c..769757ba75 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2012-2013. All Rights Reserved.
+%% Copyright Ericsson AB 2012-2016. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
-- 
cgit v1.2.3


From 37092dab15448ef6a078800e3ff0cc41880ea765 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas.larsson@erlang-solutions.com>
Date: Thu, 10 Dec 2015 11:10:46 +0100
Subject: erts: Implement tracer modules

Add the possibility to use modules as trace data receivers. The functions
in the module have to be nifs as otherwise complex trace probes will be
very hard to handle (complex means trace probes for ports for example).

This commit changes the way that the ptab->tracer field works from always
being an immediate, to now be NIL if no tracer is present or else be
the tuple {TracerModule, TracerState} where TracerModule is an atom that
is later used to lookup the appropriate tracer callbacks to call and
TracerState is just passed to the tracer callback. The default process and
port tracers have been rewritten to use the new API.

This commit also changes the order which trace messages are delivered to the
potential tracer process. Any enif_send done in a tracer module may be delayed
indefinitely because of lock order issues. If a message is delayed any other
trace message send from that process is also delayed so that order is preserved
for each traced entity. This means that for some trace events (i.e. send/receive)
the events may come in an unintuitive order (receive before send) to the
trace receiver. Timestamps are taken when the trace message is generated so
trace messages from differented processes may arrive with the timestamp
out of order.

Both the erlang:trace and seq_trace:set_system_tracer accept the new tracer
module tracers and also the backwards compatible arguments.

OTP-10267
---
 erts/preloaded/src/erts_internal.erl | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

(limited to 'erts/preloaded/src/erts_internal.erl')

diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 769757ba75..2459ea2a2c 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -55,7 +55,9 @@
 -export([await_microstate_accounting_modifications/3,
 	 gather_microstate_accounting_result/2]).
 
-%% Auto-import name clash
+-export([trace/3, trace_pattern/3]).
+
+%% Auto import name clash
 -export([check_process_code/2]).
 
 %%
@@ -403,3 +405,28 @@ microstate_accounting(Ref, Threads) ->
         {Ref, Res} ->
 	    [Res | microstate_accounting(Ref, Threads - 1)]
     end.
+
+-spec trace(PidPortSpec, How, FlagList) -> integer() when
+      PidPortSpec :: pid() | port()
+                   | all | processes | ports
+                   | existing | existing_processes | existing_ports
+                   | new | new_processes | new_ports,
+      How :: boolean(),
+      FlagList :: [].
+trace(_PidSpec, _How, _FlagList) ->
+    erlang:nif_error(undefined).
+
+-type trace_pattern_mfa() ::
+      {atom(),atom(),arity() | '_'} | on_load.
+-type trace_match_spec() ::
+      [{[term()] | '_' ,[term()],[term()]}].
+
+-spec trace_pattern(MFA, MatchSpec, FlagList) -> non_neg_integer() when
+      MFA :: trace_pattern_mfa(),
+      MatchSpec :: (MatchSpecList :: trace_match_spec())
+                 | boolean()
+                 | restart
+                 | pause,
+      FlagList :: [ ].
+trace_pattern(_MFA, _MatchSpec, _FlagList) ->
+    erlang:nif_error(undefined).
-- 
cgit v1.2.3