%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 1997-2017. 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) -> %% Try as major, the test process will self-trigger GC check_gc_tracing_around( fun(Pid, Ref) -> Pid ! {gc, Ref, major} end, [gc_major_start, gc_major_end]), %% Try as minor, the test process will self-trigger GC check_gc_tracing_around( fun(Pid, Ref) -> Pid ! {gc, Ref, minor} end, [gc_minor_start, gc_minor_end]). minor_major_gc_option_async(_Config) -> %% Try with default option, must be major GC check_gc_tracing_around( fun(Pid, _Ref) -> erlang:garbage_collect(Pid, []) end, [gc_major_start, gc_major_end]), %% Try with the 'major' type check_gc_tracing_around( fun(Pid, _Ref) -> erlang:garbage_collect(Pid, [{type, major}]) end, [gc_major_start, gc_major_end]), %% Try with 'minor' option, once check_gc_tracing_around( fun(Pid, _Ref) -> erlang:garbage_collect(Pid, [{type, minor}]) end, [gc_minor_start, gc_minor_end]), %% Try with 'minor' option, once, async check_gc_tracing_around( fun(Pid, Ref) -> ?assertEqual(async, erlang:garbage_collect(Pid, [{type, minor}, {async, Ref}])), receive {garbage_collect, Ref, true} -> ok after 10000 -> ct:fail("Did not receive a completion notification on async GC") end end, [gc_minor_start, gc_minor_end]). %% Traces garbage collection around the given operation, and fails the test if %% it results in any unexpected messages or if the expected trace tags are not %% received. check_gc_tracing_around(Fun, ExpectedTraceTags) -> Ref = erlang:make_ref(), Pid = spawn( fun Endless() -> receive {gc, Ref, Type} -> erlang:garbage_collect(self(), [{type, Type}]) after 100 -> ok end, Endless() end), erlang:garbage_collect(Pid, []), erlang:trace(Pid, true, [garbage_collection]), Fun(Pid, Ref), expect_trace_messages(Pid, ExpectedTraceTags), erlang:trace(Pid, false, [garbage_collection]), erlang:exit(Pid, kill), check_no_unexpected_messages(). %% Ensures that trace messages with the provided tags have all been received %% within a reasonable timeframe. expect_trace_messages(_Pid, []) -> ok; expect_trace_messages(Pid, [Tag | TraceTags]) -> receive {trace, Pid, Tag, _Data} -> expect_trace_messages(Pid, TraceTags) after 4000 -> ct:fail("Didn't receive tag ~p within 4000ms", [Tag]) end. check_no_unexpected_messages() -> receive Anything -> ct:fail("Unexpected message: ~p", [Anything]) after 0 -> ok end.