Optimize memory allocation

A number of memory allocation optimizations have been implemented. Most
optimizations reduce contention caused by synchronization between
threads during allocation and deallocation of memory. Most notably:
* Synchronization of memory management in scheduler specific allocator
  instances has been rewritten to use lock-free synchronization.
* Synchronization of memory management in scheduler specific
  pre-allocators has been rewritten to use lock-free synchronization.
* The 'mseg_alloc' memory segment allocator now use scheduler specific
  instances instead of one instance. Apart from reducing contention
  this also ensures that memory allocators always create memory
  segments on the local NUMA node on a NUMA system.

3 files changed, 132 insertions, 118 deletions

diff --git a/lib/runtime_tools/src/erts_alloc_config.erl b/lib/runtime_tools/src/erts_alloc_config.erl
index 0bcb202fd8..1a57c94443 100644
--- a/lib/runtime_tools/src/erts_alloc_config.erl
+++ b/lib/runtime_tools/src/erts_alloc_config.erl
@@ -1,6 +1,7 @@
+%%
 %% %CopyrightBegin%
 %% 
-%% Copyright Ericsson AB 2007-2009. All Rights Reserved.
+%% Copyright Ericsson AB 2007-2010. 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
@@ -16,6 +17,7 @@
 %% The Initial Developer of the Original Code is Ericsson AB.
 %% 
 %% %CopyrightEnd%
+%%
 
 %%%-------------------------------------------------------------------
 %%% File    : erts_alloc_config.erl
@@ -71,6 +73,7 @@
 	A == binary_alloc;
 	A == std_alloc;
 	A == ets_alloc;
+	A == fix_alloc;
 	A == eheap_alloc;
 	A == ll_alloc;
 	A == sl_alloc;
@@ -94,6 +97,7 @@
 	[{binary_alloc, 131072},
 	 {std_alloc, 131072},
 	 {ets_alloc, 131072},
+	 {fix_alloc, 131072},
 	 {eheap_alloc, 524288},
 	 {ll_alloc, 2097152},
 	 {sl_alloc, 131072},
@@ -104,6 +108,7 @@
 	[{binary_alloc, 10},
 	 {std_alloc, 10},
 	 {ets_alloc, 10},
+	 {fix_alloc, 10},
 	 {eheap_alloc, 10},
 	 {ll_alloc, 0},
 	 {sl_alloc, 10},
@@ -438,9 +443,6 @@ conf_alloc(#conf{format_to = FTO} = Conf, #alloc{name = A} = Alc) ->
     chk_xnote(Conf, Alc).
 
 chk_xnote(#conf{format_to = FTO},
-	  #alloc{name = fix_alloc}) ->
-    fcp(FTO, "Cannot be configured.");
-chk_xnote(#conf{format_to = FTO},
 	  #alloc{name = sys_alloc}) ->
     fcp(FTO, "Cannot be configured. Default malloc implementation used.");
 chk_xnote(#conf{format_to = FTO},
diff --git a/lib/stdlib/test/ets_SUITE.erl b/lib/stdlib/test/ets_SUITE.erl
index 57df963ae2..e2f22cfbc9 100644
--- a/lib/stdlib/test/ets_SUITE.erl
+++ b/lib/stdlib/test/ets_SUITE.erl
@@ -74,7 +74,7 @@
 -export([bad_table/1, types/1]).
 -export([otp_9423/1]).
 
--export([init_per_testcase/2, end_per_testcase/2]).
+-export([init_per_testcase/2]).
 %% Convenience for manual testing
 -export([random_test/0]).
 
@@ -176,6 +176,7 @@ groups() ->
        meta_newdel_unnamed, meta_newdel_named]}].
 
 init_per_suite(Config) ->
+    erts_debug:set_internal_state(available_internal_state, true),
     Config.
 
 end_per_suite(_Config) ->
@@ -304,7 +305,6 @@ t_match_spec_run(Config) when is_list(Config) ->
 		      end,
 		  repeat_for_permutations(F, N_MS)
 	  end,
-
     test_terms(Fun, skip_refc_check),
 
     ?line verify_etsmem(EtsMem).
@@ -324,7 +324,7 @@ t_match_spec_run_test(List, MS, Result) ->
 
     %% Check that tracing agree
     Self = self(),
-    {Tracee, MonRef} = spawn_monitor(fun() -> ms_tracee(Self, List) end),
+    {Tracee, MonRef} = my_spawn_monitor(fun() -> ms_tracee(Self, List) end),
     receive {Tracee, ready} -> ok end,
 
     MST = lists:map(fun(Clause) -> ms_clause_ets_to_trace(Clause) end, MS),
@@ -585,7 +585,6 @@ select_fail_do(Opts) ->
 memory(doc) -> ["Whitebox test of ets:info(X,memory)"];
 memory(suite) -> [];
 memory(Config) when is_list(Config) ->
-    ?line erts_debug:set_internal_state(available_internal_state, true),
     ?line ok = chk_normal_tab_struct_size(),
     repeat_for_opts(memory_do,[compressed]),
     ?line catch erts_debug:set_internal_state(available_internal_state, false).
@@ -1942,7 +1941,7 @@ evil_update_counter(Config) when is_list(Config) ->
 evil_update_counter_do(Opts) ->
     ?line EtsMem = etsmem(),
     ?line process_flag(trap_exit, true),
-    ?line Pids = [spawn_link(fun() -> evil_counter(I,Opts) end)  || I <- lists:seq(1, 40)],
+    ?line Pids = [my_spawn_link(fun() -> evil_counter(I,Opts) end)  || I <- lists:seq(1, 40)],
     ?line wait_for_all(gb_sets:from_list(Pids)),
     ?line verify_etsmem(EtsMem),
     ok.
@@ -2148,24 +2147,24 @@ heir_do(Opts) ->
 			Combos),    			
 			 
     %% No heir
-    {Founder1,MrefF1} = spawn_monitor(fun()->heir_founder(Master,foo_data,Opts)end),
+    {Founder1,MrefF1} = my_spawn_monitor(fun()->heir_founder(Master,foo_data,Opts)end),
     Founder1 ! {go, none},
     ?line {"No heir",Founder1} = receive_any(),
     ?line {'DOWN', MrefF1, process, Founder1, normal} = receive_any(),
     ?line undefined = ets:info(foo),
 
     %% An already dead heir
-    {Heir2,MrefH2} = spawn_monitor(fun()->die end),
+    {Heir2,MrefH2} = my_spawn_monitor(fun()->die end),
     ?line {'DOWN', MrefH2, process, Heir2, normal} = receive_any(),
-    {Founder2,MrefF2} = spawn_monitor(fun()->heir_founder(Master,foo_data,Opts)end),
+    {Founder2,MrefF2} = my_spawn_monitor(fun()->heir_founder(Master,foo_data,Opts)end),
     Founder2 ! {go, Heir2},
     ?line {"No heir",Founder2} = receive_any(),
     ?line {'DOWN', MrefF2, process, Founder2, normal} = receive_any(),
     ?line undefined = ets:info(foo),
 
     %% When heir dies before founder
-    {Founder3,MrefF3} = spawn_monitor(fun()->heir_founder(Master,"The dying heir",Opts)end),
-    {Heir3,MrefH3} = spawn_monitor(fun()->heir_heir(Founder3)end),
+    {Founder3,MrefF3} = my_spawn_monitor(fun()->heir_founder(Master,"The dying heir",Opts)end),
+    {Heir3,MrefH3} = my_spawn_monitor(fun()->heir_heir(Founder3)end),
     Founder3 ! {go, Heir3},
     ?line {'DOWN', MrefH3, process, Heir3, normal} = receive_any(),
     Founder3 ! die_please,
@@ -2173,14 +2172,12 @@ heir_do(Opts) ->
     ?line undefined = ets:info(foo),
 
     %% When heir dies and pid reused before founder dies
-    erts_debug:set_internal_state(available_internal_state,true),
     NextPidIx = erts_debug:get_internal_state(next_pid),
-    {Founder4,MrefF4} = spawn_monitor(fun()->heir_founder(Master,"The dying heir",Opts)end),
-    {Heir4,MrefH4} = spawn_monitor(fun()->heir_heir(Founder4)end),
+    {Founder4,MrefF4} = my_spawn_monitor(fun()->heir_founder(Master,"The dying heir",Opts)end),
+    {Heir4,MrefH4} = my_spawn_monitor(fun()->heir_heir(Founder4)end),
     Founder4 ! {go, Heir4},
     ?line {'DOWN', MrefH4, process, Heir4, normal} = receive_any(),
     erts_debug:set_internal_state(next_pid, NextPidIx),
-    erts_debug:set_internal_state(available_internal_state,false),
     {Heir4,MrefH4_B} = spawn_monitor_with_pid(Heir4, 
 					      fun()-> ?line die_please = receive_any() end),
     Founder4 ! die_please,
@@ -2256,9 +2253,9 @@ heir_heir(Founder, Mode) ->
 heir_1(HeirData,Mode,Opts) ->
     io:format("test with heir_data = ~p\n", [HeirData]),
     Master = self(),
-    ?line Founder = spawn_link(fun() -> heir_founder(Master,HeirData,Opts) end),
+    ?line Founder = my_spawn_link(fun() -> heir_founder(Master,HeirData,Opts) end),
     io:format("founder spawned = ~p\n", [Founder]),
-    ?line {Heir,Mref} = spawn_monitor(fun() -> heir_heir(Founder,Mode) end),
+    ?line {Heir,Mref} = my_spawn_monitor(fun() -> heir_heir(Founder,Mode) end),
     io:format("heir spawned = ~p\n", [{Heir,Mref}]),
     ?line Founder ! {go, Heir},
     ?line {'DOWN', Mref, process, Heir, normal} = receive_any().
@@ -2275,7 +2272,7 @@ give_away_do(Opts) ->
     Parent = self(),
 
     %% Give and then give back
-    ?line {Receiver,Mref} = spawn_monitor(fun()-> give_away_receiver(T,Parent) end),
+    ?line {Receiver,Mref} = my_spawn_monitor(fun()-> give_away_receiver(T,Parent) end),
     ?line give_me = receive_any(),
     ?line true = ets:give_away(T,Receiver,here_you_are),
     ?line {'EXIT',{badarg,_}} = (catch ets:lookup(T,key)),
@@ -2286,7 +2283,7 @@ give_away_do(Opts) ->
 
     %% Give and then let receiver keep it
     ?line true = ets:insert(T,{key,1}),
-    ?line {Receiver3,Mref3} = spawn_monitor(fun()-> give_away_receiver(T,Parent) end),
+    ?line {Receiver3,Mref3} = my_spawn_monitor(fun()-> give_away_receiver(T,Parent) end),
     ?line give_me = receive_any(),
     ?line true = ets:give_away(T,Receiver3,here_you_are),
     ?line {'EXIT',{badarg,_}} = (catch ets:lookup(T,key)),
@@ -2298,7 +2295,7 @@ give_away_do(Opts) ->
     ?line T2 = ets_new(foo,[private | Opts]),
     ?line true = ets:insert(T2,{key,1}),
     ?line ets:setopts(T2,{heir,self(),"Som en gummiboll..."}),
-    ?line {Receiver2,Mref2} = spawn_monitor(fun()-> give_away_receiver(T2,Parent) end),
+    ?line {Receiver2,Mref2} = my_spawn_monitor(fun()-> give_away_receiver(T2,Parent) end),
     ?line give_me = receive_any(),
     ?line true = ets:give_away(T2,Receiver2,here_you_are),
     ?line {'EXIT',{badarg,_}} = (catch ets:lookup(T2,key)),
@@ -2313,12 +2310,12 @@ give_away_do(Opts) ->
     ?line {'EXIT',{badarg,_}} = (catch ets:give_away(T2,"not a pid","To wrong type")),
 
     ?line true = ets:delete(T2),
-    ?line {ReceiverNeg,MrefNeg} = spawn_monitor(fun()-> give_away_receiver(T2,Parent) end),
+    ?line {ReceiverNeg,MrefNeg} = my_spawn_monitor(fun()-> give_away_receiver(T2,Parent) end),
     ?line give_me = receive_any(),
     ?line {'EXIT',{badarg,_}} = (catch ets:give_away(T2,ReceiverNeg,"A deleted table")),
 
     ?line T3 = ets_new(foo,[public | Opts]),
-    spawn_link(fun()-> {'EXIT',{badarg,_}} = (catch ets:give_away(T3,ReceiverNeg,"From non owner")),
+    my_spawn_link(fun()-> {'EXIT',{badarg,_}} = (catch ets:give_away(T3,ReceiverNeg,"From non owner")),
 		       Parent ! done
 	       end),
     ?line done = receive_any(),
@@ -2354,7 +2351,7 @@ setopts_do(Opts) ->
     Self = self(),
     ?line T = ets_new(foo,[named_table, private | Opts]),
     ?line none = ets:info(T,heir),
-    Heir = spawn_link(fun()->heir_heir(Self) end),
+    Heir = my_spawn_link(fun()->heir_heir(Self) end),
     ?line ets:setopts(T,{heir,Heir,"Data"}),
     ?line Heir = ets:info(T,heir),
     ?line ets:setopts(T,{heir,self(),"Data"}),
@@ -2405,14 +2402,14 @@ bad_table(Config) when is_list(Config) ->
 
 bad_table_do(Opts, DummyFile) ->
     Parent = self(),    
-    {Pid,Mref} = spawn_opt(fun()-> ets_new(priv,[private,named_table | Opts]),
-				   Priv = ets_new(priv,[private | Opts]),
-				   ets_new(prot,[protected,named_table | Opts]),
-				   Prot = ets_new(prot,[protected | Opts]),
-				   Parent ! {self(),Priv,Prot},
-				   die_please = receive_any()
-			   end,
-			   [link, monitor]),
+    {Pid,Mref} = my_spawn_opt(fun()-> ets_new(priv,[private,named_table | Opts]),
+				      Priv = ets_new(priv,[private | Opts]),
+				      ets_new(prot,[protected,named_table | Opts]),
+				      Prot = ets_new(prot,[protected | Opts]),
+				      Parent ! {self(),Priv,Prot},
+				      die_please = receive_any()
+			      end,
+			      [link, monitor]),
     {Pid,Priv,Prot} = receive_any(),
     MatchSpec = {{key,'_'}, [], ['$$']},
     Fun = fun(X,_) -> X end,
@@ -3258,7 +3255,7 @@ delete_large_named_table_1(Name, Flags, Data, Fix) ->
 	    ?line lists:foreach(fun({K,_}) -> ets:delete(Tab, K) end, Data)
     end,
     Parent = self(),
-    Pid = spawn_link(fun() ->
+    Pid = my_spawn_link(fun() ->
 			     receive
 				 {trace,Parent,call,_} ->
 				     ets_new(Name, [named_table])
@@ -3620,7 +3617,7 @@ cycle(Tab, L) ->
     ets:insert(Tab,list_to_tuple(L)),
     cycle(Tab, tl(L)++[hd(L)]).
 
-dynamic_go() -> spawn_link(fun dynamic_init/0).
+dynamic_go() -> my_spawn_link(fun dynamic_init/0).
 
 dynamic_init() -> [dyn_lookup(?MODULE) || _ <- lists:seq(1, 10)].
 
@@ -3847,7 +3844,7 @@ safe_fixtable_do(Opts) ->
     Self = self(),
     ?line {{_,_,_},[{Self,1}]} = ets:info(Tab,safe_fixed),
     %% Test that an unjustified 'unfix' is a no-op.
-    {Pid,MRef} = spawn_monitor(fun() -> true = ets:safe_fixtable(Tab,false) end),
+    {Pid,MRef} = my_spawn_monitor(fun() -> true = ets:safe_fixtable(Tab,false) end),
     {'DOWN', MRef, process, Pid, normal} = receive M -> M end,
     ?line true = ets:info(Tab,fixed),
     ?line {{_,_,_},[{Self,1}]} = ets:info(Tab,safe_fixed),
@@ -4251,7 +4248,7 @@ do_heavy_concurrent(Opts) ->
     ?line ok = fill_tab2(Tab, 0, Size),
     ?line Procs = lists:map(
 		    fun (N) ->
-			    spawn_link(
+			    my_spawn_link(
 			      fun () ->
 				      do_heavy_concurrent_proc(Tab, Size, N)
 			      end)
@@ -4855,12 +4852,7 @@ otp_7665_act(Tab,Min,Max,DelNr) ->
 %% Whitebox testing of meta name table hashing.
 meta_wb(Config) when is_list(Config) ->
     ?line EtsMem = etsmem(),
-    ?line erts_debug:set_internal_state(available_internal_state, true),
-    try
-	repeat_for_opts(meta_wb_do)
-    after
-	erts_debug:set_internal_state(available_internal_state, false)
-    end,
+    repeat_for_opts(meta_wb_do),
     ?line verify_etsmem(EtsMem).
 
 
@@ -4929,12 +4921,15 @@ colliding_names(Name) ->
 
 grow_shrink(Config) when is_list(Config) ->
     ?line EtsMem = etsmem(),
-    grow_shrink_0(lists:seq(3071, 5000), EtsMem).
+    ?line grow_shrink_0(lists:seq(3071, 5000), EtsMem),
+    ?line verify_etsmem(EtsMem).
 
 grow_shrink_0([N|Ns], EtsMem) ->
     ?line grow_shrink_1(N, [set]),
     ?line grow_shrink_1(N, [ordered_set]),
-    ?line verify_etsmem(EtsMem),
+    %% Verifying ets-memory here takes too long time, since
+    %% lock-free allocators were introduced...
+    %% ?line verify_etsmem(EtsMem),
     grow_shrink_0(Ns, EtsMem);
 grow_shrink_0([], _) -> ok.
 
@@ -4981,13 +4976,13 @@ grow_pseudo_deleted_do(Type) ->
     ?line Left = ets:info(T,size),
     ?line Mult = get_kept_objects(T),
     filltabstr(T,Mult),
-    spawn_opt(fun()-> ?line true = ets:info(T,fixed),
-		       Self ! start,
-		       io:format("Starting to filltabstr... ~p\n",[now()]),
-		       filltabstr(T,Mult,Mult+10000),
-		       io:format("Done with filltabstr. ~p\n",[now()]),
-		       Self ! done 
-	       end, [link, {scheduler,2}]),
+    my_spawn_opt(fun()-> ?line true = ets:info(T,fixed),
+			 Self ! start,
+			 io:format("Starting to filltabstr... ~p\n",[now()]),
+			 filltabstr(T,Mult,Mult+10000),
+			 io:format("Done with filltabstr. ~p\n",[now()]),
+			 Self ! done 
+		 end, [link, {scheduler,2}]),
     ?line start = receive_any(),
     io:format("Unfixing table...~p nitems=~p\n",[now(),ets:info(T,size)]),
     ?line true = ets:safe_fixtable(T,false),
@@ -5021,13 +5016,13 @@ shrink_pseudo_deleted_do(Type) ->
 				     [true]}]),    
     ?line Half = ets:info(T,size),
     ?line Half = get_kept_objects(T),
-    spawn_opt(fun()-> ?line true = ets:info(T,fixed),
-		      Self ! start,
-		      io:format("Starting to delete... ~p\n",[now()]),
-		      del_one_by_one_set(T,1,Half+1),
-		      io:format("Done with delete. ~p\n",[now()]),
-		      Self ! done 
-	      end, [link, {scheduler,2}]),
+    my_spawn_opt(fun()-> ?line true = ets:info(T,fixed),
+			 Self ! start,
+			 io:format("Starting to delete... ~p\n",[now()]),
+			 del_one_by_one_set(T,1,Half+1),
+			 io:format("Done with delete. ~p\n",[now()]),
+			 Self ! done 
+		 end, [link, {scheduler,2}]),
     ?line start = receive_any(),
     io:format("Unfixing table...~p nitems=~p\n",[now(),ets:info(T,size)]),
     ?line true = ets:safe_fixtable(T,false),
@@ -5184,24 +5179,24 @@ smp_unfix_fix_do() ->
     ?line Deleted = get_kept_objects(T),
     
     {Child, Mref} = 
-	spawn_opt(fun()-> ?line true = ets:info(T,fixed),
-			  Parent ! start,
-			  io:format("Child waiting for table to be unfixed... now=~p mem=~p\n",
-				    [now(),ets:info(T,memory)]),
-			  repeat_while(fun()-> ets:info(T,fixed) end),
-			  io:format("Table unfixed. Child Fixating! now=~p mem=~p\n",
-				    [now(),ets:info(T,memory)]),    
-			  ?line true = ets:safe_fixtable(T,true),
-			  repeat_while(fun(Key) when Key =< NumOfObjs -> 
-					       ets:delete(T,Key), {true,Key+1};
-					  (Key) -> {false,Key}
-				       end,
-				       Deleted),
-			  ?line 0 = ets:info(T,size),
-			  ?line true = get_kept_objects(T) >= Left,		      
-			  ?line done = receive_any()
-		  end, 
-		  [link, monitor, {scheduler,2}]),
+      my_spawn_opt(fun()-> ?line true = ets:info(T,fixed),
+			   Parent ! start,
+			   io:format("Child waiting for table to be unfixed... now=~p mem=~p\n",
+				     [now(),ets:info(T,memory)]),
+			   repeat_while(fun()-> ets:info(T,fixed) end),
+			   io:format("Table unfixed. Child Fixating! now=~p mem=~p\n",
+				     [now(),ets:info(T,memory)]),    
+			   ?line true = ets:safe_fixtable(T,true),
+			   repeat_while(fun(Key) when Key =< NumOfObjs -> 
+						ets:delete(T,Key), {true,Key+1};
+					   (Key) -> {false,Key}
+					end,
+					Deleted),
+			   ?line 0 = ets:info(T,size),
+			   ?line true = get_kept_objects(T) >= Left,		      
+			   ?line done = receive_any()
+		   end, 
+		   [link, monitor, {scheduler,2}]),
     
     ?line start = receive_any(),        
     ?line true = ets:info(T,fixed),
@@ -5232,11 +5227,11 @@ otp_8166_do(WC) ->
     Deleted = NumOfObjs div 2,
     filltabint(T,NumOfObjs),
     {ReaderPid, ReaderMref} = 
- 	spawn_opt(fun()-> otp_8166_reader(T,NumOfObjs) end, 
- 		  [link, monitor, {scheduler,2}]),
+ 	my_spawn_opt(fun()-> otp_8166_reader(T,NumOfObjs) end, 
+		     [link, monitor, {scheduler,2}]),
     {ZombieCrPid, ZombieCrMref} = 
- 	spawn_opt(fun()-> otp_8166_zombie_creator(T,Deleted) end, 
- 		  [link, monitor, {scheduler,3}]),
+ 	my_spawn_opt(fun()-> otp_8166_zombie_creator(T,Deleted) end, 
+		     [link, monitor, {scheduler,3}]),
 
     repeat(fun() -> ZombieCrPid ! {loop, self()},
 		    zombies_created = receive_any(),
@@ -5496,7 +5491,7 @@ run_workers_do(InitF,ExecF,FiniF,Laps, Exclude) ->
     io:format("smp starting ~p workers\n",[NumOfProcs]),
     Seeds = [{ProcN,random:uniform(9999)} || ProcN <- lists:seq(1,NumOfProcs)],
     Parent = self(),
-    Pids = [spawn_link(fun()-> worker(Seed,InitF,ExecF,FiniF,Laps,Parent,NumOfProcs) end)
+    Pids = [my_spawn_link(fun()-> worker(Seed,InitF,ExecF,FiniF,Laps,Parent,NumOfProcs) end)
 	    || Seed <- Seeds],
     case Laps of
 	infinite -> Pids;
@@ -5545,31 +5540,30 @@ my_tab_to_list(_Ts,'$end_of_table', Acc) -> lists:reverse(Acc);
 my_tab_to_list(Ts,Key, Acc) ->
     my_tab_to_list(Ts,ets:next(Ts,Key),[ets:lookup(Ts, Key)| Acc]).
 
-wait_for_all_schedulers_online_to_execute() ->
-    PMs = lists:map(fun (Sched) ->
-			    spawn_opt(fun () -> ok end,
-				      [monitor, {scheduler, Sched}])
-		    end,
-		    lists:seq(1,erlang:system_info(schedulers_online))),
-    lists:foreach(fun ({P, M}) ->
-			  receive
-			      {'DOWN', M, process, P, _} -> ok
-			  end
-		  end,
-		  PMs),
-    ok.
+
+wait_for_memory_deallocations() ->
+    try
+	erts_debug:set_internal_state(wait, deallocations)
+    catch
+	error:undef ->
+	    erts_debug:set_internal_state(available_internal_state, true),
+	    wait_for_memory_deallocations()
+    end.
+	    
 
 etsmem() ->
-    %% Wait until it is guaranteed that all already scheduled
-    %% deallocations of DbTable structures have completed.
-    wait_for_all_schedulers_online_to_execute(),
+    wait_for_memory_deallocations(),
 
     AllTabs = lists:map(fun(T) -> {T,ets:info(T,name),ets:info(T,size),
 				   ets:info(T,memory),ets:info(T,type)} 
 			end, ets:all()),
+
+    EtsAllocInfo = erlang:system_info({allocator,ets_alloc}),
+    ErlangMemoryEts = try erlang:memory(ets) catch error:notsup -> notsup end,
+
     Mem =
-    {try erlang:memory(ets) catch error:notsup -> notsup end,
-     case erlang:system_info({allocator,ets_alloc}) of
+    {ErlangMemoryEts,
+     case EtsAllocInfo of
 	 false -> undefined;
 	 MemInfo ->
 	     CS = lists:foldl(
@@ -5646,6 +5640,7 @@ spawn_logger(Procs) ->
 					      true -> exit(Proc, kill);
 					      _ -> ok
 					  end,
+					  erlang:display(process_info(Proc)),
 					  receive
 					      {'DOWN', Mon, _, _, _} ->
 						  ok
@@ -5681,7 +5676,7 @@ wait_for_test_procs(Kill) ->
     ets_test_spawn_logger ! {sync_test_procs, Kill, self()},
     receive test_procs_synced -> ok end.
 
-log_test_proc(Proc) ->
+log_test_proc(Proc) when is_pid(Proc) ->
     ets_test_spawn_logger ! {new_test_proc, Proc},
     Proc.
 
@@ -5693,9 +5688,17 @@ my_spawn_link(Fun) -> log_test_proc(spawn_link(Fun)).
 my_spawn_link(M,F,A) -> log_test_proc(spawn_link(M,F,A)).
 %%my_spawn_link(N,M,F,A) -> log_test_proc(spawn_link(N,M,F,A)).
 
-my_spawn_opt(Fun,Opts) -> log_test_proc(spawn_opt(Fun,Opts)).
-%%my_spawn_opt(M,F,A,Opts) -> log_test_proc(spawn_opt(M,F,A,Opts)).
-%%my_spawn_opt(N,M,F,A,Opts) -> log_test_proc(spawn_opt(N,M,F,A,Opts)).
+my_spawn_opt(Fun,Opts) ->
+    case spawn_opt(Fun,Opts) of
+	Pid when is_pid(Pid) -> log_test_proc(Pid);
+	{Pid, _} = Res when is_pid(Pid) -> log_test_proc(Pid), Res
+    end.
+
+my_spawn_monitor(Fun) ->
+    Res = spawn_monitor(Fun),
+    {Pid, _} = Res,
+    log_test_proc(Pid),
+    Res.
 
 repeat(_Fun, 0) ->
     ok;
@@ -5758,11 +5761,11 @@ spawn_monitor_with_pid(Pid, Fun, N, M) when N > M*10 ->
     spawn_monitor_with_pid(Pid, Fun, N, M*10);
 spawn_monitor_with_pid(Pid, Fun, N, M) ->
     ?line false = is_process_alive(Pid),
-    case spawn(fun()-> case self() of
-			  Pid -> Fun();
-			  _ -> die
-		       end
-	       end) of
+    case my_spawn(fun()-> case self() of
+			      Pid -> Fun();
+			      _ -> die
+			  end
+		  end) of
 	Pid ->	    
 	    {Pid, erlang:monitor(process, Pid)};
 	Other ->
diff --git a/lib/stdlib/test/supervisor_SUITE.erl b/lib/stdlib/test/supervisor_SUITE.erl
index b48450c151..fce89e2185 100644
--- a/lib/stdlib/test/supervisor_SUITE.erl
+++ b/lib/stdlib/test/supervisor_SUITE.erl
@@ -115,7 +115,9 @@ end_per_group(_GroupName, Config) ->
 
 init_per_testcase(count_children_memory, Config) ->
     try erlang:memory() of
-	_ -> Config
+	_ ->
+	    erts_debug:set_internal_state(available_internal_state, true),
+	    Config
     catch error:notsup ->
 	    {skip, "+Meamin used during test; erlang:memory/1 not available"}
     end;
@@ -123,6 +125,9 @@ init_per_testcase(_Case, Config) ->
     erlang:display(_Case),
     Config.
 
+end_per_testcase(count_children_memory, _Config) ->
+    catch erts_debug:set_internal_state(available_internal_state, false),
+    ok;
 end_per_testcase(_Case, _Config) ->
     ok.
 
@@ -1018,25 +1023,25 @@ count_children_memory(Config) when is_list(Config) ->
     [supervisor:start_child(sup_test, []) || _Ignore <- lists:seq(1,1000)],
 
     garbage_collect(),
-    _Size1 = erlang:memory(processes_used),
+    _Size1 = proc_memory(),
     Children = supervisor:which_children(sup_test),
-    _Size2 = erlang:memory(processes_used),
+    _Size2 = proc_memory(),
     ChildCount = get_child_counts(sup_test),
-    _Size3 = erlang:memory(processes_used),
+    _Size3 = proc_memory(),
 
     [supervisor:start_child(sup_test, []) || _Ignore2 <- lists:seq(1,1000)],
 
     garbage_collect(),
     Children2 = supervisor:which_children(sup_test),
-    Size4 = erlang:memory(processes_used),
+    Size4 = proc_memory(),
     ChildCount2 = get_child_counts(sup_test),
-    Size5 = erlang:memory(processes_used),
+    Size5 = proc_memory(),
 
     garbage_collect(),
     Children3 = supervisor:which_children(sup_test),
-    Size6 = erlang:memory(processes_used),
+    Size6 = proc_memory(),
     ChildCount3 = get_child_counts(sup_test),
-    Size7 = erlang:memory(processes_used),
+    Size7 = proc_memory(),
 
     1000 = length(Children),
     [1,1000,0,1000] = ChildCount,
@@ -1062,6 +1067,10 @@ count_children_memory(Config) when is_list(Config) ->
     [terminate(SupPid, Pid, child, kill) || {undefined, Pid, worker, _Modules} <- Children3],
     [1,0,0,0] = get_child_counts(sup_test).
 
+proc_memory() ->
+    erts_debug:set_internal_state(wait, deallocations),
+    erlang:memory(processes_used).
+
 %%-------------------------------------------------------------------------
 do_not_save_start_parameters_for_temporary_children(doc) ->
     ["Temporary children shall not be restarted so they should not "