%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 1997-2016. 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%
%%
%% Test the garbage collector (or Memory Recycler)
-module(gc_SUITE).
-include_lib("common_test/include/ct.hrl").
-include_lib("eunit/include/eunit.hrl").
-export([all/0, suite/0]).
-export([
grow_heap/1,
grow_stack/1,
grow_stack_heap/1,
max_heap_size/1,
minor_major_gc_option_async/1,
minor_major_gc_option_self/1
]).
suite() ->
[{ct_hooks,[ts_install_cth]}].
all() ->
[grow_heap, grow_stack, grow_stack_heap, max_heap_size,
minor_major_gc_option_self,
minor_major_gc_option_async].
%% Produce a growing list of elements,
%% for X calls, then drop one item per call
%% until the list is empty.
grow_heap(Config) when is_list(Config) ->
ct:timetrap({minutes, 40}),
ok = grow_heap1(256),
ok = grow_heap1(512),
ok = grow_heap1(1024),
ok = grow_heap1(2048),
ok.
grow_heap1(Len) ->
io:format("~ngrow_heap with ~p items.",[Len]),
show_heap("before:"),
grow_heap1([], Len, 0, up),
show_heap("after:").
grow_heap1(List, MaxLen, MaxLen, up) ->
show_heap("top:"),
grow_heap1(List, MaxLen, MaxLen-1, down);
grow_heap1(List, MaxLen, CurLen, up) ->
NewList=[make_arbit()|List],
grow_heap1(NewList, MaxLen, CurLen+1, up);
grow_heap1([], _MaxLen, _, down) ->
ok;
grow_heap1([_|List], MaxLen, CurLen, down) ->
C=erlang:unique_integer([positive]),
Num = C rem (length(List))+1,
Elem = lists:nth(Num, List),
NewList = lists:delete(Elem, List),
grow_heap1(NewList, MaxLen, CurLen-1, down).
%% Increase and decrease stack size, and
%% drop off some garbage from time to time.
grow_stack(Config) when is_list(Config) ->
ct:timetrap({minutes, 80}),
show_heap("before:"),
grow_stack1(200, 0),
show_heap("after:"),
ok.
grow_stack1(0, _) ->
ok;
grow_stack1(Recs, 0) ->
% show_heap("running:"),
grow_stack1(Recs-1, Recs),
grow_stack1(0,0);
grow_stack1(Recs, CurRecs) ->
grow_stack1(Recs, CurRecs-1),
make_arbit(),
grow_stack1(1,0),
ok.
%% Let's see how BEAM handles this one...
%% While growing the heap, bounces the size of the
%% stack, and while reducing the heap, bounces the stack usage.
grow_stack_heap(Config) when is_list(Config) ->
ct:timetrap({minutes, 40}),
grow_stack_heap1(16),
grow_stack_heap1(32),
ok.
grow_stack_heap1(MaxLen) ->
io:format("~ngrow_stack_heap with ~p items.",[MaxLen]),
show_heap("before:"),
grow_stack_heap1([], MaxLen, 0, up),
show_heap("after:").
grow_stack_heap1(List, MaxLen, MaxLen, up) ->
show_heap("top:"),
grow_stack_heap1(List, MaxLen, MaxLen-1, down);
grow_stack_heap1(List, MaxLen, CurLen, up) ->
grow_stack1(CurLen*2,0),
grow_stack_heap1([make_arbit()|List], MaxLen, CurLen+1, up),
ok;
grow_stack_heap1([], _MaxLen, _, down) -> ok;
grow_stack_heap1([_|List], MaxLen, CurLen, down) ->
grow_stack1(CurLen*2,0),
C=erlang:unique_integer([positive]),
Num=C rem (length(List))+1,
Elem=lists:nth(Num, List),
NewList=lists:delete(Elem, List),
grow_stack_heap1(NewList, MaxLen, CurLen-1, down),
ok.
%% Create an arbitrary element/term.
make_arbit() ->
{AA,BB,CC}=erlang:timestamp(),
A=AA+1, B=BB+1, C=(CC+erlang:unique_integer([positive])) rem 1000000 + 1,
New =
case C rem 9 of
0 -> make_string((B div C) +5);
1 -> C;
2 -> make_ref();
3 -> self();
4 -> list_to_binary(make_string((C div B) + 12));
5 -> (C*B)/(A+1);
6 -> list_to_tuple(make_string((B div C) +5));
7 -> list_to_atom(make_string(((C div B) rem 254) + 2));
8 -> fun(X) -> {X,AA,make_string((B div C)+10)} end
end,
New.
%% Create an arbitrary string of a certain length.
make_string(Length) ->
Alph="abcdefghjiklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"++
"0123456789",
make_string(Alph, Length, []).
make_string(_, 0, Acc) ->
Acc;
make_string(Alph, Length, Acc) ->
C=erlang:unique_integer([positive]),
Pos=1+(Length*C rem length(Alph)),
make_string(Alph, Length-1,
[lists:nth(Pos,Alph)|Acc]).
show_heap(String) ->
garbage_collect(self()),
receive after 1 -> ok end,
{heap_size, HSize}=process_info(self(), heap_size),
{stack_size, SSize}=process_info(self(), stack_size),
io:format("Heap/Stack "++String++"~p/~p", [HSize, SSize]).
%% Test that doing a remote GC that triggers the max heap size
%% kills the process.
max_heap_size(_Config) ->
Pid = spawn_opt(fun long_receive/0,[{max_heap_size, 1024},
{message_queue_data, on_heap}]),
[Pid ! lists:duplicate(I,I) || I <- lists:seq(1,100)],
Ref = erlang:monitor(process, Pid),
%% Force messages to be viewed as part of heap
erlang:process_info(Pid, messages),
%% Do the GC that triggers max heap
erlang:garbage_collect(Pid),
%% Verify that max heap was triggered
receive
{'DOWN', Ref, process, Pid, killed} -> ok
after 5000 ->
ct:fail({process_did_not_die, Pid, erlang:process_info(Pid)})
end.
long_receive() ->
receive
after 10000 ->
ok
end.
minor_major_gc_option_self(_Config) ->
Endless = fun Endless() ->
receive
{gc, Type} -> erlang:garbage_collect(self(), [{type, Type}])
after 100 -> ok end,
Endless()
end,
%% Try as major, a test process will self-trigger GC
P1 = spawn(Endless),
erlang:garbage_collect(P1, []),
erlang:trace(P1, true, [garbage_collection]),
P1 ! {gc, major},
expect_trace_messages(P1, [gc_major_start, gc_major_end]),
erlang:trace(P1, false, [garbage_collection]),
erlang:exit(P1, kill),
%% Try as minor, a test process will self-trigger GC
P2 = spawn(Endless),
erlang:garbage_collect(P2, []),
erlang:trace(P2, true, [garbage_collection]),
P2 ! {gc, minor},
expect_trace_messages(P2, [gc_minor_start, gc_minor_end]),
erlang:trace(P2, false, [garbage_collection]),
erlang:exit(P2, kill).
minor_major_gc_option_async(_Config) ->
Endless = fun Endless() ->
receive after 100 -> ok end,
Endless()
end,
%% Try with default option, must be major gc
P1 = spawn(Endless),
erlang:garbage_collect(P1, []),
erlang:trace(P1, true, [garbage_collection]),
erlang:garbage_collect(P1, []),
expect_trace_messages(P1, [gc_major_start, gc_major_end]),
erlang:trace(P1, false, [garbage_collection]),
erlang:exit(P1, kill),
%% Try with the 'major' type
P2 = spawn(Endless),
erlang:garbage_collect(P2, []),
erlang:trace(P2, true, [garbage_collection]),
erlang:garbage_collect(P2, [{type, major}]),
expect_trace_messages(P2, [gc_major_start, gc_major_end]),
erlang:trace(P2, false, [garbage_collection]),
erlang:exit(P2, kill),
%% Try with 'minor' option, once
P3 = spawn(Endless),
erlang:garbage_collect(P3, []),
erlang:trace(P3, true, [garbage_collection]),
erlang:garbage_collect(P3, [{type, minor}]),
expect_trace_messages(P3, [gc_minor_start, gc_minor_end]),
erlang:trace(P3, false, [garbage_collection]),
erlang:exit(P3, kill),
%% Try with 'minor' option, once, async
P4 = spawn(Endless),
Ref = erlang:make_ref(),
erlang:garbage_collect(P4, []),
erlang:trace(P4, true, [garbage_collection]),
?assertEqual(async,
erlang:garbage_collect(P4, [{type, minor}, {async, Ref}])),
expect_trace_messages(P4, [gc_minor_start, gc_minor_end]),
erlang:trace(P4, false, [garbage_collection]),
receive {garbage_collect, Ref, true} -> ok;
Other4 -> ct:pal("Unexpected message: ~p~n"
++ "while waiting for async gc result", [Other4])
after 2000 -> ?assert(false)
end,
erlang:exit(P4, kill).
%% Given a list of atoms, trace tags - receives messages and checks if they are
%% trace events, and if the tag matches. Else will crash failing the test.
expect_trace_messages(_Pid, []) -> ok;
expect_trace_messages(Pid, [Tag | TraceTags]) ->
receive
{trace, Pid, Tag, _Data} -> ok;
AnythingElse ->
ct:pal("Unexpected message: ~p~nWhile expected {trace, _, ~p, _}",
[AnythingElse, Tag]),
?assert(false)
end,
expect_trace_messages(Pid, TraceTags).
