erts, kernel: Fix erts_debug:size/1 for hashmaps

This commit introduces two BIFs:
* erts_internal:map_type/1
* erts_internal:map_hashmap_children/1

erts_internal:map_hashmap_children/1 is only intended for use within
erts_debug:size/1 since the internal hashmap node is not allowed to
leak anywhere.

1 files changed, 31 insertions, 10 deletions

diff --git a/lib/kernel/src/erts_debug.erl b/lib/kernel/src/erts_debug.erl
index ef605d0bfe..a82d9e750f 100644
--- a/lib/kernel/src/erts_debug.erl
+++ b/lib/kernel/src/erts_debug.erl
@@ -164,8 +164,10 @@ set_internal_state(_, _) ->
 
 -spec size(term()) -> non_neg_integer().
 
+-record(s, {seen, maps}).
+
 size(Term) ->
-    {Sum,_} = size(Term, gb_trees:empty(), 0),
+    {Sum,_} = size(Term, #s{seen=gb_trees:empty(),maps=[]}, 0),
     Sum.
 
 size([H|T]=Term, Seen0, Sum0) ->
@@ -209,10 +211,24 @@ tuple_size(I, Sz, Tuple, Seen0, Sum0) ->
     tuple_size(I+1, Sz, Tuple, Seen, Sum).
 
 map_size(Map,Seen0,Sum0) ->
-    Kt = erts_internal:map_to_tuple_keys(Map),
-    Vs = maps:values(Map),
-    {Sum1,Seen1} = size(Kt,Seen0,Sum0),
-    fold_size(Vs,Seen1,Sum1+length(Vs)+3).
+    %% Danger:
+    %% The internal nodes from erts_internal:map_hashmap_children/1
+    %% is not allowed to leak anywhere. They are only allowed in
+    %% containers (cons cells and tuples, not maps), in gc and
+    %% in erts_debug:same/2
+    case erts_internal:map_type(Map) of
+        flatmap ->
+            Kt = erts_internal:map_to_tuple_keys(Map),
+            Vs = maps:values(Map),
+            {Sum1,Seen1} = size(Kt,Seen0,Sum0),
+            fold_size(Vs,Seen1,Sum1+length(Vs)+3);
+        hashmap ->
+            Cs = erts_internal:map_hashmap_children(Map),
+            fold_size(Cs,Seen0,Sum0+length(Cs)+2);
+        hashmap_node ->
+            Cs = erts_internal:map_hashmap_children(Map),
+            fold_size(Cs,Seen0,Sum0+length(Cs)+1)
+    end.
 
 fun_size(Fun, Seen, Sum) ->
     case erlang:fun_info(Fun, type) of
@@ -229,13 +245,18 @@ fold_size([H|T], Seen0, Sum0) ->
     fold_size(T, Seen, Sum);
 fold_size([], Seen, Sum) -> {Sum,Seen}.
 
-remember_term(Term, Seen) ->
-    case gb_trees:lookup(Term, Seen) of
-	none -> gb_trees:insert(Term, [Term], Seen);
+remember_term(Term, #s{maps=Ms}=S) when is_map(Term) ->
+    case is_term_seen(Term, Ms) of
+        false -> S#s{maps=[Term|Ms]};
+        true  -> seen
+    end;
+remember_term(Term, #s{seen=T}=S) ->
+    case gb_trees:lookup(Term,T) of
+	none -> S#s{seen=gb_trees:insert(Term,[Term],T)};
 	{value,Terms} ->
 	    case is_term_seen(Term, Terms) of
-		false -> gb_trees:update(Term, [Term|Terms], Seen);
-		true -> seen
+		false -> S#s{seen=gb_trees:update(Term,[Term|Terms],T)};
+		true  -> seen
 	    end
     end.