1 files changed, 152 insertions, 0 deletions
diff --git a/lib/runtime_tools/src/scheduler.erl b/lib/runtime_tools/src/scheduler.erl
new file mode 100644
index 0000000000..c896b671ac
--- /dev/null
+++ b/lib/runtime_tools/src/scheduler.erl
@@ -0,0 +1,152 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2018. 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.
+%% You may obtain a copy of the License at
+%%
+%%     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%
+%%
+
+%% @doc Utility functions for easier measurement of scheduler utilization
+%%      using erlang:statistics(scheduler_wall_time).
+
+-module(scheduler).
+
+-export([sample/0,
+         sample_all/0,
+         utilization/1,
+         utilization/2]).
+
+-export_type([sched_sample/0]).
+
+
+-opaque sched_sample() ::
+          {scheduler_wall_time | scheduler_wall_time_all,
+           [{sched_type(), sched_id(), ActiveTime::integer(), TotalTime::integer()}]}.
+
+-type sched_type() :: normal | cpu | io.
+
+-type sched_id() :: integer().
+
+-spec sample() -> sched_sample().
+sample() ->
+    sample(scheduler_wall_time).
+
+-spec sample_all() -> sched_sample().
+sample_all() ->
+    sample(scheduler_wall_time_all).
+
+sample(Stats) ->
+    case erlang:statistics(Stats) of
+        undefined ->
+            erlang:system_flag(scheduler_wall_time, true),
+            sample(Stats);
+        
+        List ->
+            Sorted = lists:sort(List),
+            Tagged = lists:map(fun({I, A, T}) -> {sched_tag(I), I, A, T} end,
+                               Sorted),
+            {Stats, Tagged}
+    end.
+
+-type sched_util_result() ::
+        [{sched_type(), sched_id(), float(), string()} |
+         {total, float(), string()} |
+         {weighted, float(), string()}].
+
+-spec utilization(Seconds) -> sched_util_result() when
+      Seconds :: pos_integer();
+                 (Sample) -> sched_util_result() when
+      Sample :: sched_sample().
+utilization(Seconds) when is_integer(Seconds), Seconds > 0 ->
+    OldFlag = erlang:system_flag(scheduler_wall_time, true),
+    T0 = sample(),
+    receive after Seconds*1000 -> ok end,
+    T1 = sample(),
+    case OldFlag of
+        false ->
+            erlang:system_flag(scheduler_wall_time, OldFlag);
+        true ->
+            ok
+    end,
+    utilization(T0,T1);
+
+utilization({Stats, _}=T0) when Stats =:= scheduler_wall_time;
+                                Stats =:= scheduler_wall_time_all ->
+    utilization(T0, sample(Stats)).
+
+-spec utilization(Sample1, Sample2) -> sched_util_result() when
+      Sample1 :: sched_sample(),
+      Sample2 :: sched_sample().
+utilization({Stats, Ts0}, {Stats, Ts1}) ->
+    Diffs = lists:map(fun({{Tag, I, A0, T0}, {Tag, I, A1, T1}}) ->
+                              {Tag, I, (A1 - A0), (T1 - T0)}
+                      end,
+                      lists:zip(Ts0,Ts1)),
+
+    {Lst0, {A, T, N}} = lists:foldl(fun({Tag, I, Adiff, Tdiff}, {Lst, Acc}) ->
+                                            R = safe_div(Adiff, Tdiff),
+                                            {[{Tag, I, R, percent(R)} | Lst],
+                                             acc(Tag, Adiff, Tdiff, Acc)}
+                                    end,
+                                    {[], {0, 0, 0}},
+                               Diffs),
+
+    Total = safe_div(A, T),
+    Lst1 = lists:reverse(Lst0),
+    Lst2 = case erlang:system_info(logical_processors_available) of
+               unknown -> Lst1;
+               LPA ->
+                   Weighted = Total * (N / LPA),
+                   [{weighted, Weighted, percent(Weighted)} | Lst1]
+           end,
+    [{total, Total, percent(Total)} | Lst2];
+
+utilization({scheduler_wall_time, _}=T0,
+            {scheduler_wall_time_all, Ts1}) ->
+    utilization(T0, {scheduler_wall_time, remove_io(Ts1)});
+
+utilization({scheduler_wall_time_all, Ts0},
+            {scheduler_wall_time, _}=T1) ->
+    utilization({scheduler_wall_time, remove_io(Ts0)}, T1).
+
+%% Do not include dirty-io in totals
+acc(io, _, _, Acc) ->
+    Acc;
+acc(Tag, Adiff, Tdiff, {Asum, Tsum, N}) when Tag =:= normal; Tag =:= cpu ->
+    {Adiff+Asum, Tdiff+Tsum, N+1}.
+
+
+remove_io(Ts) ->
+    lists:filter(fun({io,_,_,_}) -> false;
+                    (_) -> true end,
+                 Ts).
+
+safe_div(A, B) ->
+    if B == 0.0 -> 0.0;
+       true -> A / B
+    end.            
+
+sched_tag(Nr) ->
+    Normal = erlang:system_info(schedulers),
+    Cpu = Normal + erlang:system_info(dirty_cpu_schedulers),
+    case Nr of
+        _ when Nr =< Normal -> normal;
+        _ when Nr =< Cpu -> cpu;
+        _ -> io
+    end.
+
+
+percent(F) ->
+    float_to_list(F*100, [{decimals,1}]) ++ [$%].