Remove ad-hoc memory use calculations in tests

4 files changed, 89 insertions, 54 deletions

diff --git a/erts/emulator/test/driver_SUITE.erl b/erts/emulator/test/driver_SUITE.erl
index 7aff3a6ea1..bb76e6f24b 100644
--- a/erts/emulator/test/driver_SUITE.erl
+++ b/erts/emulator/test/driver_SUITE.erl
@@ -2643,24 +2643,7 @@ wait_deallocations() ->
 
 driver_alloc_size() ->
     wait_deallocations(),
-    case erlang:system_info({allocator_sizes, driver_alloc}) of
-        false ->
-            undefined;
-        MemInfo ->
-            CS = lists:foldl(
-                   fun ({instance, _, L}, Acc) ->
-                           {value,{_,MBCS}} = lists:keysearch(mbcs, 1, L),
-                           {value,{_,SBCS}} = lists:keysearch(sbcs, 1, L),
-                           [MBCS,SBCS | Acc]
-                   end,
-                   [],
-                   MemInfo),
-            lists:foldl(
-              fun(L, Sz0) ->
-                      {value,{_,Sz,_,_}} = lists:keysearch(blocks_size, 1, L),
-                      Sz0+Sz
-              end, 0, CS)
-    end.
+    erts_debug:alloc_blocks_size(driver_alloc).
 
 rpc(Config, Fun) ->
     case proplists:get_value(node, Config) of
diff --git a/erts/emulator/test/erts_debug_SUITE.erl b/erts/emulator/test/erts_debug_SUITE.erl
index 6aa7a445b5..f39dbedd8f 100644
--- a/erts/emulator/test/erts_debug_SUITE.erl
+++ b/erts/emulator/test/erts_debug_SUITE.erl
@@ -22,8 +22,10 @@
 -include_lib("common_test/include/ct.hrl").
 
 -export([all/0, suite/0,
-	 test_size/1,flat_size_big/1,df/1,term_type/1,
-	 instructions/1, stack_check/1]).
+         test_size/1,flat_size_big/1,df/1,term_type/1,
+         instructions/1, stack_check/1, alloc_blocks_size/1]).
+
+-export([do_alloc_blocks_size/0]).
 
 suite() ->
     [{ct_hooks,[ts_install_cth]},
@@ -31,7 +33,7 @@ suite() ->
 
 all() -> 
     [test_size, flat_size_big, df, instructions, term_type,
-     stack_check].
+     stack_check, alloc_blocks_size].
 
 test_size(Config) when is_list(Config) ->
     ConsCell1 = id([a|b]),
@@ -210,5 +212,28 @@ instructions(Config) when is_list(Config) ->
     _ = [list_to_atom(I) || I <- Is],
     ok.
 
+alloc_blocks_size(Config) when is_list(Config) ->
+    F = fun(Args) ->
+                Node = start_slave(Args),
+                ok = rpc:call(Node, ?MODULE, do_alloc_blocks_size, []),
+                true = test_server:stop_node(Node)
+        end,
+    F("+Meamax"),
+    F("+Meamin"),
+    F(""),
+    ok.
+
+do_alloc_blocks_size() ->
+    _ = erts_debug:alloc_blocks_size(binary_alloc),
+    ok.
+
+start_slave(Args) ->
+    Name = ?MODULE_STRING ++ "_slave",
+    Pa = filename:dirname(code:which(?MODULE)),
+    {ok, Node} = test_server:start_node(list_to_atom(Name),
+                                        slave,
+                                        [{args, "-pa " ++ Pa ++ " " ++ Args}]),
+    Node.
+
 id(I) ->
     I.
diff --git a/lib/kernel/src/erts_debug.erl b/lib/kernel/src/erts_debug.erl
index 1270de4144..c4d276f9e8 100644
--- a/lib/kernel/src/erts_debug.erl
+++ b/lib/kernel/src/erts_debug.erl
@@ -36,7 +36,8 @@
          map_info/1, same/2, set_internal_state/2,
          size_shared/1, copy_shared/1, dirty_cpu/2, dirty_io/2, dirty/3,
          lcnt_control/1, lcnt_control/2, lcnt_collect/0, lcnt_clear/0,
-         lc_graph/0, lc_graph_to_dot/2, lc_graph_merge/2]).
+         lc_graph/0, lc_graph_to_dot/2, lc_graph_merge/2,
+         alloc_blocks_size/1]).
 
 -spec breakpoint(MFA, Flag) -> non_neg_integer() when
       MFA :: {Module :: module(),
@@ -495,3 +496,58 @@ lcg_print_locks(Out, [LastLock]) ->
 lcg_print_locks(Out, [Lock | Rest]) ->
     io:format(Out, "~w,\n", [Lock]),
     lcg_print_locks(Out, Rest).
+
+
+%% Returns the amount of memory allocated by the given allocator type.
+-spec alloc_blocks_size(Type) -> non_neg_integer() | undefined when
+      Type :: atom().
+
+alloc_blocks_size(Type) ->
+    Allocs = erlang:system_info(alloc_util_allocators),
+    Sizes = erlang:system_info({allocator_sizes, Allocs}),
+    alloc_blocks_size_1(Sizes, Type, 0).
+
+alloc_blocks_size_1([], _Type, 0) ->
+    undefined;
+alloc_blocks_size_1([{_Type, false} | Rest], Type, Acc) ->
+    alloc_blocks_size_1(Rest, Type, Acc);
+alloc_blocks_size_1([{Type, Instances} | Rest], Type, Acc0) ->
+    F = fun ({instance, _, L}, Acc) ->
+                MBCSPool = case lists:keyfind(mbcs_pool, 1, L) of
+                               {_, Pool} -> Pool;
+                               false -> []
+                           end,
+                {_,MBCS} = lists:keyfind(mbcs, 1, L),
+                {_,SBCS} = lists:keyfind(sbcs, 1, L),
+                Acc +
+                    sum_block_sizes(MBCSPool) +
+                    sum_block_sizes(MBCS) +
+                    sum_block_sizes(SBCS)
+        end,
+    alloc_blocks_size_1(Rest, Type, lists:foldl(F, Acc0, Instances));
+alloc_blocks_size_1([{_Type, Instances} | Rest], Type, Acc0) ->
+    F = fun ({instance, _, L}, Acc) ->
+                Acc + sum_foreign_sizes(Type, L)
+        end,
+    alloc_blocks_size_1(Rest, Type, lists:foldl(F, Acc0, Instances));
+alloc_blocks_size_1([], _Type, Acc) ->
+    Acc.
+
+sum_foreign_sizes(Type, L) ->
+    case lists:keyfind(mbcs_pool, 1, L) of
+        {_,Pool} ->
+            {_,ForeignBlocks} = lists:keyfind(foreign_blocks, 1, Pool),
+            case lists:keyfind(Type, 1, ForeignBlocks) of
+                {_,TypeSizes} -> sum_block_sizes(TypeSizes);
+                false -> 0
+            end;
+        _ ->
+            0
+    end.
+
+sum_block_sizes(Blocks) ->
+    lists:foldl(
+      fun({blocks_size, Sz,_,_}, Sz0) -> Sz0+Sz;
+         ({blocks_size, Sz}, Sz0) -> Sz0+Sz;
+         (_, Sz) -> Sz
+      end, 0, Blocks).
diff --git a/lib/stdlib/test/ets_SUITE.erl b/lib/stdlib/test/ets_SUITE.erl
index 7a48d1d55e..fee8b204f4 100644
--- a/lib/stdlib/test/ets_SUITE.erl
+++ b/lib/stdlib/test/ets_SUITE.erl
@@ -6112,40 +6112,11 @@ etsmem() ->
 				   ets:info(T,memory),ets:info(T,type)}
 			end, ets:all()),
 
-    EtsAllocInfo = erlang:system_info({allocator,ets_alloc}),
+    EtsAllocSize = erts_debug:alloc_blocks_size(ets_alloc),
     ErlangMemoryEts = try erlang:memory(ets) catch error:notsup -> notsup end,
 
-    Mem =
-	{ErlangMemoryEts,
-	 case EtsAllocInfo of
-	     false -> undefined;
-	     MemInfo ->
-		 CS = lists:foldl(
-			fun ({instance, _, L}, Acc) ->
-				{value,{mbcs,MBCS}} = lists:keysearch(mbcs, 1, L),
-				{value,{sbcs,SBCS}} = lists:keysearch(sbcs, 1, L),
-				NewAcc = [MBCS, SBCS | Acc],
-				case lists:keysearch(mbcs_pool, 1, L) of
-				    {value,{mbcs_pool, MBCS_POOL}} ->
-					[MBCS_POOL|NewAcc];
-				    _ -> NewAcc
-				end
-			end,
-			[],
-			MemInfo),
-		 lists:foldl(
-		   fun(L, {Bl0,BlSz0}) ->
-			   {value,BlTup} = lists:keysearch(blocks, 1, L),
-			   blocks = element(1, BlTup),
-			   Bl = element(2, BlTup),
-			   {value,BlSzTup} = lists:keysearch(blocks_size, 1, L),
-			   blocks_size = element(1, BlSzTup),
-			   BlSz = element(2, BlSzTup),
-			   {Bl0+Bl,BlSz0+BlSz}
-		   end, {0,0}, CS)
-	 end},
-    {Mem,AllTabs}.
-
+    Mem = {ErlangMemoryEts, EtsAllocSize},
+    {Mem, AllTabs}.
 
 verify_etsmem(MI) ->
     wait_for_test_procs(),