Merge branch 'egil/increase-eprof-usability/OTP-11144' into maint

* egil/increase-eprof-usability/OTP-11144:
  tools: Document new eprof options
  tools: Add options to eprof
  tools: Add testcase to eprof_SUITE
  tools: Refactor away ?line macro in eprof_SUITE

4 files changed, 301 insertions, 199 deletions

diff --git a/lib/tools/doc/src/eprof.xml b/lib/tools/doc/src/eprof.xml
index 82eb8dd284..8397204a43 100644
--- a/lib/tools/doc/src/eprof.xml
+++ b/lib/tools/doc/src/eprof.xml
@@ -52,12 +52,14 @@
     <func>
       <name>start_profiling(Rootset) -> profiling | {error, Reason}</name>
       <name>start_profiling(Rootset,Pattern) -> profiling | {error, Reason}</name>
+      <name>start_profiling(Rootset,Pattern,Options) -> profiling | {error, Reason}</name>
       <fsummary>Start profiling.</fsummary>
       <type>
         <v>Rootset = [atom() | pid()]</v>
-	<v>Pattern = {Module, Function, Arity}</v>
-	<v>Module = Function = atom()</v>
-	<v>Arity = integer()</v>
+		<v>Pattern = {Module, Function, Arity}</v>
+		<v>Module = Function = atom()</v>
+		<v>Arity = integer()</v>
+		<v>Options = [set_on_spawn]</v>
         <v>Reason = term()</v>
       </type>
       <desc>
@@ -70,6 +72,9 @@
         <p>A pattern can be selected to narrow the profiling. For instance a
           specific module can be selected, and only the code executed in that
           module will be profiled.</p>
+	    <p>The <c>set_on_spawn</c> option will active call time tracing for
+			all processes spawned by processes in the rootset. This is
+			the default behaviour.</p>
       </desc>
     </func>
     <func>
@@ -82,19 +87,22 @@
     </func>
     <func>
       <name>profile(Fun) -> profiling | {error, Reason}</name>
+      <name>profile(Fun, Options) -> profiling | {error, Reason}</name>
       <name>profile(Rootset) -> profiling | {error, Reason}</name>
       <name>profile(Rootset,Fun) -> {ok, Value} | {error,Reason}</name>
       <name>profile(Rootset,Fun,Pattern) -> {ok, Value} | {error, Reason}</name>
       <name>profile(Rootset,Module,Function,Args) -> {ok, Value} | {error, Reason}</name>
       <name>profile(Rootset,Module,Function,Args,Pattern) -> {ok, Value} | {error, Reason}</name>
+      <name>profile(Rootset,Module,Function,Args,Pattern,Options) -> {ok, Value} | {error, Reason}</name>
       <fsummary>Start profiling.</fsummary>
       <type>
         <v>Rootset = [atom() | pid()]</v>
-        <v>Fun = fun() -> term()</v>
-	<v>Pattern = {Module, Function, Arity}</v>
+        <v>Fun = fun() -> term() end</v>
+		<v>Pattern = {Module, Function, Arity}</v>
         <v>Module = Function = atom()</v>
         <v>Args = [term()]</v>
-	<v>Arity = integer()</v>
+		<v>Arity = integer()</v>
+		<v>Options = [set_on_spawn]</v>
         <v>Value = Reason = term()</v>
       </type>
       <desc>
@@ -108,8 +116,11 @@
           <c>Rootset</c>, the function returns <c>{ok,Value}</c> when
           <c>Fun()</c>/<c>apply</c> returns with the value <c>Value</c>, or
           <c>{error,Reason}</c> if <c>Fun()</c>/<c>apply</c> fails with
-	  exit reason <c>Reason</c>. Otherwise it returns <c>{error, Reason}</c>
+		  exit reason <c>Reason</c>. Otherwise it returns <c>{error, Reason}</c>
           immediately.</p>
+	    <p>The <c>set_on_spawn</c> option will active call time tracing for
+			all processes spawned by processes in the rootset. This is
+			the default behaviour.</p>
         <p>The programmer must ensure that the function given as argument
           is truly synchronous and that no work continues after
           the function has returned a value.</p>
diff --git a/lib/tools/src/eprof.erl b/lib/tools/src/eprof.erl
index 87fdc1fa34..bc9345fa62 100644
--- a/lib/tools/src/eprof.erl
+++ b/lib/tools/src/eprof.erl
@@ -26,7 +26,7 @@
 -export([start/0,
 	 stop/0,
 	 dump/0,
-	 start_profiling/1, start_profiling/2,
+	 start_profiling/1, start_profiling/2, start_profiling/3,
 	 profile/1, profile/2, profile/3, profile/4, profile/5,
 	 stop_profiling/0,
 	 analyze/0, analyze/1, analyze/2,
@@ -39,6 +39,8 @@
 	 handle_info/2,
 	 terminate/2,
 	 code_change/3]).
+
+
 -record(bpd, {
 	n   = 0,                 % number of total calls
 	us  = 0,                 % sum of uS for all calls
@@ -46,14 +48,18 @@
 	mfa = []                 % list of {Mfa, {Count, Us}}
     }).
 
+-define(default_options, [{set_on_spawn, true}]).
+-define(default_pattern, {'_','_','_'}).
+
 -record(state, {
-	profiling = false,
-	pattern   = {'_','_','_'},
-	rootset   = [],
-	fd    = undefined,
-	start_ts  = undefined,
-	reply     = undefined,
-	bpd       = #bpd{}
+	profiling  = false,
+	pattern    = ?default_pattern,
+	rootset    = [],
+	trace_opts = [],
+	fd         = undefined,
+	start_ts   = undefined,
+	reply      = undefined,
+	bpd        = #bpd{}
     }).
 
 
@@ -67,26 +73,6 @@
 start() -> gen_server:start({local, ?MODULE}, ?MODULE, [], []).
 stop()  -> gen_server:call(?MODULE, stop, infinity).
 
-profile(Fun) when is_function(Fun) ->
-    profile([], Fun);
-profile(Rs) when is_list(Rs) ->
-    start_profiling(Rs).
-
-profile(Pids, Fun) ->
-    profile(Pids, Fun, {'_','_','_'}).
-
-profile(Pids, Fun, Pattern) ->
-    profile(Pids, erlang, apply, [Fun,[]], Pattern).
-
-profile(Pids, M, F, A) ->
-    profile(Pids, M, F, A, {'_','_','_'}).
-
-profile(Pids, M, F, A, Pattern) ->
-    start(),
-    gen_server:call(?MODULE, {profile,Pids,Pattern,M,F,A},infinity).
-
-dump() -> 
-    gen_server:call(?MODULE, dump, infinity).
 
 analyze() ->
     analyze(procs).
@@ -98,17 +84,53 @@ analyze(Opts) when is_list(Opts) ->
 analyze(Type, Opts) when is_list(Opts) ->
     gen_server:call(?MODULE, {analyze, Type, Opts}, infinity).
 
+%% odd duck, should only been start_profiling/1
+profile(Rootset) when is_list(Rootset) ->
+    start_profiling(Rootset);
+
+profile(Fun) when is_function(Fun) ->
+    profile([], Fun).
+
+profile(Fun, Opts) when is_function(Fun), is_list(Opts) ->
+    profile([], erlang, apply, [Fun, []], ?default_pattern, Opts);
+
+profile(Rootset, Fun) when is_list(Rootset), is_function(Fun) ->
+    profile(Rootset, Fun, ?default_pattern).
+
+profile(Rootset, Fun, Pattern) when is_list(Rootset), is_function(Fun) ->
+    profile(Rootset, Fun, Pattern, ?default_options).
+
+profile(Rootset, Fun, Pattern, Options) when is_list(Rootset), is_function(Fun), is_list(Options) ->
+    profile(Rootset, erlang, apply, [Fun,[]], Pattern, Options);
+
+profile(Rootset, M, F, A) when is_list(Rootset), is_atom(M), is_atom(F), is_list(A) ->
+    profile(Rootset, M, F, A, ?default_pattern).
+
+profile(Rootset, M, F, A, Pattern) when is_list(Rootset), is_atom(M), is_atom(F), is_list(A) ->
+    profile(Rootset, M, F, A, Pattern, ?default_options).
+
+%% Returns when M:F/A has terminated
+profile(Rootset, M, F, A, Pattern, Options) ->
+    start(),
+    gen_server:call(?MODULE, {profile_start, Rootset, Pattern, {M,F,A}, Options}, infinity).
+
+dump() -> 
+    gen_server:call(?MODULE, dump, infinity).
+
 log(File) ->
     gen_server:call(?MODULE, {logfile, File}, infinity).
 
+%% Does not block
 start_profiling(Rootset) ->
-    start_profiling(Rootset, {'_','_','_'}).
+    start_profiling(Rootset, ?default_pattern).
 start_profiling(Rootset, Pattern) ->
+    start_profiling(Rootset, Pattern, ?default_options).
+start_profiling(Rootset, Pattern, Options) ->
     start(),
-    gen_server:call(?MODULE, {profile, Rootset, Pattern}, infinity).
+    gen_server:call(?MODULE, {profile_start, Rootset, Pattern, undefined, Options}, infinity).
 
 stop_profiling() ->
-    gen_server:call(?MODULE, stop_profiling, infinity).
+    gen_server:call(?MODULE, profile_stop, infinity).
 
 
 %% -------------------------------------------------------------------- %%
@@ -151,74 +173,75 @@ handle_call({analyze, Type, _Opts}, _, S) ->
 
 %% profile
 
-handle_call({profile, _Rootset, _Pattern, _M,_F,_A}, _From, #state{ profiling = true } = S) ->
+handle_call({profile_start, _Rootset, _Pattern, _MFA, _Opts}, _From, #state{ profiling = true } = S) ->
     {reply, {error, already_profiling}, S};
 
-handle_call({profile, Rootset, Pattern, M,F,A}, From, #state{fd = Fd } = S) ->
+handle_call({profile_start, Rootset, Pattern, {M,F,A}, Opts}, From, #state{fd = Fd } = S) ->
+
+    ok = set_pattern_trace(false, S#state.pattern),
+    _  = set_process_trace(false, S#state.rootset, S#state.trace_opts),
 
-    set_pattern_trace(false, S#state.pattern),
-    set_process_trace(false, S#state.rootset),
+    Topts = get_trace_options(Opts),
+    Pid   = setup_profiling(M,F,A),
 
-    Pid = setup_profiling(M,F,A),
-    case set_process_trace(true, [Pid|Rootset]) of
+    case set_process_trace(true, [Pid|Rootset], Topts) of
 	true ->
-	    set_pattern_trace(true, Pattern),
+	    ok = set_pattern_trace(true, Pattern),
 	    T0 = now(),
-	    execute_profiling(Pid),
+	    ok = execute_profiling(Pid),
 	    {noreply, #state{
-		    profiling = true,
-		    rootset   = [Pid|Rootset],
-		    start_ts  = T0,
-		    reply     = From,
-		    fd        = Fd,
-		    pattern   = Pattern
+		    profiling  = true,
+		    rootset    = [Pid|Rootset],
+		    start_ts   = T0,
+		    reply      = From,
+		    fd         = Fd,
+		    trace_opts = Topts,
+		    pattern    = Pattern
 		}};
 	false ->
 	    exit(Pid, eprof_kill),
 	    {reply, error, #state{ fd = Fd}}
     end;
 
-handle_call({profile, _Rootset, _Pattern}, _From, #state{ profiling = true } = S) ->
-    {reply, {error, already_profiling}, S};
-
-handle_call({profile, Rootset, Pattern}, From, #state{ fd = Fd } = S) ->
+handle_call({profile_start, Rootset, Pattern, undefined, Opts}, From, #state{ fd = Fd } = S) ->
 
-    set_pattern_trace(false, S#state.pattern),
-    set_process_trace(false, S#state.rootset),
+    ok    = set_pattern_trace(false, S#state.pattern),
+    true  = set_process_trace(false, S#state.rootset, S#state.trace_opts),
+    Topts = get_trace_options(Opts),
 
-    case set_process_trace(true, Rootset) of
+    case set_process_trace(true, Rootset, Topts) of
 	true ->
 	    T0 = now(),
-	    set_pattern_trace(true, Pattern),
+	    ok = set_pattern_trace(true, Pattern),
 	    {reply, profiling, #state{
-		    profiling = true,
-		    rootset   = Rootset,
-		    start_ts  = T0,
-		    reply     = From,
-		    fd        = Fd,
-		    pattern   = Pattern
+		    profiling  = true,
+		    rootset    = Rootset,
+		    start_ts   = T0,
+		    reply      = From,
+		    fd         = Fd,
+		    trace_opts = Topts,
+		    pattern    = Pattern
 		}};
 	false ->
 	    {reply, error, #state{ fd = Fd }}
     end;
 
-handle_call(stop_profiling, _From, #state{ profiling = false } = S) ->
+handle_call(profile_stop, _From, #state{ profiling = false } = S) ->
     {reply, profiling_already_stopped, S};
 
-handle_call(stop_profiling, _From, #state{ profiling = true } = S) ->
-
-    set_pattern_trace(pause, S#state.pattern),
+handle_call(profile_stop, _From, #state{ profiling = true } = S) ->
 
+    ok  = set_pattern_trace(pause, S#state.pattern),
     Bpd = collect_bpd(),
-
-    set_process_trace(false, S#state.rootset),
-    set_pattern_trace(false, S#state.pattern),
+    _   = set_process_trace(false, S#state.rootset, S#state.trace_opts),
+    ok  = set_pattern_trace(false, S#state.pattern),
 
     {reply, profiling_stopped, S#state{
-	profiling = false,
-	rootset   = [],
-	pattern   = {'_','_','_'},
-	bpd       = Bpd
+	profiling  = false,
+	rootset    = [],
+	trace_opts = [],
+	pattern    = ?default_pattern,
+	bpd        = Bpd
     }};
 
 %% logfile
@@ -261,33 +284,33 @@ handle_info({'EXIT', _, eprof_kill}, S) ->
     {noreply, S};
 handle_info({'EXIT', _, Reason}, #state{ reply = FromTag } = S) ->
 
-    set_process_trace(false, S#state.rootset),
-    set_pattern_trace(false, S#state.pattern),
+    _  = set_process_trace(false, S#state.rootset, S#state.trace_opts),
+    ok = set_pattern_trace(false, S#state.pattern),
 
     gen_server:reply(FromTag, {error, Reason}),
     {noreply, S#state{
-	profiling = false,
-	rootset   = [],
-	pattern   = {'_','_','_'}
+	profiling  = false,
+	rootset    = [],
+	trace_opts = [],
+	pattern    = ?default_pattern
     }};
 
 % check if Pid is spawned process?
 handle_info({_Pid, {answer, Result}}, #state{ reply = {From,_} = FromTag} = S) ->
 
-    set_pattern_trace(pause, S#state.pattern),
-
-    Bpd = collect_bpd(),
-
-    set_process_trace(false, S#state.rootset),
-    set_pattern_trace(false, S#state.pattern),
+    ok   = set_pattern_trace(pause, S#state.pattern),
+    Bpd  = collect_bpd(),
+    _    = set_process_trace(false, S#state.rootset, S#state.trace_opts),
+    ok   = set_pattern_trace(false, S#state.pattern),
 
     catch unlink(From),
     gen_server:reply(FromTag, {ok, Result}),
     {noreply, S#state{
-	profiling = false,
-	rootset   = [],
-	pattern   = {'_','_','_'},
-	bpd       = Bpd
+	profiling  = false,
+	rootset    = [],
+	trace_opts = [],
+	pattern    = ?default_pattern,
+	bpd        = Bpd
     }}.
 
 %% -------------------------------------------------------------------- %%
@@ -297,11 +320,11 @@ handle_info({_Pid, {answer, Result}}, #state{ reply = {From,_} = FromTag} = S) -
 %% -------------------------------------------------------------------- %%
 
 terminate(_Reason, #state{ fd = undefined }) ->
-    set_pattern_trace(false, {'_','_','_'}),
+    ok = set_pattern_trace(false, ?default_pattern),
     ok;
 terminate(_Reason, #state{ fd = Fd }) ->
-    file:close(Fd),
-    set_pattern_trace(false, {'_','_','_'}),
+    ok = file:close(Fd),
+    ok = set_pattern_trace(false, ?default_pattern),
     ok.
 
 %% -------------------------------------------------------------------- %%
@@ -330,7 +353,19 @@ spin_profile(M, F, A) ->
     end.
 
 execute_profiling(Pid) ->
-    Pid ! {self(), execute}.
+    Pid ! {self(), execute},
+    ok.
+
+
+get_trace_options([]) ->
+    [call];
+get_trace_options([{set_on_spawn, true}|Opts]) ->
+    [set_on_spawn | get_trace_options(Opts)];
+get_trace_options([set_on_spawn|Opts]) ->
+    [set_on_spawn | get_trace_options(Opts)];
+get_trace_options([_|Opts]) ->
+    get_trace_options(Opts).
+
 
 set_pattern_trace(Flag, Pattern) ->
     erlang:system_flag(multi_scheduling, block),
@@ -339,10 +374,6 @@ set_pattern_trace(Flag, Pattern) ->
     erlang:system_flag(multi_scheduling, unblock),
     ok.
 
-set_process_trace(Flag, Pids) ->
-    % do we need procs for meta info?
-    % could be useful
-    set_process_trace(Flag, Pids, [call, set_on_spawn]).
 set_process_trace(_, [], _) -> true;
 set_process_trace(Flag, [Pid|Pids], Options) when is_pid(Pid) ->
     try
diff --git a/lib/tools/test/eprof_SUITE.erl b/lib/tools/test/eprof_SUITE.erl
index 3283fa571f..148622cf07 100644
--- a/lib/tools/test/eprof_SUITE.erl
+++ b/lib/tools/test/eprof_SUITE.erl
@@ -21,12 +21,14 @@
 -include_lib("test_server/include/test_server.hrl").
 
 -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
-	 init_per_group/2,end_per_group/2,tiny/1,eed/1,basic/1]).
+	init_per_group/2,end_per_group/2]).
+
+-export([tiny/1,eed/1,basic/1,basic_option/1]).
 
 suite() -> [{ct_hooks,[ts_install_cth]}].
 
 all() -> 
-    [basic, tiny, eed].
+    [basic, basic_option, tiny, eed].
 
 groups() -> 
     [].
@@ -49,140 +51,185 @@ basic(Config) when is_list(Config) ->
 
     %% load eprof_test and change directory
 
-    ?line {ok, OldCurDir} = file:get_cwd(),
+    {ok, OldCurDir} = file:get_cwd(),
     Datadir = ?config(data_dir, Config),
     Privdir = ?config(priv_dir, Config),
-    ?line {ok,eprof_test} = compile:file(filename:join(Datadir, "eprof_test"),
+    {ok,eprof_test} = compile:file(filename:join(Datadir, "eprof_test"),
 					       [trace,{outdir, Privdir}]),
-    ?line ok = file:set_cwd(Privdir),
-    ?line code:purge(eprof_test),
-    ?line {module,eprof_test} = code:load_file(eprof_test),
+    ok = file:set_cwd(Privdir),
+    code:purge(eprof_test),
+    {module,eprof_test} = code:load_file(eprof_test),
 
     %% rootset profiling
 
-    ?line ensure_eprof_stopped(),
-    ?line profiling = eprof:profile([self()]),
-    ?line {error, already_profiling} = eprof:profile([self()]),
-    ?line profiling_stopped = eprof:stop_profiling(),
-    ?line profiling_already_stopped = eprof:stop_profiling(),
-    ?line profiling = eprof:start_profiling([self(),self(),self()]),
-    ?line profiling_stopped = eprof:stop_profiling(),
+    ensure_eprof_stopped(),
+    profiling = eprof:profile([self()]),
+    {error, already_profiling} = eprof:profile([self()]),
+    profiling_stopped = eprof:stop_profiling(),
+    profiling_already_stopped = eprof:stop_profiling(),
+    profiling = eprof:start_profiling([self(),self(),self()]),
+    profiling_stopped = eprof:stop_profiling(),
 
     %% with patterns
 
-    ?line profiling = eprof:start_profiling([self()], {?MODULE, '_', '_'}),
-    ?line {error, already_profiling} = eprof:start_profiling([self()], {?MODULE, '_', '_'}),
-    ?line profiling_stopped = eprof:stop_profiling(),
-    ?line profiling = eprof:start_profiling([self()], {?MODULE, start_stop, '_'}),
-    ?line profiling_stopped = eprof:stop_profiling(),
-    ?line profiling = eprof:start_profiling([self()], {?MODULE, start_stop, 1}),
-    ?line profiling_stopped = eprof:stop_profiling(),
+    profiling = eprof:start_profiling([self()], {?MODULE, '_', '_'}),
+    {error, already_profiling} = eprof:start_profiling([self()], {?MODULE, '_', '_'}),
+    profiling_stopped = eprof:stop_profiling(),
+    profiling = eprof:start_profiling([self()], {?MODULE, start_stop, '_'}),
+    profiling_stopped = eprof:stop_profiling(),
+    profiling = eprof:start_profiling([self()], {?MODULE, start_stop, 1}),
+    profiling_stopped = eprof:stop_profiling(),
 
     %% with fun
 
-    ?line {ok, _} = eprof:profile(fun() -> eprof_test:go(10) end),
-    ?line profiling = eprof:profile([self()]),
-    ?line {error, already_profiling} = eprof:profile(fun() -> eprof_test:go(10) end),
-    ?line profiling_stopped = eprof:stop_profiling(),
-    ?line {ok, _} = eprof:profile(fun() -> eprof_test:go(10) end),
-    ?line {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end),
-    ?line Pid     = whereis(eprof),
-    ?line {ok, _} = eprof:profile(erlang:processes() -- [Pid], fun() -> eprof_test:go(10) end),
-    ?line {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, '_', '_'}),
-    ?line {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, go, '_'}),
-    ?line {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, go, 1}),
-    ?line {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, dec, 1}),
+    {ok, _} = eprof:profile(fun() -> eprof_test:go(10) end),
+    profiling = eprof:profile([self()]),
+    {error, already_profiling} = eprof:profile(fun() -> eprof_test:go(10) end),
+    profiling_stopped = eprof:stop_profiling(),
+    {ok, _} = eprof:profile(fun() -> eprof_test:go(10) end),
+    {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end),
+    Pid     = whereis(eprof),
+    {ok, _} = eprof:profile(erlang:processes() -- [Pid], fun() -> eprof_test:go(10) end),
+    {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, '_', '_'}),
+    {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, go, '_'}),
+    {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, go, 1}),
+    {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, dec, 1}),
 
     %% error case
 
-    ?line error     = eprof:profile([Pid], fun() -> eprof_test:go(10) end),
-    ?line Pid       = whereis(eprof),
-    ?line error     = eprof:profile([Pid], fun() -> eprof_test:go(10) end),
-    ?line A         = spawn(fun() -> receive _ -> ok end end),
-    ?line profiling = eprof:profile([A]),
-    ?line true      = exit(A, kill_it),
-    ?line profiling_stopped = eprof:stop_profiling(),
-    ?line {error,_} = eprof:profile(fun() -> a = b end),
+    error     = eprof:profile([Pid], fun() -> eprof_test:go(10) end),
+    Pid       = whereis(eprof),
+    error     = eprof:profile([Pid], fun() -> eprof_test:go(10) end),
+    A         = spawn(fun() -> receive _ -> ok end end),
+    profiling = eprof:profile([A]),
+    true      = exit(A, kill_it),
+    profiling_stopped = eprof:stop_profiling(),
+    {error,_} = eprof:profile(fun() -> a = b end),
 
     %% with mfa
 
-    ?line {ok, _} = eprof:profile([], eprof_test, go, [10]),
-    ?line {ok, _} = eprof:profile([], eprof_test, go, [10], {eprof_test, dec, 1}),
+    {ok, _} = eprof:profile([], eprof_test, go, [10]),
+    {ok, _} = eprof:profile([], eprof_test, go, [10], {eprof_test, dec, 1}),
 
     %% dump
 
-    ?line {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, '_', '_'}),
-    ?line [{_, Mfas}] = eprof:dump(),
-    ?line Dec_mfa = {eprof_test, dec, 1},
-    ?line Go_mfa  = {eprof_test, go,  1},
-    ?line {value, {Go_mfa,  { 1, _Time1}}} = lists:keysearch(Go_mfa,  1, Mfas),
-    ?line {value, {Dec_mfa, {11, _Time2}}} = lists:keysearch(Dec_mfa, 1, Mfas),
+    {ok, _} = eprof:profile([], fun() -> eprof_test:go(10) end, {eprof_test, '_', '_'}),
+    [{_, Mfas}] = eprof:dump(),
+    Dec_mfa = {eprof_test, dec, 1},
+    Go_mfa  = {eprof_test, go,  1},
+    {value, {Go_mfa,  { 1, _Time1}}} = lists:keysearch(Go_mfa,  1, Mfas),
+    {value, {Dec_mfa, {11, _Time2}}} = lists:keysearch(Dec_mfa, 1, Mfas),
 
     %% change current working directory
 
-    ?line ok = file:set_cwd(OldCurDir),
-    ?line stopped = eprof:stop(),
+    ok = file:set_cwd(OldCurDir),
+    stopped = eprof:stop(),
+    ok.
+
+basic_option(Config) when is_list(Config) ->
+    %% load eprof_test and change directory
+
+    {ok, OldCurDir} = file:get_cwd(),
+    Datadir = ?config(data_dir, Config),
+    Privdir = ?config(priv_dir, Config),
+    {ok,eprof_test} = compile:file(filename:join(Datadir, "eprof_test"),
+					       [trace,{outdir, Privdir}]),
+    ok = file:set_cwd(Privdir),
+    code:purge(eprof_test),
+    {module,eprof_test} = code:load_file(eprof_test),
+
+    % vanilla
+    {ok, _} = eprof:profile(fun() -> eprof_test:do(10) end, [{set_on_spawn, true}]),
+
+    [{_, MfasDo1},{_, MfasLists1}] = eprof:dump(),
+    Mfas1 = MfasDo1 ++ MfasLists1,
+
+    {value, {_, {11, _}}} = lists:keysearch({eprof_test,dec,1},  1, Mfas1),
+    {value, {_, { 1, _}}} = lists:keysearch({eprof_test, go,1},  1, Mfas1),
+    {value, {_, { 9, _}}} = lists:keysearch({lists, split_2,5},  1, Mfas1),
+    {value, {_, { 4, _}}} = lists:keysearch({lists, seq_loop,3}, 1, Mfas1),
+
+    {ok, _} = eprof:profile(fun() -> eprof_test:do(10) end, [set_on_spawn]),
+
+    [{_, MfasDo2},{_, MfasLists2}] = eprof:dump(),
+    Mfas2 = MfasDo2 ++ MfasLists2,
+    {value, {_, {11, _}}} = lists:keysearch({eprof_test,dec,1},  1, Mfas2),
+    {value, {_, { 1, _}}} = lists:keysearch({eprof_test, go,1},  1, Mfas2),
+    {value, {_, { 9, _}}} = lists:keysearch({lists, split_2,5},  1, Mfas2),
+    {value, {_, { 4, _}}} = lists:keysearch({lists, seq_loop,3}, 1, Mfas2),
+
+    % disable trace set_on_spawn
+    {ok, _} = eprof:profile(fun() -> eprof_test:do(10) end, []),
+    [{_, Mfas3}] = eprof:dump(),
+    {value, {_, {11, _}}} = lists:keysearch({eprof_test,dec,1}, 1, Mfas3),
+    {value, {_, { 1, _}}} = lists:keysearch({eprof_test, go,1}, 1, Mfas3),
+    false = lists:keysearch({lists, split_2,5},  1, Mfas3),
+    false = lists:keysearch({lists, seq_loop,3}, 1, Mfas3),
+
+    %% change current working directory
+    ok = file:set_cwd(OldCurDir),
+    stopped = eprof:stop(),
     ok.
 
 tiny(suite) -> [];
 tiny(Config) when is_list(Config) -> 
-    ?line ensure_eprof_stopped(),
-    ?line {ok, OldCurDir} = file:get_cwd(),
+    ensure_eprof_stopped(),
+    {ok, OldCurDir} = file:get_cwd(),
     Datadir = ?config(data_dir, Config),
     Privdir = ?config(priv_dir, Config),
-    ?line TTrap=?t:timetrap(60*1000),
+    TTrap=?t:timetrap(60*1000),
     % (Trace)Compile to priv_dir and make sure the correct version is loaded.
-    ?line {ok,eprof_suite_test} = compile:file(filename:join(Datadir,
+    {ok,eprof_suite_test} = compile:file(filename:join(Datadir,
 							     "eprof_suite_test"),
 					       [trace,{outdir, Privdir}]),
-    ?line ok = file:set_cwd(Privdir),
-    ?line code:purge(eprof_suite_test),
-    ?line {module,eprof_suite_test} = code:load_file(eprof_suite_test),
-    ?line {ok,_Pid} = eprof:start(),
-    ?line nothing_to_analyze = eprof:analyze(),
-    ?line nothing_to_analyze = eprof:analyze(total),
-    ?line eprof:profile([], eprof_suite_test, test, [Config]),
-    ?line ok = eprof:analyze(),
-    ?line ok = eprof:analyze(total),
-    ?line ok = eprof:log("eprof_SUITE_logfile"),
-    ?line stopped = eprof:stop(),
-    ?line ?t:timetrap_cancel(TTrap),
-    ?line ok = file:set_cwd(OldCurDir),
+    ok = file:set_cwd(Privdir),
+    code:purge(eprof_suite_test),
+    {module,eprof_suite_test} = code:load_file(eprof_suite_test),
+    {ok,_Pid} = eprof:start(),
+    nothing_to_analyze = eprof:analyze(),
+    nothing_to_analyze = eprof:analyze(total),
+    eprof:profile([], eprof_suite_test, test, [Config]),
+    ok = eprof:analyze(),
+    ok = eprof:analyze(total),
+    ok = eprof:log("eprof_SUITE_logfile"),
+    stopped = eprof:stop(),
+    ?t:timetrap_cancel(TTrap),
+    ok = file:set_cwd(OldCurDir),
     ok.
 
 eed(suite) -> [];
 eed(Config) when is_list(Config) ->
-    ?line ensure_eprof_stopped(),
-    ?line Datadir = ?config(data_dir, Config),
-    ?line Privdir = ?config(priv_dir, Config),
-    ?line TTrap=?t:timetrap(5*60*1000),
+    ensure_eprof_stopped(),
+    Datadir = ?config(data_dir, Config),
+    Privdir = ?config(priv_dir, Config),
+    TTrap=?t:timetrap(5*60*1000),
 
     %% (Trace)Compile to priv_dir and make sure the correct version is loaded.
-    ?line code:purge(eed),
-    ?line {ok,eed} = c:c(filename:join(Datadir, "eed"), [trace,{outdir,Privdir}]),
-    ?line {ok,_Pid} = eprof:start(),
-    ?line Script = filename:join(Datadir, "ed.script"),
-    ?line ok = file:set_cwd(Datadir),
-    ?line {T1,_} = statistics(runtime),
-    ?line ok = eed:file(Script),
-    ?line ok = eed:file(Script),
-    ?line ok = eed:file(Script),
-    ?line ok = eed:file(Script),
-    ?line ok = eed:file(Script),
-    ?line ok = eed:file(Script),
-    ?line ok = eed:file(Script),
-    ?line ok = eed:file(Script),
-    ?line ok = eed:file(Script),
-    ?line ok = eed:file(Script),
-    ?line {T2,_} = statistics(runtime),
-    ?line {ok,ok} = eprof:profile([], eed, file, [Script]),
-    ?line {T3,_} = statistics(runtime),
-    ?line profiling_already_stopped = eprof:stop_profiling(),
-    ?line ok = eprof:analyze(),
-    ?line ok = eprof:analyze(total),
-    ?line ok = eprof:log("eprof_SUITE_logfile"),
-    ?line stopped = eprof:stop(),
-    ?line ?t:timetrap_cancel(TTrap),
+    code:purge(eed),
+    {ok,eed} = c:c(filename:join(Datadir, "eed"), [trace,{outdir,Privdir}]),
+    {ok,_Pid} = eprof:start(),
+    Script = filename:join(Datadir, "ed.script"),
+    ok = file:set_cwd(Datadir),
+    {T1,_} = statistics(runtime),
+    ok = eed:file(Script),
+    ok = eed:file(Script),
+    ok = eed:file(Script),
+    ok = eed:file(Script),
+    ok = eed:file(Script),
+    ok = eed:file(Script),
+    ok = eed:file(Script),
+    ok = eed:file(Script),
+    ok = eed:file(Script),
+    ok = eed:file(Script),
+    {T2,_} = statistics(runtime),
+    {ok,ok} = eprof:profile([], eed, file, [Script]),
+    {T3,_} = statistics(runtime),
+    profiling_already_stopped = eprof:stop_profiling(),
+    ok = eprof:analyze(),
+    ok = eprof:analyze(total),
+    ok = eprof:log("eprof_SUITE_logfile"),
+    stopped = eprof:stop(),
+    ?t:timetrap_cancel(TTrap),
     try
 	S = lists:flatten(io_lib:format("~p times slower",
 					[10*(T3-T2)/(T2-T1)])),
@@ -198,5 +245,5 @@ ensure_eprof_stopped() ->
 	undefined ->
 	    ok;
 	Pid ->
-	    ?line stopped=eprof:stop()
+	    stopped=eprof:stop()
     end.
diff --git a/lib/tools/test/eprof_SUITE_data/eprof_test.erl b/lib/tools/test/eprof_SUITE_data/eprof_test.erl
index 33c428e893..2d9e4c2945 100644
--- a/lib/tools/test/eprof_SUITE_data/eprof_test.erl
+++ b/lib/tools/test/eprof_SUITE_data/eprof_test.erl
@@ -1,5 +1,5 @@
 -module(eprof_test).
--export([go/1]).
+-export([go/1, do/1]).
 
 go(N) ->
     0 = dec(N),
@@ -7,3 +7,16 @@ go(N) ->
 
 dec(0) -> 0;
 dec(N) -> dec(N - 1).
+
+
+
+load(N, Pid) ->
+    _ = lists:sort(lists:reverse(lists:seq(1, N))),
+    Pid ! {self(), ok}.
+
+
+do(N) ->
+    Me  = self(),
+    Pid = spawn_link(fun() -> load(N, Me) end),
+    ok  = go(N),
+    receive {Pid, ok} -> ok end.