anchor.diff:  t_scheduler_poll(Config) ->
       ok = lttng_start_event("org_erlang_otp:scheduler_poll", Config),
   
  +    N = 100,
  +
  +    Me = self(),
  +    Pid = spawn_link(fun() -> tcp_server(Me, {active, N*2}) end),
  +    receive {Pid, accept} -> ok end,
  +
  +    %% We want to create a scenario where the fd is moved into a scheduler
  +    %% pollset, this means we have to send many small packages to the
  +    %% same socket, but not fast enough for them to all arrive at the
  +    %% same time.
  +    {ok, Sock} = gen_tcp:connect("localhost", 5679, [binary, {packet, 2}]),
  +    [begin gen_tcp:send(Sock,txt()), receive ok -> ok end end || _ <- lists:seq(1,N)],
  +
       ok = memory_load(),
  +
  +    [begin gen_tcp:send(Sock,txt()), receive ok -> ok end end || _ <- lists:seq(1,N)],
  +
  +    ok = gen_tcp:close(Sock),
  +    Pid ! die,
  +    receive {Pid, done} -> ok end,
   
       Res = lttng_stop_and_view(Config),
       ok = check_tracepoint("org_erlang_otp:scheduler_poll", Res),
  
positive.code: -export([t_lttng_list/1,
           t_carrier_pool/1,
           t_memory_carrier/1,
           t_async_io_pool/1,
           t_driver_control_ready_async/1,
           t_driver_start_stop/1,
           t_driver_ready_input_output/1,
           t_driver_timeout/1,
  
negative.code:         passive_no_read ->
              receive die -> ok end;
          active ->
              inet:setopts(Sock, [{active, 2}, {packet,2}]),
              receive Msg1 -> io:format("msg1: ~p~n", [Msg1]) end,
              receive Msg2 -> io:format("msg2: ~p~n", [Msg2]) end,
              ok = gen_tcp:close(Sock);
          timeout ->
              Res = gen_tcp:recv(Sock, 2000, 1000),
              io:format("res ~p~n", [Res]);
          {active, Number} when is_number(Number) ->
              inet:setopts(Sock, [{active, Number}, {packet,2}]),
              [begin
                   receive _Msg1 -> Pid ! ok, io:format("msg ~p~n", [I]) end
               end || I <- lists:seq(1,Number)],
              ok = gen_tcp:close(Sock)
      end,
      Pid ! {self(), done},
      ok.
  