%%% -*- erlang-indent-level: 2 -*-
%%%----------------------------------------------------------------------
%%% Contains
%%%----------------------------------------------------------------------
-module(basic_edge_cases).
-export([test/0]).
test() ->
ok = test_float_spills(),
ok = test_infinite_loops(),
ok.
%% Contains more float temps live at a single point than there are float
%% registers in any backend
test_float_spills() ->
{{{2942.0,4670.0,3198.0,4926.0,2206.0,4734.0},
{3118.0,2062.0,5174.0,3038.0,3618.0,3014.0},
{2542.0,2062.0,4934.0,2590.0,3098.0,3062.0},
{2950.0,3666.0,2574.0,5038.0,1866.0,2946.0},
{3126.0,3050.0,3054.0,5070.0,2258.0,2714.0},
{4734.0,2206.0,4926.0,3198.0,4670.0,2942.0}},
58937.0} =
mat66_flip_sum(35.0,86.0,32.0,88.0,33.0,57.0,
22.0,77.0,91.0,80.0,14.0,33.0,
51.0,28.0,87.0,20.0,91.0,11.0,
68.0,83.0,64.0,82.0,10.0,86.0,
74.0,18.0,08.0,52.0,10.0,14.0,
89.0,34.0,64.0,66.0,58.0,55.0,
0.0, 5),
ok.
mat66_flip_sum(M11, M12, M13, M14, M15, M16,
M21, M22, M23, M24, M25, M26,
M31, M32, M33, M34, M35, M36,
M41, M42, M43, M44, M45, M46,
M51, M52, M53, M54, M55, M56,
M61, M62, M63, M64, M65, M66,
Acc, Ctr)
when is_float(M11), is_float(M12), is_float(M13),
is_float(M14), is_float(M15), is_float(M16),
is_float(M21), is_float(M22), is_float(M23),
is_float(M24), is_float(M25), is_float(M26),
is_float(M31), is_float(M32), is_float(M33),
is_float(M34), is_float(M35), is_float(M36),
is_float(M41), is_float(M42), is_float(M43),
is_float(M44), is_float(M45), is_float(M46),
is_float(M51), is_float(M52), is_float(M53),
is_float(M54), is_float(M55), is_float(M56),
is_float(M61), is_float(M62), is_float(M63),
is_float(M64), is_float(M65), is_float(M66),
is_float(Acc) ->
R11 = M66+M11, R12 = M65+M12, R13 = M64+M13,
R14 = M63+M14, R15 = M62+M15, R16 = M61+M16,
R21 = M56+M21, R22 = M55+M22, R23 = M54+M23,
R24 = M53+M24, R25 = M52+M25, R26 = M51+M26,
R31 = M46+M31, R32 = M45+M32, R33 = M44+M33,
R34 = M43+M34, R35 = M42+M35, R36 = M41+M36,
R41 = M26+M41, R42 = M25+M42, R43 = M24+M43,
R44 = M23+M44, R45 = M22+M45, R46 = M21+M46,
R51 = M36+M51, R52 = M35+M52, R53 = M34+M53,
R54 = M33+M54, R55 = M32+M55, R56 = M31+M56,
R61 = M16+M61, R62 = M15+M62, R63 = M14+M63,
R64 = M13+M64, R65 = M12+M65, R66 = M11+M66,
case Ctr of
0 ->
{{{R11, R12, R13, R14, R15, R16},
{R21, R22, R23, R24, R25, R26},
{R31, R32, R33, R34, R35, R36},
{R41, R42, R43, R44, R45, R46},
{R51, R52, R53, R54, R55, R56},
{R61, R62, R63, R64, R65, R66}},
Acc};
_ ->
NewAcc = 0.0 + M11 + M12 + M13 + M14 + M15 + M16 +
+ M21 + M22 + M23 + M24 + M25 + M26
+ M31 + M32 + M33 + M34 + M35 + M36
+ M41 + M42 + M43 + M44 + M45 + M46
+ M51 + M52 + M53 + M54 + M55 + M56
+ M61 + M62 + M63 + M64 + M65 + M66
+ Acc,
mat66_flip_sum(R11+1.0, R12+1.0, R13+1.0, R14+1.0, R15+1.0, R16+1.0,
R21+1.0, R22+1.0, R23+1.0, R24+1.0, R25+1.0, R26+1.0,
R31+1.0, R32+1.0, R33+1.0, R34+1.0, R35+1.0, R36+1.0,
R41+1.0, R42+1.0, R43+1.0, R44+1.0, R45+1.0, R46+1.0,
R51+1.0, R52+1.0, R53+1.0, R54+1.0, R55+1.0, R56+1.0,
R61+1.0, R62+1.0, R63+1.0, R64+1.0, R65+1.0, R66+1.0,
NewAcc, Ctr-1)
end.
%% Infinite loops must receive reduction tests, and might trip up basic block
%% weighting, leading to infinite weights and/or divisions by zero.
test_infinite_loops() ->
OldTrapExit = process_flag(trap_exit, true),
ok = test_infinite_loop(fun infinite_recursion/0),
ok = test_infinite_loop(fun infinite_corecursion/0),
RecursiveFun = fun RecursiveFun() -> RecursiveFun() end,
ok = test_infinite_loop(RecursiveFun),
CorecursiveFunA = fun CorecursiveFunA() ->
CorecursiveFunA1 = fun () -> CorecursiveFunA() end,
CorecursiveFunA1()
end,
ok = test_infinite_loop(CorecursiveFunA),
CorecursiveFunB1 = fun(CorecursiveFunB) -> CorecursiveFunB() end,
CorecursiveFunB = fun CorecursiveFunB() ->
CorecursiveFunB1(CorecursiveFunB)
end,
ok = test_infinite_loop(CorecursiveFunB),
CorecursiveFunC1 = fun CorecursiveFunC1(Other) ->
Other(CorecursiveFunC1)
end,
CorecursiveFunC = fun CorecursiveFunC(Other) ->
Other(CorecursiveFunC)
end,
ok = test_infinite_loop(fun() -> CorecursiveFunC(CorecursiveFunC1) end),
ok = test_infinite_loop(fun() -> CorecursiveFunC(CorecursiveFunC) end),
true = process_flag(trap_exit, OldTrapExit),
ok.
-define(INFINITE_LOOP_TIMEOUT, 100).
test_infinite_loop(Fun) ->
Tester = spawn_link(Fun),
kill_soon(Tester),
receive {'EXIT', Tester, awake} ->
undefined = process_info(Tester),
ok
after ?INFINITE_LOOP_TIMEOUT -> error(timeout)
end.
infinite_recursion() -> infinite_recursion().
infinite_corecursion() -> infinite_corecursion_1().
infinite_corecursion_1() -> infinite_corecursion().
kill_soon(Pid) ->
_ = spawn_link(fun() ->
timer:sleep(1),
erlang:exit(Pid, awake)
end),
ok.
