anchor.diff:      Start = erlang:statistics(Type),
       timer:sleep(1500),
       End = erlang:statistics(Type),
  -    lists:reverse(lists:sort(load_percentage(lists:sort(Start),lists:sort(End)))).
  +
  +    lists:reverse(
  +      lists:sort(load_percentage(online_statistics(Start),online_statistics(End)))).
  +
  +%% We are only interested in schedulers that are online to remove all
  +%% offline normal and dirty cpu schedulers (dirty io cannot be offline)
  +online_statistics(Stats) ->
  +    Schedulers = erlang:system_info(schedulers),
  +    SchedulersOnline = erlang:system_info(schedulers_online),
  +    DirtyCPUSchedulers = erlang:system_info(dirty_cpu_schedulers),
  +    DirtyCPUSchedulersOnline = erlang:system_info(dirty_cpu_schedulers_online),
  +    DirtyIOSchedulersOnline = erlang:system_info(dirty_io_schedulers),
  +    SortedStats = lists:sort(Stats),
  +    SchedulersStats =
  +        lists:sublist(SortedStats, 1, SchedulersOnline),
  +    DirtyCPUSchedulersStats =
  +        lists:sublist(SortedStats, Schedulers+1, DirtyCPUSchedulersOnline),
  +    DirtyIOSchedulersStats =
  +        lists:sublist(SortedStats, Schedulers + DirtyCPUSchedulers+1, DirtyIOSchedulersOnline),
  +    SchedulersStats ++ DirtyCPUSchedulersStats ++ DirtyIOSchedulersStats.
   
   load_percentage([{Id, WN, TN}|Ss], [{Id, WP, TP}|Ps]) ->
       [100*(WN-WP) div (TN-TP)|load_percentage(Ss, Ps)];
  
positive.code:         HalfDirtyIOHogs = [StartDirtyHog(dirty_io)
                             || _ <- lists:seq(1, lists:max([1,DirtyIOSchedulers div 2]))],
          HalfLoad = lists:sum(get_load(Type)) div TotLoadSchedulers,
          if Schedulers < 2, HalfLoad > 80 -> ok; %% Ok only one scheduler online and one hog
             %% We want roughly 50% load
             HalfLoad > 40, HalfLoad < 60 -> ok;
             true -> exit({halfload, HalfLoad})
          end,
  
          %% 100% load
          LastHogs = [StartHog() || _ <- lists:seq(1, Schedulers div 2)],
          LastDirtyCPUHogs = [StartDirtyHog(dirty_cpu)
                              || _ <- lists:seq(1, DirtyCPUSchedulers div 2)],
          LastDirtyIOHogs = [StartDirtyHog(dirty_io)
                             || _ <- lists:seq(1, DirtyIOSchedulers div 2)],
          FullScheds = get_load(Type),
          {false,_} = {lists:any(fun(Load) -> Load < 80 end, FullScheds),FullScheds},
          FullLoad = lists:sum(FullScheds) div TotLoadSchedulers,
  
negative.code:     %% Check some IO
      {ok, L} = gen_tcp:listen(0, [{active, true},{reuseaddr,true}]),
      {ok, Port} = inet:port(L),
      _Pid = spawn(fun() ->
                           {ok, _S} = gen_tcp:accept(L),
                           (fun F() -> receive _M -> F() end end)()
                  end),
      {ok, C} = gen_tcp:connect("localhost", Port, []),
      [begin gen_tcp:send(C,"hello"),timer:sleep(1) end || _ <- lists:seq(1,100)],
  