anchor.diff:  same_time_yielding(Config) when is_list(Config) ->
       Mem = mem(),
       Ref = make_ref(),
  -    SchdlrsOnln = erlang:system_info(schedulers_online),
  -    Tmo = erlang:monotonic_time(millisecond) + 6000,
  +    SchdlrsOnline = erlang:system_info(schedulers_online),
  +    SchdlrsToUse = erlang:max(1, erlang:min(8, SchdlrsOnline) - 1),
  +    StartTime = erlang:monotonic_time(millisecond),
  +    Tmo = StartTime + 20000,
  +    NrOfTimeouts = (?TIMEOUT_YIELD_LIMIT*3+1) * SchdlrsToUse,
  +    NrOfTimeoutsPerScheduler = NrOfTimeouts div SchdlrsToUse,
       Tmrs = lists:map(fun (I) ->
  -                             process_flag(scheduler, (I rem SchdlrsOnln) + 1),
  -                             erlang:start_timer(Tmo, self(), Ref, [{abs, true}])
  +                             SchedulerId =
  +                                 case SchdlrsOnline of
  +                                     1 -> 1;
  +                                     _ ->
  +                                         ((I div NrOfTimeoutsPerScheduler) rem SchdlrsToUse)  + 2
  +                                 end,
  +                             process_flag(scheduler, SchedulerId),
  +                             erlang:start_timer(Tmo, self(), Ref, [{abs, true}]),
  +                             SchedulerId
                        end,
  -                     lists:seq(1, (?TIMEOUT_YIELD_LIMIT*3+1)*SchdlrsOnln)),
  +                     lists:seq(1, NrOfTimeouts)),
  +    process_flag(scheduler, 1),
  +    AllTimersStartedTime = erlang:monotonic_time(millisecond),
       true = mem_larger_than(Mem),
  -    receive_all_timeouts(length(Tmrs), Ref),
  +    {TimeToReceive, TimeUntilFirst} = receive_all_timeouts(length(Tmrs), Ref),
       Done = erlang:monotonic_time(millisecond),
       true = Done >= Tmo,
       MsAfterTmo = Done - Tmo,
  -    io:format("Done ~p ms after Tmo\n", [MsAfterTmo]),
  +    io:format("Done ~p ms after Tmo\nInfo: ~p\n",
  +              [MsAfterTmo,
  +               {'TimeToStartAllTimers', AllTimersStartedTime - StartTime,
  +                'TimeInReceiveUntilFirst',TimeUntilFirst,
  +                'TimeToReceive', TimeToReceive}]),
       case erlang:system_info(build_type) of
           opt ->
               true = MsAfterTmo < 200;
  
positive.code: %% Read out all timeouts in receive queue order. This is efficient
  %% even if there are very many messages.
  
  receive_all_timeouts(0, _Ref) ->
      ok;
  receive_all_timeouts(N, Ref) ->
      receive
          {timeout, _Tmr, Ref} ->
              receive_all_timeouts(N-1, Ref)
      end.
  
  same_time_yielding_with_cancel(Config) when is_list(Config) ->
  
negative.code:                true -> [{accessor, Cancelor}, {abs, true}]
             end,
      Tmrs = lists:map(fun (I) ->
                               SchedulerId =
                                   case SchdlrsOnline of
                                       1 -> 1;
                                       _ ->
                                           ((I div NrOfTimeoutsPerScheduler) rem SchdlrsToUse)  + 2
                                   end,
                               process_flag(scheduler, SchedulerId),
                               erlang:start_timer(Tmo, self(), hej, Opts)
                       end,
                       lists:seq(1, NrOfTimeouts)),
      process_flag(scheduler, 1),
      true = mem_larger_than(Mem),
      case Other of
          false ->
  