Merge branch 'rickard/test-cuddle' into maint

* rickard/test-cuddle:
  Fix dirty_nif_SUITE:dirty_call_while_terminated test case
  Adjust process_SUITE:no_priority_inversion2
  Allow larger timeout delay in driver_SUITE
  Ignore long time failures during high CPU utilization
  Cleanup in statistics_SUITE:runtime_update test
  Improve timer tests in driver_SUITE
  Fix statistics_SUITE:scheduler_wall_time test
  Fix scheduler_SUITE:scheduler_suspend test
  Fix scheduler_SUITE:scheduler_threads test
  Fix scheduler_SUITE:update_cpu_info test
  Skip nif_SUITE:consume_timeslice test when debug compiled
  Increase time margin in timer_bif_SUITE:start_timer_1 test

9 files changed, 249 insertions, 64 deletions

diff --git a/erts/emulator/test/dirty_nif_SUITE.erl b/erts/emulator/test/dirty_nif_SUITE.erl
index 653b96557e..5e4c81a9cf 100644
--- a/erts/emulator/test/dirty_nif_SUITE.erl
+++ b/erts/emulator/test/dirty_nif_SUITE.erl
@@ -233,7 +233,11 @@ dirty_call_while_terminated(Config) when is_list(Config) ->
 							  process_info(self(),
 								       binary))),
     process_flag(trap_exit, OT),
-    ok.
+    try
+	blipp:blupp(Bin)
+    catch
+	_ : _ -> ok
+    end.
 
 dirty_heap_access(Config) when is_list(Config) ->
     {ok, Node} = start_node(Config),
diff --git a/erts/emulator/test/driver_SUITE.erl b/erts/emulator/test/driver_SUITE.erl
index f134a197aa..a3df0bb2db 100644
--- a/erts/emulator/test/driver_SUITE.erl
+++ b/erts/emulator/test/driver_SUITE.erl
@@ -114,7 +114,7 @@
 -define(MAX_DATA_SIZE, 16384).
 
 % This is the allowed delay when testing the driver timer functionality
--define(delay, 100).
+-define(delay, 400).
 
 -define(heap_binary_size, 64).
 
@@ -401,7 +401,7 @@ try_timeouts(Port, Timeout) ->
                 true ->
                     try_timeouts(Port, Timeout div 2)
             end
-    after Timeout + ?delay ->
+    after Timeout + 100*?delay ->
               ct:fail("driver failed to timeout")
     end.
 
@@ -437,7 +437,7 @@ try_cancel(Port, Timeout) ->
                           Timeout == 0 -> ok;
                           true -> try_cancel(Port, Timeout div 2)
                       end
-              after ?delay ->
+              after 100*?delay ->
                         ct:fail("No message from driver")
               end
     end.
@@ -505,7 +505,7 @@ try_change_timer(Port, Timeout) ->
                 true ->
                     try_timeouts(Port, Timeout div 2)
             end
-    after Timeout + ?delay ->
+    after Timeout + 100*?delay ->
               ct:fail("driver failed to timeout")
     end.
 
diff --git a/erts/emulator/test/long_timers_test.erl b/erts/emulator/test/long_timers_test.erl
index 7c055a31f9..90efe1292c 100644
--- a/erts/emulator/test/long_timers_test.erl
+++ b/erts/emulator/test/long_timers_test.erl
@@ -27,11 +27,16 @@
 %%% Created : 21 Aug 2006 by Rickard Green <[email protected]>
 %%%-------------------------------------------------------------------
 
+-define(HIGH_CPU_INFO, "Ignored due to high CPU utilization.").
+-define(MISSING_CPU_INFO, "Ignored due to missing CPU utilization information.").
 
 -define(MAX_TIMEOUT, 60). % Minutes
--define(MAX_LATE_MS, 15*1000). % Milliseconds
+-define(MAX_LATE_MS, 1000). % Milliseconds
 -define(REG_NAME, '___LONG___TIMERS___TEST___SERVER___').
 
+-define(HIGH_UTIL, 96.0).
+-define(UTIL_INTERVAL, 10000).
+
 -define(DRV_NAME, timer_driver).
 
 % First byte in communication with the timer driver
@@ -72,52 +77,149 @@ check_result() ->
     receive
 	{'DOWN', Mon, process, _, Reason} ->
 	    {?REG_NAME, 'DOWN', Reason};
-	{result, ?REG_NAME, TORs, Start, End} ->
+	{result, ?REG_NAME, TORs, Start, End, UtilData} ->
 	    erlang:demonitor(Mon),
 	    receive {'DOWN', Mon, _, _, _} -> ok after 0 -> ok end,
 	    stop_node(Node),
-	    check(TORs, ms((End - Start) - max_late()), ok)
+	    Res = check(TORs, Start, End, UtilData, ms((End - Start) - max_late()), ok),
+	    io:format("Start = ~p~n End = ~p~n UtilData = ~p~n", [Start, End, UtilData]),
+	    Res
     end.
 
+res(New, Old) when New == failed; Old == failed ->
+    failed;
+res(New, Old) when New == missing_cpu_info; Old == missing_cpu_info ->
+    missing_cpu_info;
+res(New, Old) when New == high_cpu; Old == high_cpu ->
+    high_cpu;
+res(New, _Old) ->
+    New.
+
 check([#timeout_rec{timeout = Timeout,
 		    type = Type,
 		    timeout_diff = undefined} | TORs],
+      Start,
+      End,
+      UtilData,
       NeedRes,
-      _Ok) when Timeout < NeedRes ->
-    io:format("~p timeout = ~p ms failed! No timeout.~n",
-	      [Type, Timeout]),
-    check(TORs, NeedRes, failed);
+      Ok) when Timeout < NeedRes ->
+    {NewOk, HCPU} = case had_high_cpu_util(Start,
+					   Timeout,
+					   End - Timeout*1000,
+					   UtilData) of
+			yes -> {res(high_cpu, Ok), ?HIGH_CPU_INFO};
+			no -> {res(failed, Ok), ""};
+			missing -> {res(missing_cpu_info, Ok), "FAILED", ?MISSING_CPU_INFO}
+		    end,
+    io:format("~p timeout = ~p ms FAILED! No timeout. ~s~n",
+	      [Type, Timeout, HCPU]),
+    check(TORs, Start, End, UtilData, NeedRes, NewOk);
 check([#timeout_rec{timeout_diff = undefined} | TORs],
+      Start,
+      End,
+      UtilData,
       NeedRes,
       Ok) ->
-    check(TORs, NeedRes, Ok);
+    check(TORs, Start, End, UtilData, NeedRes, Ok);
 check([#timeout_rec{timeout = Timeout,
 		    type = Type,
 		    timeout_diff = {error, Reason}} | TORs],
+      Start,
+      End,
+      UtilData,
       NeedRes,
       _Ok) ->
-    io:format("~p timeout = ~p ms failed! exit reason ~p~n",
+    io:format("~p timeout = ~p ms FAILED! exit reason ~p~n",
 	      [Type, Timeout, Reason]),
-    check(TORs, NeedRes, failed);
+    check(TORs, Start, End, UtilData, NeedRes, failed);
 check([#timeout_rec{timeout = Timeout,
 		    type = Type,
 		    timeout_diff = TimeoutDiff} | TORs],
+      Start,
+      End,
+      UtilData,
       NeedRes,
       Ok) ->
-    {NewOk, SuccessStr} = case ((0 =< TimeoutDiff)
-				andalso (TimeoutDiff =< max_late())) of
-			      true -> {Ok, "succeeded"};
-			      false -> {failed, "FAILED"}
+    {NewOk, SuccessStr, HCPU} = case {(0 =< TimeoutDiff),
+				     (TimeoutDiff =< max_late())} of
+				    {true, true} ->
+					{res(ok, Ok), "succeeded", ""};
+				    {false, _} ->
+					{res(failed, Ok), "FAILED", ""};
+				    _ ->
+					case had_high_cpu_util(Start,
+							       Timeout,
+							       TimeoutDiff,
+							       UtilData) of
+					    yes -> {res(high_cpu, Ok), "FAILED", ?HIGH_CPU_INFO};
+					    no -> {res(failed, Ok), "FAILED", ""};
+					    missing -> {res(missing_cpu_info, Ok), "FAILED", ?MISSING_CPU_INFO}
+					end
 			  end,
-    io:format("~s timeout = ~s ms ~s! timeout diff = ~s.~n",
+    io:format("~s timeout = ~s ms ~s! timeout diff = ~s. ~s~n",
 	      [type_str(Type),
 	       time_str(Timeout),
 	       SuccessStr,
-	       time_str(TimeoutDiff, erlang:convert_time_unit(1, seconds, native))]),
-    check(TORs, NeedRes, NewOk);
-check([], _NeedRes, Ok) ->
+	       time_str(TimeoutDiff, 1000000),
+	       HCPU]),
+    check(TORs, Start, End, UtilData, NeedRes, NewOk);
+check([],_Start,_End,_UtilData,_NeedRes, Ok) ->
     Ok.
 
+% TargetTimeout in ms, other in us.
+had_high_cpu_util(StartTime,
+		  TargetTimeout,
+		  TimeoutDiff,
+		  UtilData) ->
+    TargetTo = StartTime + TargetTimeout*1000,
+    ActTo = TargetTo + TimeoutDiff,
+    hcpu(ActTo, TargetTo, UtilData).
+
+hcpu(_ActTo, _TargetTo, [{UT, 0} | _] = UD) ->
+    missing; %% Util is the integer zero when not supported...
+%% UT2 =:= UT1
+hcpu(ActTo, TargetTo, [{UT, _}, {UT, _} | _] = UD) ->
+    hcpu(ActTo, TargetTo, tl(UD));
+%% UT2 > UT1 > ActTo > TargetTo
+hcpu(ActTo, TargetTo, [{_UT2, _}, {UT1, _} | _] = UD) when UT1 > ActTo ->
+    hcpu(ActTo, TargetTo, tl(UD));
+%% UT2 >= ActTo > TargetTo >= UT1
+hcpu(ActTo, TargetTo,
+     [{UT2, U}, {UT1, _} | _]) when UT2 >= ActTo,
+				    TargetTo >= UT1 ->
+    case U >= (((ActTo - TargetTo) / (UT2 - UT1))
+	       * (?HIGH_UTIL/100.0)) of
+	true -> yes;
+	false -> no
+    end;
+%% UT2 >= ActTo >= UT1 > TargetTo
+hcpu(ActTo, TargetTo,
+     [{UT2, U}, {UT1, _} | _] = UD) when UT2 >= ActTo,
+					 ActTo >= UT1,
+					 UT1 > TargetTo ->
+    case U >= (((ActTo - UT1) / (UT2 - UT1))
+	       * (?HIGH_UTIL/100.0)) of
+	true -> hcpu(ActTo, TargetTo, tl(UD));
+	false -> no
+    end;
+%% ActTo > UT2 >= TargetTo >= UT1
+hcpu(ActTo, TargetTo,
+     [{UT2, U}, {UT1, _} | _]) when ActTo > UT2,
+				    TargetTo >= UT1 ->
+    case U >= (((UT2 - TargetTo) / (UT2 - UT1))
+	       * (?HIGH_UTIL/100.0)) of
+	true -> yes;
+	false -> no
+    end;
+%% ActTo > UT2 > UT1 > TargetTo
+hcpu(ActTo, TargetTo,
+     [{UT2, U}, {UT1, _} | _] = UD) when ActTo > UT2,
+					 UT1 > TargetTo ->
+    case U >= ?HIGH_UTIL of
+	true -> hcpu(ActTo, TargetTo, tl(UD));
+	false -> no
+    end.
+
 type_str(receive_after) -> "receive ... after";
 type_str(bif_timer) -> "BIF timer";
 type_str(driver) -> "driver".
@@ -142,24 +244,24 @@ unit_str(Res) -> Res.
 
 to_diff(Timeout, Start, Stop) ->
     %% 'Timeout' in milli seconds
-    %% 'Start', 'Stop', and result in native unit
-    (Stop - Start) - erlang:convert_time_unit(Timeout, milli_seconds, native).
+    %% 'Start', 'Stop', and result in micro seconds
+    (Stop - Start) - Timeout*1000.
 
 ms(Time) ->
-    erlang:convert_time_unit(Time, native, milli_seconds).
+    erlang:convert_time_unit(Time, micro_seconds, milli_seconds).
 
 max_late() ->
-    erlang:convert_time_unit(?MAX_LATE_MS, milli_seconds, native).
+    erlang:convert_time_unit(?MAX_LATE_MS, milli_seconds, micro_seconds).
 
 receive_after(Timeout) ->
-    Start = erlang:monotonic_time(),
+    Start = erlang:monotonic_time(micro_seconds),
     receive
 	{get_result, ?REG_NAME} ->
 	    ?REG_NAME ! #timeout_rec{pid = self(),
 				     type = receive_after,
 				     timeout = Timeout}
     after Timeout ->
-	    Stop = erlang:monotonic_time(),
+	    Stop = erlang:monotonic_time(micro_seconds),
 	    receive
 		{get_result, ?REG_NAME} ->
 		    ?REG_NAME ! #timeout_rec{pid = self(),
@@ -174,7 +276,7 @@ receive_after(Timeout) ->
 driver(Timeout) ->
     Port = open_port({spawn, ?DRV_NAME},[]),
     link(Port),
-    Start = erlang:monotonic_time(),
+    Start = erlang:monotonic_time(micro_seconds),
     erlang:port_command(Port, <<?START_TIMER, Timeout:32>>),
     receive
 	{get_result, ?REG_NAME} ->
@@ -182,7 +284,7 @@ driver(Timeout) ->
 				     type = driver,
 				     timeout = Timeout};
 	{Port,{data,[?TIMER]}} ->
-	    Stop = erlang:monotonic_time(),
+	    Stop = erlang:monotonic_time(micro_seconds),
 	    unlink(Port),
 	    true = erlang:port_close(Port),
 	    receive
@@ -197,7 +299,7 @@ driver(Timeout) ->
     end.
 
 bif_timer(Timeout) ->
-    Start = erlang:monotonic_time(),
+    Start = erlang:monotonic_time(micro_seconds),
     Tmr = erlang:start_timer(Timeout, self(), ok),
     receive
 	{get_result, ?REG_NAME} ->
@@ -205,7 +307,7 @@ bif_timer(Timeout) ->
 				     type = bif_timer,
 				     timeout = Timeout};
 	{timeout, Tmr, ok} ->
-	    Stop = erlang:monotonic_time(),
+	    Stop = erlang:monotonic_time(micro_seconds),
 	    receive
 		{get_result, ?REG_NAME} ->
 		    ?REG_NAME ! #timeout_rec{pid = self(),
@@ -218,13 +320,22 @@ bif_timer(Timeout) ->
     end.
 
 test(Starter, DrvDir, StartDone) ->
+    process_flag(priority, high),
     erl_ddll:start(),
     ok = load_driver(DrvDir, ?DRV_NAME),
     process_flag(trap_exit, true),
     register(?REG_NAME, self()),
     {group_leader, GL} = process_info(whereis(net_kernel),group_leader),
     group_leader(GL, self()),
-    Start = erlang:monotonic_time(),
+    try
+	application:start(sasl),
+	application:start(os_mon)
+    catch
+	_ : _ ->
+	    ok
+    end,
+    UtilData = new_util(),
+    Start = erlang:monotonic_time(micro_seconds),
     TORs = lists:map(fun (Min) ->
 			     TO = Min*60*1000,
 			     [#timeout_rec{pid = spawn_opt(
@@ -252,16 +363,27 @@ test(Starter, DrvDir, StartDone) ->
 		     lists:seq(1, ?MAX_TIMEOUT)),
     FlatTORs = lists:flatten(TORs),
     Starter ! StartDone,
-    test_loop(FlatTORs, Start).
+    test_loop(FlatTORs, Start, UtilData).
+
+new_util() ->
+    new_util([]).
+
+new_util(UtilData) ->
+    Util = cpu_sup:util(),
+    Time = erlang:monotonic_time(micro_seconds),
+    [{Time, Util} | UtilData].
 
-test_loop(TORs, Start) ->
+test_loop(TORs, Start, UtilData) ->
     receive
 	{get_result, ?REG_NAME, Pid} ->
-	    End = erlang:monotonic_time(),
-	    Pid ! {result, ?REG_NAME, get_test_results(TORs), Start, End},
+	    End = erlang:monotonic_time(micro_seconds),
+	    EndUtilData = new_util(UtilData),
+	    Pid ! {result, ?REG_NAME, get_test_results(TORs), Start, End, EndUtilData},
 	    erl_ddll:unload_driver(?DRV_NAME),
 	    erl_ddll:stop(),
 	    exit(bye)
+    after ?UTIL_INTERVAL ->
+	    test_loop(TORs, Start, new_util(UtilData))
     end.
 
 get_test_results(TORs) ->
diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl
index a0e9f1bad6..b8fa7184b6 100644
--- a/erts/emulator/test/nif_SUITE.erl
+++ b/erts/emulator/test/nif_SUITE.erl
@@ -1443,6 +1443,17 @@ otp_9828_loop(Bin, Val) ->
 
 
 consume_timeslice(Config) when is_list(Config) ->
+    case {erlang:system_info(debug_compiled),
+	  erlang:system_info(lock_checking)} of
+	{false, false} ->
+	    consume_timeslice_test(Config);
+	{false, true} ->
+	    {skipped, "Lock checking enabled"};
+	_ ->
+	    {skipped, "Debug compiled"}
+    end.
+
+consume_timeslice_test(Config) when is_list(Config) ->
     CONTEXT_REDS = 2000,
     Me = self(),
     Go = make_ref(),
diff --git a/erts/emulator/test/process_SUITE.erl b/erts/emulator/test/process_SUITE.erl
index dae8990f56..7462c8c593 100644
--- a/erts/emulator/test/process_SUITE.erl
+++ b/erts/emulator/test/process_SUITE.erl
@@ -2376,7 +2376,7 @@ no_priority_inversion2(Config) when is_list(Config) ->
 				       [{priority, max}, monitor, link])
 		     end,
 		     lists:seq(1, 2*erlang:system_info(schedulers))),
-    receive after 500 -> ok end,
+    receive after 2000 -> ok end,
     {PL, ML} = spawn_opt(fun () ->
 			       tok_loop()
 		       end,
diff --git a/erts/emulator/test/scheduler_SUITE.erl b/erts/emulator/test/scheduler_SUITE.erl
index f18d79d770..a95de609aa 100644
--- a/erts/emulator/test/scheduler_SUITE.erl
+++ b/erts/emulator/test/scheduler_SUITE.erl
@@ -793,13 +793,13 @@ update_cpu_info(Config) when is_list(Config) ->
     io:format("START - Affinity mask: ~p - Schedulers online: ~p - Scheduler bindings: ~p~n",
 		    [OldAff, OldOnline, erlang:system_info(scheduler_bindings)]),
     case {erlang:system_info(logical_processors_available), OldAff} of
-	      {Avail, _} when Avail == unknown; OldAff == unknown ->
+	      {Avail, _} when Avail == unknown; OldAff == unknown; OldAff == 1 ->
 		  %% Nothing much to test; just a smoke test
 		  case erlang:system_info(update_cpu_info) of
 		      unchanged -> ok;
 		      changed -> ok
 		  end;
-	      _ ->
+	      {Avail, _} ->
 		  try
 		      adjust_schedulers_online(),
 		      case erlang:system_info(schedulers_online) of
@@ -810,7 +810,7 @@ update_cpu_info(Config) when is_list(Config) ->
 			      %% unset least significant bit
 			      Aff = (OldAff band (OldAff - 1)),
 			      set_affinity_mask(Aff),
-			      Onln1 = Onln0 - 1,
+			      Onln1 = Avail - 1,
 			      case adjust_schedulers_online() of
 					{Onln0, Onln1} ->
 					    Onln1 = erlang:system_info(schedulers_online),
@@ -1072,20 +1072,27 @@ scheduler_threads(Config) when is_list(Config) ->
     {Sched, HalfSchedOnln, _} = get_sstate(Config, "+SP:50"),
     %% Configure 2x scheduler threads only
     {TwiceSched, SchedOnln, _} = get_sstate(Config, "+SP 200"),
-    %% Test resetting the scheduler counts
-    ResetCmd = "+S "++FourSched++":"++FourSchedOnln++" +S 0:0",
-    {Sched, SchedOnln, _} = get_sstate(Config, ResetCmd),
-    %% Test negative +S settings, but only for SMP-enabled emulators
-    case SmpSupport of
-        false -> ok;
-        true ->
-            SchedMinus1 = Sched-1,
-            SchedOnlnMinus1 = SchedOnln-1,
-            {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(Config, "+S -1"),
-            {Sched, SchedOnlnMinus1, _} = get_sstate(Config, "+S :-1"),
-            {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(Config, "+S -1:-1")
-    end,
-    ok.
+    case {erlang:system_info(logical_processors),
+	  erlang:system_info(logical_processors_available)} of
+	{LProc, LProcAvail} when is_integer(LProc), is_integer(LProcAvail) ->
+	    %% Test resetting the scheduler counts
+	    ResetCmd = "+S "++FourSched++":"++FourSchedOnln++" +S 0:0",
+	    {LProc, LProcAvail, _} = get_sstate(Config, ResetCmd),
+	    %% Test negative +S settings, but only for SMP-enabled emulators
+	    case {SmpSupport, LProc > 1, LProcAvail > 1} of
+		{true, true, true} ->
+		    SchedMinus1 = LProc-1,
+		    SchedOnlnMinus1 = LProcAvail-1,
+		    {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(Config, "+S -1"),
+		    {LProc, SchedOnlnMinus1, _} = get_sstate(Config, "+S :-1"),
+		    {SchedMinus1, SchedOnlnMinus1, _} = get_sstate(Config, "+S -1:-1"),
+		    ok;
+		_ ->
+		    {comment, "Skipped reduced amount of schedulers test due to too few logical processors"}
+	    end;
+	_ -> %% Skipped when missing info about logical processors...
+	    {comment, "Skipped reset amount of schedulers test, and reduced amount of schedulers test due to too unknown amount of logical processors"}
+    end.
 
 dirty_scheduler_threads(Config) when is_list(Config) ->
     SmpSupport = erlang:system_info(smp_support),
@@ -1312,11 +1319,33 @@ scheduler_suspend_test(Config, Schedulers) ->
                                         true ->
                                             ok
                                     end,
-                                    erlang:system_info(schedulers_state)
+                                    until(fun () ->
+						  {_A, B, C} = erlang:system_info(
+								 schedulers_state),
+                                              B == C
+                                          end,
+                                          erlang:monotonic_time()
+                                          + erlang:convert_time_unit(1,
+								     seconds,
+								     native)),
+				    erlang:system_info(schedulers_state)
                             end]),
     stop_node(Node),
     ok.
-    
+
+until(Pred, MaxTime) ->
+    case Pred() of
+	true ->
+	    true;
+	false ->
+	    case erlang:monotonic_time() > MaxTime of
+		true ->
+		    false;
+		false ->
+		    receive after 100 -> ok end,
+		    until(Pred, MaxTime)
+	    end
+    end.
 
 sst0_loop(0) ->
     ok;
diff --git a/erts/emulator/test/statistics_SUITE.erl b/erts/emulator/test/statistics_SUITE.erl
index 71ef003b25..a1f12ba93c 100644
--- a/erts/emulator/test/statistics_SUITE.erl
+++ b/erts/emulator/test/statistics_SUITE.erl
@@ -129,11 +129,15 @@ do_runtime_update(0) ->
     {comment,"Never close enough"};
 do_runtime_update(N) ->
     {T1,Diff0} = statistics(runtime),
-    spawn_link(fun cpu_heavy/0),
+    {CPUHog, CPUHogMon} = spawn_opt(fun cpu_heavy/0,[link,monitor]),
     receive after 1000 -> ok end,
     {T2,Diff} = statistics(runtime),
+    unlink(CPUHog),
+    exit(CPUHog, kill),
+    
     true = is_integer(T1+T2+Diff0+Diff),
     io:format("T1 = ~p, T2 = ~p, Diff = ~p, T2-T1 = ~p", [T1,T2,Diff,T2-T1]),
+    receive {'DOWN',CPUHogMon,process,CPUHog,_} -> ok end,
     if
         T2 - T1 =:= Diff, 900 =< Diff, Diff =< 1500 -> ok;
         true -> do_runtime_update(N-1)
@@ -311,8 +315,17 @@ scheduler_wall_time(Config) when is_list(Config) ->
            true -> exit({fullload, FullLoad})
         end,
 
-        [exit(Pid, kill) || Pid <- [P1|HalfHogs++LastHogs]],
+	KillHog = fun (HP) ->
+			  HPM = erlang:monitor(process, HP),
+			  exit(HP, kill),
+			  receive
+			      {'DOWN', HPM, process, HP, killed} ->
+				  ok
+			  end
+		  end,
+        [KillHog(Pid) || Pid <- [P1|HalfHogs++LastHogs]],
         AfterLoad = get_load(),
+	io:format("AfterLoad=~p~n", [AfterLoad]),
         {false,_} = {lists:any(fun(Load) -> Load > 25 end, AfterLoad),AfterLoad},
         true = erlang:system_flag(scheduler_wall_time, false)
     after
diff --git a/erts/emulator/test/timer_bif_SUITE.erl b/erts/emulator/test/timer_bif_SUITE.erl
index a5f11bd959..44f276f232 100644
--- a/erts/emulator/test/timer_bif_SUITE.erl
+++ b/erts/emulator/test/timer_bif_SUITE.erl
@@ -74,7 +74,7 @@ all() ->
 %% Basic start_timer/3 functionality
 start_timer_1(Config) when is_list(Config) ->
     Ref1 = erlang:start_timer(1000, self(), plopp),
-    ok   = get(1100, {timeout, Ref1, plopp}),
+    ok   = get(1400, {timeout, Ref1, plopp}),
 
     false = erlang:read_timer(Ref1),
     false = erlang:cancel_timer(Ref1),
@@ -83,12 +83,12 @@ start_timer_1(Config) when is_list(Config) ->
     Ref2  = erlang:start_timer(1000, self(), plapp),
     Left2 = erlang:cancel_timer(Ref2),
     UpperLimit = 1000,
-    true = (Left2 > 900) and (Left2 =< UpperLimit),
+    true = (Left2 > 600) and (Left2 =< UpperLimit),
     empty = get_msg(),
     false = erlang:cancel_timer(Ref2),
 
     Ref3 = erlang:start_timer(1000, self(), plopp),
-    no_message = get(900, {timeout, Ref3, plopp}),
+    no_message = get(600, {timeout, Ref3, plopp}),
     ok.
 
 %% Basic send_after/3 functionality
diff --git a/erts/emulator/test/z_SUITE.erl b/erts/emulator/test/z_SUITE.erl
index d1085c1958..ab56018373 100644
--- a/erts/emulator/test/z_SUITE.erl
+++ b/erts/emulator/test/z_SUITE.erl
@@ -191,7 +191,13 @@ node_container_refc_check(Config) when is_list(Config) ->
     ok.
 
 long_timers(Config) when is_list(Config) ->
-    ok = long_timers_test:check_result().
+    case long_timers_test:check_result() of
+	ok -> ok;
+	high_cpu -> {comment, "Ignored failures due to high CPU utilization"};
+	missing_cpu_info -> {comment, "Ignored failures due to missing CPU utilization information"};
+	Fail -> ct:fail(Fail)
+    end.
+	    
 
 pollset_size(Config) when is_list(Config) ->
     Name = pollset_size_testcase_initial_state_holder,