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

9 files changed, 802 insertions, 4 deletions

diff --git a/lib/runtime_tools/doc/src/Makefile b/lib/runtime_tools/doc/src/Makefile
index 0292333f0a..38725807ae 100644
--- a/lib/runtime_tools/doc/src/Makefile
+++ b/lib/runtime_tools/doc/src/Makefile
@@ -41,7 +41,7 @@ RELSYSDIR = $(RELEASE_PATH)/lib/$(APPLICATION)-$(VSN)
 # Target Specs
 # ----------------------------------------------------
 XML_APPLICATION_FILES = ref_man.xml
-XML_REF3_FILES = dbg.xml dyntrace.xml erts_alloc_config.xml system_information.xml
+XML_REF3_FILES = dbg.xml dyntrace.xml erts_alloc_config.xml system_information.xml msacc.xml
 XML_REF6_FILES = runtime_tools_app.xml
 
 XML_PART_FILES = part_notes.xml part_notes_history.xml part.xml
diff --git a/lib/runtime_tools/doc/src/msacc.xml b/lib/runtime_tools/doc/src/msacc.xml
new file mode 100644
index 0000000000..129da3d230
--- /dev/null
+++ b/lib/runtime_tools/doc/src/msacc.xml
@@ -0,0 +1,305 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE erlref SYSTEM "erlref.dtd">
+
+<erlref>
+  <header>
+    <copyright>
+      <year>2014</year><year>2014</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    </legalnotice>
+
+    <title>Microstate Accounting</title>
+    <prepared>Lukas Larsson</prepared>
+    <responsible></responsible>
+    <docno>1</docno>
+    <approved></approved>
+    <checked></checked>
+    <date>14-09-30</date>
+    <rev>A</rev>
+    <file>msacc.xml</file>
+  </header>
+  <module>msacc</module>
+  <modulesummary>Convenience functions for microstate accounting</modulesummary>
+  <description>
+    <p>This module implements some convenience functions for analyzing
+    microstate accounting data. For details about how to use the basic api and
+    what the different states represent see
+    <seealso marker="erts:erlang#statistics_microstate_accounting"><c>
+    erlang:statistics(microstate_accounting)</c></seealso>.</p>
+    <marker id="msacc_print_example"></marker>
+    <p><em>Basic Scenario</em></p>
+    <pre>1> <input>msacc:start(1000).</input>
+ok
+2> <input>msacc:print().</input>
+Average thread real-time    : 1000513 us
+Accumulated system run-time :    2213 us
+Average scheduler run-time  :    1076 us
+
+        Thread      aux check_io emulator       gc    other     port    sleep
+
+Stats per thread:
+     async( 0)    0.00%    0.00%    0.00%    0.00%    0.00%    0.00%  100.00%
+     async( 1)    0.00%    0.00%    0.00%    0.00%    0.00%    0.00%  100.00%
+       aux( 1)    0.00%    0.00%    0.00%    0.00%    0.00%    0.00%   99.99%
+ scheduler( 1)    0.00%    0.03%    0.13%    0.00%    0.01%    0.00%   99.82%
+ scheduler( 2)    0.00%    0.00%    0.00%    0.00%    0.03%    0.00%   99.97%
+
+Stats per type:
+         async    0.00%    0.00%    0.00%    0.00%    0.00%    0.00%  100.00%
+           aux    0.00%    0.00%    0.00%    0.00%    0.00%    0.00%   99.99%
+     scheduler    0.00%    0.02%    0.06%    0.00%    0.02%    0.00%   99.89%
+ok
+</pre>
+    <p>This first command enables microstate accounting for 1000 milliseconds.
+    See <seealso marker="#start-0"><c>start/0</c></seealso>,
+    <seealso marker="#stop-0"><c>stop/0</c></seealso>,
+    <seealso marker="#reset-0"><c>reset/0</c></seealso> and
+    <seealso marker="#start-1"><c>start/1</c></seealso> for more details.
+    The second command prints the statistics gathered during that time.
+    First three general statistics are printed.</p>
+    <taglist>
+      <tag>Average real-time</tag>
+      <item>The average time spent collecting data in the threads.
+      This should be close to the time which data was collected.
+      </item>
+      <tag>System run-time</tag>
+      <item>The total run-time of all threads in the system.
+      This is what you get if you call <c>msacc:stats(total_runtime,Stats).</c>
+      </item>
+      <tag>Average scheduler run-time</tag>
+      <item>The average run-time for the schedulers.
+      This is the average amount of time the schedulers did not sleep.</item>
+    </taglist>
+    <p>Then one column per state is printed with a the percentage of time this
+    thread spent in the state out of it's own real-time. After the thread
+    specific time, the accumulated time for each type of thread is printed in
+    a similar format.</p>
+    <p>Since we have the average real-time and the percentage spent in each
+    state we can easily calculate the time spent in each state by multiplying
+    <c>Average thread real-time</c> with <c>Thread state %</c>, i.e. to
+    get the time Scheduler 1 spent in the emulator state we do
+    <c>1000513us * 0.13% = 1300us</c>.</p>
+  </description>
+  <datatypes>
+    <datatype>
+      <name name="msacc_data"/>
+    </datatype>
+    <datatype>
+      <name name="msacc_data_thread"/>
+    </datatype>
+    <datatype>
+      <name name="msacc_data_counters"/>
+      <desc><p>A map containing the different microstate accounting states and
+      the number of microseconds spent in it.</p></desc>
+    </datatype>
+    <datatype>
+      <name name="msacc_stats"/>
+    </datatype>
+    <datatype>
+      <name name="msacc_stats_thread"/>
+      <desc><p>A map containing information about a specific thread. The
+      percentages in the map can be either run-time or real-time depending
+      on if <c>runtime</c> or <c>realtime</c> was requested from
+      <seealso marker="#stats-2">stats/2</seealso>. <c>system</c> is the
+      percentage of total system time for this specific thread.</p></desc>
+    </datatype>
+    <datatype>
+      <name name="msacc_stats_counters"/>
+      <desc><p>A map containing the different microstate accounting states. Each
+      value in the map contains another map with the percentage of time that
+      this thread has spent in the specific state. Both the percentage of
+      <c>system</c> time and the time for that specific <c>thread</c> is part of
+      the map.</p></desc>
+    </datatype>
+    <datatype>
+      <name name="msacc_type"/>
+    </datatype>
+    <datatype>
+      <name name="msacc_id"/>
+    </datatype>
+    <datatype>
+      <name name="msacc_state"/>
+      <desc><p>The different states that a thread can be in. See
+      <seealso marker="erts:erlang#statistics_microstate_accounting">
+        erlang:statistics(microstate_accounting)</seealso> for details.
+      </p></desc>
+    </datatype>
+    <datatype>
+      <name name="msacc_print_options"/>
+      <desc><p>The different options that can be given to
+      <seealso marker="#print-2"><c>print/2</c></seealso>.
+      </p></desc>
+    </datatype>
+  </datatypes>
+  <funcs>
+    <func>
+      <name name="available" arity="0"/>
+      <fsummary>Check if microstate accounting is available</fsummary>
+      <desc>
+	<p>This function checks whether microstate accounting
+        is available or not.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="start" arity="0"/>
+      <fsummary>Start microstate accounting.</fsummary>
+      <desc>
+        <p>Start microstate accounting. Returns whether it was
+        previously enabled or disabled.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="start" arity="1"/>
+      <fsummary>Start microstate accounting for a time.</fsummary>
+      <desc>
+        <p>Resets all counters and then starts microstate accounting
+        for the given milliseconds.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="stop" arity="0"/>
+      <fsummary>Stop microstate accounting.</fsummary>
+      <desc>
+        <p>Stop microstate accounting.
+        Returns whether is was previously enabled or disabled.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="reset" arity="0"/>
+      <fsummary>Reset microstate accounting counters</fsummary>
+      <desc>
+        <p>Reset microstate accounting counters.
+        Returns whether is was enabled or disabled.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="print" arity="0"/>
+      <fsummary>Print microstate statistics</fsummary>
+      <desc>
+        <p>
+          Prints the current microstate accounting to standard out.
+          Same as
+          <seealso marker="#print-1">
+            <c>msacc:print(msacc:stats(),#{}).</c>
+          </seealso>
+        </p>
+      </desc>
+    </func>
+    <func>
+      <name name="print" arity="1"/>
+      <fsummary>Print microstate statistics</fsummary>
+      <desc>
+        <p>Print the given microstate statistics values to stdout.
+        Same as
+        <seealso marker="#print-1">
+          <c>msacc:print(DataOrStats,#{}).</c>
+        </seealso>
+        </p>
+      </desc>
+    </func>
+    <func>
+      <name name="print" arity="2"/>
+      <fsummary>Print microstate statistics</fsummary>
+      <desc>
+        <p>Print the given microstate statistics values to standard out.
+        With many states this can be quite verbose. See the top of this
+        reference manual for a brief description of what the fields mean.</p>
+        <p>It is possible to print more specific types of statistics by
+        first manipulating the <c>DataOrStats</c> using
+        <seealso marker="#stats-2"><c>stats/2</c></seealso>.
+        For instance if you want to print the percentage of run-time for each
+        thread you can do:</p>
+        <pre><input>msacc:print(msacc:stats(runtime,msacc:stats())).</input></pre>
+        <p>If you want to only print run-time per thread type you can do:</p>
+        <pre><input>msacc:print(msacc:stats(type,msacc:stats(runtime,msacc:stats()))).</input></pre>
+        <p><em>Options</em></p>
+        <taglist>
+          <tag><c>system</c></tag><item>Print percentage of time spent in each
+          state out of system time as well as thread time.
+          Default: false.</item>
+        </taglist>
+      </desc>
+    </func>
+    <func>
+      <name name="print" arity="3"/>
+      <fsummary>Print microstate statistics</fsummary>
+      <desc>
+        <p>Print the given microstate statistics values to the given file
+        or device. The other arguments behave the same way as for
+        <seealso marker="#print-2"><c>print/2</c></seealso>.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="stats" arity="0"/>
+      <fsummary></fsummary>
+      <desc>
+        <p>Returns a runtime system independent version of the microstate
+        statistics data presented by
+        <seealso marker="erts:erlang#statistics_microstate_accounting">
+        <c>erlang:statistics(microstate_accounting)</c></seealso>.
+        All counters have been normalized to be in microsecond resolution.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="stats" arity="2" clause_i="1"/>
+      <fsummary></fsummary>
+      <desc>
+        <p>Returns the system time for the given microstate statistics values.
+        System time is the accumulated time of all threads.</p>
+        <taglist>
+          <tag><c>realtime</c></tag>
+          <item>Returns all time recorded for all threads.</item>
+          <tag><c>runtime</c></tag>
+          <item>Returns all time spent doing work for all threads, i.e.
+          all time not spent in the <c>sleep</c> state.</item>
+        </taglist>
+      </desc>
+    </func>
+    <func>
+      <name name="stats" arity="2" clause_i="2"/>
+      <fsummary></fsummary>
+      <desc>
+        <p>Returns fractions of real-time or run-time spent in the various
+        threads from the given microstate statistics values.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="stats" arity="2" clause_i="3"/>
+      <fsummary></fsummary>
+      <desc>
+        <p>Returns a list of microstate statistics values where the values
+        for all threads of the same type has been merged.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="to_file" arity="1"/>
+      <fsummary></fsummary>
+      <desc>
+        <p>Dumps the current microstate statistics counters to a file that can
+        be parsed with <seealso marker="kernel:file#consult/1">
+        file:consult/1</seealso>.</p>
+      </desc>
+    </func>
+    <func>
+      <name name="from_file" arity="1"/>
+      <fsummary></fsummary>
+      <desc>
+        <p>Read a file dump produced by <seealso marker="#to_file/1">
+        to_file(Filename)</seealso>.</p>
+      </desc>
+    </func>
+  </funcs>
+</erlref>
diff --git a/lib/runtime_tools/doc/src/ref_man.xml b/lib/runtime_tools/doc/src/ref_man.xml
index ea0c0832a4..8657a07a30 100644
--- a/lib/runtime_tools/doc/src/ref_man.xml
+++ b/lib/runtime_tools/doc/src/ref_man.xml
@@ -36,6 +36,7 @@
   <xi:include href="dbg.xml"/>
   <xi:include href="dyntrace.xml"/>
   <xi:include href="erts_alloc_config.xml"/>
+  <xi:include href="msacc.xml"/>
   <xi:include href="system_information.xml"/>
 </application>
 
diff --git a/lib/runtime_tools/doc/src/specs.xml b/lib/runtime_tools/doc/src/specs.xml
index d4c3c9dfe6..978bd39e55 100644
--- a/lib/runtime_tools/doc/src/specs.xml
+++ b/lib/runtime_tools/doc/src/specs.xml
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <specs xmlns:xi="http://www.w3.org/2001/XInclude">
   <xi:include href="../specs/specs_system_information.xml"/>
+  <xi:include href="../specs/specs_msacc.xml"/>
 </specs>
diff --git a/lib/runtime_tools/src/Makefile b/lib/runtime_tools/src/Makefile
index 99b90f9ec5..3b41184f4e 100644
--- a/lib/runtime_tools/src/Makefile
+++ b/lib/runtime_tools/src/Makefile
@@ -45,7 +45,9 @@ MODULES= \
 	percept_profile \
 	system_information \
 	observer_backend \
-	ttb_autostart
+	ttb_autostart\
+	msacc
+
 HRL_FILES= ../include/observer_backend.hrl
 
 ERL_FILES= $(MODULES:%=%.erl)
diff --git a/lib/runtime_tools/src/msacc.erl b/lib/runtime_tools/src/msacc.erl
new file mode 100644
index 0000000000..612effa5aa
--- /dev/null
+++ b/lib/runtime_tools/src/msacc.erl
@@ -0,0 +1,355 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2014-2015. 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 Microstate accounting utility function
+%%
+%%	This module provides a user interface for analysing
+%%      erlang:statistics(microstate_accounting) data.
+%%
+
+-module(msacc).
+-export([available/0, start/0, start/1, stop/0, reset/0, to_file/1,
+         from_file/1, stats/0, stats/2, print/0, print/1, print/2,
+         print/3]).
+
+-type msacc_data() :: [msacc_data_thread()].
+
+-type msacc_data_thread() :: #{ '$type' => msacc_data,
+                                type => msacc_type(), id => msacc_id(),
+                                counters => msacc_data_counters() }.
+-type msacc_data_counters() :: #{ msacc_state() => non_neg_integer()}.
+
+-type msacc_stats() :: [msacc_stats_thread()].
+-type msacc_stats_thread() :: #{ '$type' => msacc_stats,
+                                 type => msacc_type(), id => msacc_id(),
+                                 system => float(),
+                                 counters => msacc_stats_counters()}.
+-type msacc_stats_counters() :: #{ msacc_state() => #{ thread => float(),
+                                                       system => float()}}.
+
+
+-type msacc_type() :: scheduler | aux | async.
+-type msacc_id() :: non_neg_integer().
+-type msacc_state() :: alloc | aux | bif | busy_wait | check_io |
+                       emulator | ets | gc | gc_fullsweep | nif |
+                       other | port | send | sleep | timers.
+
+-type msacc_print_options() :: #{ system => boolean() }.
+
+-spec available() -> boolean().
+available() ->
+    try
+        [_|_] = erlang:statistics(microstate_accounting),
+        true
+    catch _:_ ->
+            false
+    end.
+
+-spec start() -> boolean().
+start() ->
+    erlang:system_flag(microstate_accounting, true).
+
+-spec stop() -> boolean().
+stop() ->
+    erlang:system_flag(microstate_accounting, false).
+
+-spec reset() -> boolean().
+reset() ->
+    erlang:system_flag(microstate_accounting, reset).
+
+-spec start(Time) -> true when
+      Time :: timeout().
+start(Tmo) ->
+    stop(), reset(), start(),
+    timer:sleep(Tmo),
+    stop().
+
+-spec to_file(Filename) -> ok | {error, file:posix()} when
+      Filename :: file:name_all().
+to_file(Filename) ->
+    file:write_file(Filename, io_lib:format("~p.~n",[stats()])).
+
+-spec from_file(Filename) -> msacc_data() when
+      Filename :: file:name_all().
+from_file(Filename) ->
+    {ok, [Stats]} = file:consult(Filename),
+    Stats.
+
+-spec print() -> ok.
+print() ->
+    print(stats()).
+
+-spec print(DataOrStats) -> ok when
+      DataOrStats :: msacc_data() | msacc_stats().
+print(Stats) ->
+    print(Stats, #{}).
+
+-spec print(DataOrStats, Options) -> ok when
+      DataOrStats :: msacc_data() | msacc_stats(),
+      Options :: msacc_print_options().
+print(Stats, Options) ->
+    print(group_leader(), Stats, Options).
+
+-spec print(FileOrDevice, DataOrStats, Options) -> ok when
+      FileOrDevice :: file:filename() | io:device(),
+      DataOrStats :: msacc_data() | msacc_stats(),
+      Options :: msacc_print_options().
+print(Filename, Stats, Options) when is_list(Filename) ->
+    case file:open(Filename,[write]) of
+        {ok, D} -> print(D, Stats, Options),file:close(D);
+        Error -> Error
+    end;
+print(Device, Stats, Options) ->
+    DefaultOpts = #{ system => false },
+    print_int(Device, Stats, maps:merge(DefaultOpts, Options)).
+print_int(Device, [#{ '$type' := msacc_data, id := _Id }|_] = Stats, Options) ->
+    TypeStats = stats(type, Stats),
+    io:format(Device, "~s", [print_stats_overview(Stats, Options)]),
+    io:format(Device, "~s", [print_stats_header(Stats, Options)]),
+    io:format(Device, "~s", [print_stats_threads(
+                               stats(realtime, Stats), Options)]),
+    io:format(Device, "~s", [print_stats_type(
+                               stats(realtime, TypeStats), Options)]);
+print_int(Device, [#{ '$type' := msacc_data }|_] = Stats, Options) ->
+    io:format(Device, "~s", [print_stats_header(Stats, Options)]),
+    io:format(Device, "~s", [print_stats_type(
+                               stats(realtime, Stats), Options)]);
+print_int(Device, [#{ '$type' := msacc_stats, id := _Id }|_] = Stats,Options) ->
+    io:format(Device, "~s", [print_stats_header(Stats, Options)]),
+    io:format(Device, "~s", [print_stats_threads(Stats, Options)]),
+    io:format(Device, "~s", [print_stats_type(
+                               msacc:stats(type, Stats), Options)]);
+print_int(Device, [#{ '$type' := msacc_stats }|_] = Stats, Options) ->
+    io:format(Device, "~s", [print_stats_header(Stats, Options)]),
+    io:format(Device, "~s", [print_stats_type(Stats, Options)]).
+
+
+-spec stats() -> msacc_data().
+stats() ->
+    Fun = fun F(K,{PerfCount,StateCount}) ->
+                %% Need to handle ERTS_MSACC_STATE_COUNTERS
+                {F(K,PerfCount),StateCount};
+              F(_K,PerfCount) ->
+                erlang:convert_time_unit(PerfCount, perf_counter, 1000000)
+        end,
+    UsStats = lists:map(
+                fun(#{ counters := Cnt } = M) ->
+                        UsCnt = maps:map(Fun,Cnt),
+                        M#{ '$type' => msacc_data, counters := UsCnt }
+                end, erlang:statistics(microstate_accounting)),
+    statssort(UsStats).
+
+-spec stats(Analysis, Stats) -> non_neg_integer() when
+      Analysis :: system_realtime | system_runtime,
+      Stats :: msacc_data();
+           (Analysis, Stats) -> msacc_stats() when
+      Analysis :: realtime | runtime,
+      Stats :: msacc_data();
+           (Analysis, StatsOrData) -> msacc_data() | msacc_stats() when
+      Analysis :: type,
+      StatsOrData :: msacc_data() | msacc_stats().
+stats(system_realtime, Stats) ->
+    lists:foldl(fun(#{ counters := Cnt }, Acc) ->
+                        get_total(Cnt, Acc)
+                end, 0, Stats);
+stats(system_runtime, Stats) ->
+    lists:foldl(fun(#{ counters := Cnt }, Acc) ->
+                        get_total(maps:remove(sleep, Cnt), Acc)
+                end, 0, Stats);
+stats(realtime, Stats) ->
+    RealTime = stats(system_realtime, Stats),
+    statssort([get_thread_perc(Thread, RealTime) || Thread <- Stats]);
+stats(runtime, Stats) ->
+    RunTime = stats(system_runtime, Stats),
+    statssort([get_thread_perc(T#{ counters := maps:remove(sleep,Cnt)}, RunTime)
+                               || T = #{ counters := Cnt } <- Stats]);
+stats(type, Stats) ->
+    statssort(merge_threads(Stats, [])).
+
+print_stats_overview(Stats, _Options) ->
+    RunTime = stats(system_runtime, Stats),
+    RealTime = stats(system_realtime, Stats) div length(Stats),
+    SchedStats = [S || #{ type := scheduler } = S <- Stats],
+    AvgSchedRunTime = stats(system_runtime, SchedStats) div length(SchedStats),
+    NumSize = if
+                  RealTime > RunTime -> length(integer_to_list(RealTime));
+                  true -> length(integer_to_list(RunTime))
+              end,
+    [io_lib:format("Average thread real-time    : ~*B us~n",
+                   [NumSize, RealTime]),
+     io_lib:format("Accumulated system run-time : ~*B us~n",
+                   [NumSize, RunTime]),
+     io_lib:format("Average scheduler run-time  : ~*B us~n",
+                   [NumSize, AvgSchedRunTime]),
+     io_lib:format("~n",[])].
+
+print_stats_threads(Stats, Options) ->
+    [io_lib:format("~nStats per thread:~n", []),
+     [print_thread_info(Thread, Options) || Thread <- Stats]].
+
+print_stats_type(Stats, Options) ->
+    [io_lib:format("~nStats per type:~n", []),
+     [print_thread_info(Thread, Options) || Thread <- Stats]].
+
+
+print_stats_header([#{ counters := Cnt }|_], #{ system := PrintSys }) ->
+    [io_lib:format("~14s", ["Thread"]),
+     map(fun(Counter, _) when PrintSys->
+                 io_lib:format("~9s     ", [atom_to_list(Counter)]);
+            (Counter, _) ->
+                 io_lib:format("~9s", [atom_to_list(Counter)])
+         end, Cnt),
+     io_lib:format("~n",[])].
+
+print_thread_info(#{ '$type' := msacc_stats,
+                     counters := Cnt } = Thread, #{ system := PrintSys }) ->
+    [case maps:find(id, Thread) of
+        error ->
+            io_lib:format("~14s", [atom_to_list(maps:get(type, Thread))]);
+        {ok, Id} ->
+            io_lib:format("~10s(~2B)", [atom_to_list(maps:get(type,Thread)),Id])
+    end,
+    map(fun(_Key, #{ thread := ThreadPerc, system := SystemPerc }) when PrintSys ->
+                io_lib:format("~6.2f%(~4.1f%)", [ThreadPerc, SystemPerc]);
+           (_Key, #{ thread := ThreadPerc }) ->
+                io_lib:format("~8.2f%", [ThreadPerc])
+             end, Cnt),
+    io_lib:format("~n",[])].
+
+get_total(Cnt, Base) ->
+    maps:fold(fun(_, {Val,_}, Time) ->
+                      %% Have to handle ERTS_MSACC_STATE_COUNTERS
+                      Time + Val;
+                 (_, Val, Time) -> Time + Val
+              end, Base, Cnt).
+
+get_thread_perc(#{ '$type' := msacc_data, counters := Cnt } = Thread,
+                SystemTime) ->
+    ThreadTime = get_total(Cnt, 0),
+    Thread#{ '$type' := msacc_stats,
+             system => percentage(ThreadTime,SystemTime),
+             counters => get_thread_perc(Cnt, ThreadTime, SystemTime)}.
+get_thread_perc(Cnt, ThreadTime, SystemTime) ->
+    maps:map(fun F(Key, {Val, C}) ->
+                    M = F(Key, Val),
+                    M#{ cnt => C };
+                 F(_Key, Val) ->
+                    #{ thread => percentage(Val, ThreadTime),
+                       system => percentage(Val, SystemTime) }
+            end, Cnt).
+
+%% This code is a little bit messy as it has to be able to deal with
+%% both [msacc_data()] and [msacc_stats()].
+merge_threads([#{ '$type' := msacc_stats,
+                  type := Type,
+                  counters := Cnt } = M0|R], Acc) ->
+    case keyfind(type, Type, Acc) of
+        false ->
+            merge_threads(R, [maps:remove(id,M0#{ threads => 1 })|Acc]);
+        #{ '$type' := msacc_stats, counters := Cnt0,
+           threads := Threads, system := System } = M ->
+            NewMap = M#{ counters := add_counters(Cnt, Cnt0),
+                         system := System + maps:get(system, M0),
+                         threads := Threads + 1},
+            NewAcc = keyreplace(type, Type, NewMap, Acc),
+            merge_threads(R, NewAcc)
+    end;
+merge_threads([], [#{ '$type' := msacc_stats,
+                      system := System,
+                      threads := Threads,
+                      counters := Cnt} = M0|R]) ->
+    Counters = maps:map(fun(_,#{ thread := Thr } = Map) ->
+                                Map#{ thread := Thr / Threads }
+                        end, Cnt),
+    M = maps:remove(threads, M0),
+    [M#{ system := System, counters := Counters} | merge_threads([],R)];
+merge_threads([], []) ->
+    [];
+%% The clauses below deal with msacc_data()
+merge_threads([#{ '$type' := msacc_data,
+                  type := Type,
+                  counters := Cnt } = M0|R], Acc) ->
+    case keyfind(type, Type, Acc) of
+        false ->
+            merge_threads(R, [maps:remove(id,M0)|Acc]);
+        #{ '$type' := msacc_data, counters := Cnt0 } = M ->
+            NewMap = M#{ counters := add_counters(Cnt, Cnt0) },
+            NewAcc = keyreplace(type, Type, NewMap, Acc),
+            merge_threads(R, NewAcc)
+    end;
+merge_threads([], Acc) ->
+    Acc.
+
+add_counters(M1, M2) ->
+    maps:map(
+      fun(Key, #{ thread := Thr1, system := Sys1, cnt := Cnt1}) ->
+              %% Have to handle ERTS_MSACC_STATE_COUNTERS
+              #{ thread := Thr2, system := Sys2, cnt := Cnt2} = maps:get(Key, M2),
+              #{ thread => Thr1 + Thr2, system => Sys1 + Sys2,
+                 cnt => Cnt1 + Cnt2 };
+         (Key, #{ thread := Thr1, system := Sys1}) ->
+              #{ thread := Thr2, system := Sys2} = maps:get(Key, M2),
+              #{ thread => Thr1 + Thr2, system => Sys1 + Sys2};
+         (Key, {V1,C1}) ->
+              %% Have to handle ERTS_MSACC_STATE_COUNTERS
+              {V2,C2} = maps:get(Key, M2),{V1+V2,C1+C2};
+         (Key, V1) -> maps:get(Key, M2) + V1
+      end, M1).
+
+percentage(Divident, Divisor) ->
+    if Divisor == 0 andalso Divident /= 0 ->
+            100.0;
+        Divisor == 0 ->
+            0.0;
+       true ->
+            Divident / Divisor * 100
+    end.
+
+keyfind(Key, Value, [H|T]) ->
+    case maps:find(Key, H) of
+        {ok, Value} ->
+            H;
+        _ ->
+            keyfind(Key, Value, T)
+    end;
+keyfind(_, _, []) ->
+    false.
+
+keyreplace(Key, Value, NewMap, [H|T]) ->
+    case maps:find(Key, H) of
+        {ok, Value} ->
+            [NewMap|T];
+        _ ->
+            [H|keyreplace(Key, Value, NewMap, T)]
+    end;
+keyreplace(_, _, _, []) ->
+    [].
+
+statssort(Stats) ->
+    lists:sort(fun(#{ type := Type1, id := Id1},
+                   #{ type := Type2, id := Id2}) ->
+                       {Type1, Id1} < {Type2, Id2};
+                  (#{ type := Type1}, #{ type := Type2}) ->
+                       Type1 < Type2
+               end, Stats).
+
+map(Fun,Map) ->
+    [ Fun(K,V) || {K,V} <- maps:to_list(Map) ].
diff --git a/lib/runtime_tools/src/runtime_tools.app.src b/lib/runtime_tools/src/runtime_tools.app.src
index ad10655aa0..aeda103e72 100644
--- a/lib/runtime_tools/src/runtime_tools.app.src
+++ b/lib/runtime_tools/src/runtime_tools.app.src
@@ -22,7 +22,8 @@
     {vsn,          "%VSN%"},
     {modules,      [appmon_info, dbg,observer_backend,percept_profile,
 		    runtime_tools,runtime_tools_sup,erts_alloc_config,
-		    ttb_autostart,dyntrace,system_information]},
+		    ttb_autostart,dyntrace,system_information,
+                    msacc]},
     {registered,   [runtime_tools_sup]},
     {applications, [kernel, stdlib]},
     {env,          []},
diff --git a/lib/runtime_tools/test/Makefile b/lib/runtime_tools/test/Makefile
index dcb9082231..71ac8b1157 100644
--- a/lib/runtime_tools/test/Makefile
+++ b/lib/runtime_tools/test/Makefile
@@ -7,7 +7,8 @@ MODULES =  \
 	runtime_tools_SUITE \
 	system_information_SUITE \
 	dbg_SUITE \
-	erts_alloc_config_SUITE
+	erts_alloc_config_SUITE \
+	msacc_SUITE
 
 ERL_FILES= $(MODULES:%=%.erl)
 
diff --git a/lib/runtime_tools/test/msacc_SUITE.erl b/lib/runtime_tools/test/msacc_SUITE.erl
new file mode 100644
index 0000000000..145a6d07fb
--- /dev/null
+++ b/lib/runtime_tools/test/msacc_SUITE.erl
@@ -0,0 +1,132 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2014-2015. 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%
+%%
+-module(msacc_SUITE).
+
+-include_lib("common_test/include/ct.hrl").
+
+%% Test server callbacks
+-export([suite/0, all/0]).
+
+%% Test cases
+-export([
+	%% API-test
+	api_file/1,
+        api_start_stop/1,
+	api_timer/1,
+        api_print/1
+    ]).
+
+%%--------------------------------------------------------------------
+%% COMMON TEST CALLBACK FUNCTIONS
+%%--------------------------------------------------------------------
+all() ->
+    [
+     api_start_stop,
+     api_file,
+     api_timer,
+     api_print
+    ].
+
+suite() -> [
+	{timetrap,{minutes,1}},
+	{ct_hooks,[ts_install_cth]}
+    ].
+
+%%--------------------------------------------------------------------
+%% TEST CASES
+%%--------------------------------------------------------------------
+
+api_timer(_Config) ->
+
+    %% Run msacc for about 100ms
+    msacc:start(100),
+
+    %% Verify that scheduler 1 executed+slept for about 100ms
+    [Sched1] = [S || S = #{ type := scheduler, id := 1 } <- msacc:stats()],
+
+    #{ counters := Cnt } = Sched1,
+
+    %% Time should be in us
+    Time = maps:fold(fun(_,V,Acc) -> V + Acc end, 0, Cnt),
+
+    if Time < 120000 andalso Time > 80000 -> ok;
+       true -> ct:fail({inaccurate_time, Time, msacc:stats()})
+    end.
+
+%% We just do a basic check that none of the apis crash
+api_start_stop(_Config) ->
+    msacc:start(),
+    timer:sleep(100),
+    msacc:stop(),
+    Runtime = msacc:stats(system_runtime, msacc:stats()),
+    Realtime = msacc:stats(system_realtime, msacc:stats()),
+    true = Runtime < Realtime,
+
+    RuntimeCnt = msacc:stats(runtime, msacc:stats()),
+    RealtimeCnt = msacc:stats(realtime, msacc:stats()),
+    TypeCnt = msacc:stats(type, msacc:stats()),
+
+    %% These should be very similar
+    RuntimeTypeCnt = msacc:stats(type, RuntimeCnt),
+    TypeRuntimeCnt = msacc:stats(runtime, TypeCnt),
+    lists:map(fun({#{ system := T1 },#{ system := T2}}) ->
+                      if T1-0.5 < T2 orelse T1+0.5 > T2 -> ok;
+                         true -> ct:fail({inaccurate_stats, RuntimeTypeCnt,
+                                          TypeRuntimeCnt})
+                      end
+              end, lists:zip(RuntimeTypeCnt, TypeRuntimeCnt)),
+
+    %% These should be very similar
+    RealtimeTypeCnt = msacc:stats(type, RealtimeCnt),
+    TypeRealtimeCnt = msacc:stats(realtime, TypeCnt),
+    lists:map(fun({#{ system := T1 },#{ system := T2}}) ->
+                      if T1-0.5 < T2 orelse T1+0.5 > T2 -> ok;
+                         true -> ct:fail({inaccurate_stats, RealtimeTypeCnt,
+                                          TypeRealtimeCnt})
+                      end
+              end,lists:zip(RealtimeTypeCnt, TypeRealtimeCnt)),
+
+    msacc:reset().
+
+api_file(Config) ->
+    PrivDir = proplists:get_value(priv_dir, Config),
+    File = filename:join(PrivDir, "msacc.stats"),
+    Stats = msacc:stats(),
+    ok = msacc:to_file(File),
+    Stats = msacc:from_file(File),
+
+    PrintFile = filename:join(PrivDir, "msacc.txt"),
+    msacc:print(PrintFile, Stats, #{}).
+
+%% We just check that it is possible to print in a couple of different ways
+api_print(_Config) ->
+    msacc:start(100),
+    io:format("msacc:print(msacc:stats()).~n"),
+    msacc:print(msacc:stats()),
+    io:format("msacc:print(msacc:stats(),#{ system => true }).~n"),
+    msacc:print(msacc:stats(), #{ system => true }),
+    io:format("msacc:print(msacc:stats(runtime,msacc:stats())).~n"),
+    msacc:print(msacc:stats(runtime, msacc:stats())),
+    io:format("msacc:print(msacc:stats(type,msacc:stats())).~n"),
+    msacc:print(msacc:stats(type, msacc:stats())),
+    io:format("msacc:print(msacc:stats(realtime,msacc:stats())).~n"),
+    msacc:print(msacc:stats(realtime, msacc:stats())),
+    io:format("msacc:stats(type,msacc:stats(runtime,msacc:stats())).~n"),
+    msacc:print(msacc:stats(type, msacc:stats(runtime, msacc:stats()))).