anchor.diff:      ok = syn:unregister(Name),
       worker_unregister_on_node(Name + 1, ToName).
   
  +join_on_node(CollectorPid, WorkersPerNode, Pids) ->
  +    %% split pids in workers
  +    PidsPerNode = round(length(Pids) / WorkersPerNode),
  +    {PidsPerWorker, []} = lists:foldl(fun(I, {P, RPids}) ->
  +        {WPids, RestOfPids} = case I of
  +            WorkersPerNode ->
  +                %% last in the loop, get remaining pids
  +                {RPids, []};
  +            _ ->
  +                %% get portion of pids
  +                lists:split(PidsPerNode, RPids)
  +        end,
  +        {[WPids | P], RestOfPids}
  +    end, {[], Pids}, lists:seq(1, WorkersPerNode)),
  +    %% spawn workers
  +    ReplyPid = self(),
  +    lists:foreach(fun(WorkerPids) ->
  +        spawn(fun() ->
  +            StartAt = os:system_time(millisecond),
  +            worker_join_on_node(WorkerPids),
  +            Time = (os:system_time(millisecond) - StartAt) / 1000,
  +            ReplyPid ! {done, Time}
  +        end)
  +    end, PidsPerWorker),
  +    %% wait
  +    Time = wait_done_on_node(CollectorPid, 0, WorkersPerNode),
  +    io:format("----> Joined on node ~p on ~p secs.~n", [node(), Time]).
  +
  +worker_join_on_node([]) -> ok;
  +worker_join_on_node([Pid | PidsTail]) ->
  +    ok = syn:join(?TEST_GROUP_NAME, Pid),
  +    worker_join_on_node(PidsTail).
  +
  +leave_on_node(CollectorPid, WorkersPerNode, Pids) ->
  +    %% split pids in workers
  +    PidsPerNode = round(length(Pids) / WorkersPerNode),
  +    {PidsPerWorker, []} = lists:foldl(fun(I, {P, RPids}) ->
  +        {WPids, RestOfPids} = case I of
  +            WorkersPerNode ->
  +                %% last in the loop, get remaining pids
  +                {RPids, []};
  +            _ ->
  +                %% get portion of pids
  +                lists:split(PidsPerNode, RPids)
  +        end,
  +        {[WPids | P], RestOfPids}
  +    end, {[], Pids}, lists:seq(1, WorkersPerNode)),
  +    %% spawn workers
  +    ReplyPid = self(),
  +    lists:foreach(fun(WorkerPids) ->
  +        spawn(fun() ->
  +            StartAt = os:system_time(millisecond),
  +            worker_leave_on_node(WorkerPids),
  +            Time = (os:system_time(millisecond) - StartAt) / 1000,
  +            ReplyPid ! {done, Time}
  +        end)
  +    end, PidsPerWorker),
  +    %% wait
  +    Time = wait_done_on_node(CollectorPid, 0, WorkersPerNode),
  +    io:format("----> Left on node ~p on ~p secs.~n", [node(), Time]).
  +
  +worker_leave_on_node([]) -> ok;
  +worker_leave_on_node([Pid | PidsTail]) ->
  +    ok = syn:leave(?TEST_GROUP_NAME, Pid),
  +    worker_leave_on_node(PidsTail).
  +
   wait_done_on_node(CollectorPid, Time, 0) ->
       CollectorPid ! {done, node(), Time},
       Time;
  
positive.code:     process_loop/0,
      register_on_node/4,
      unregister_on_node/4,
      wait_registry_propagation/1
  ]).
  -export([
      start_profiling/0,
      stop_profiling/0
  ]).
  
  %% ===================================================================
  %% API
  
negative.code:     ProcessCount = list_to_integer(os:getenv("PROCESS_COUNT", "100000")),
      WorkersPerNode = list_to_integer(os:getenv("WORKERS_PER_NODE", "1")),
      SlavesCount = list_to_integer(os:getenv("NODES_COUNT", "1")),
      SkipRegistry = case os:getenv("SKIP_REGISTRY") of false -> false; _ -> true end,
      SkipGroups = case os:getenv("SKIP_GROUPS") of false -> false; _ -> true end,
  
      ProcessesPerNode = round(ProcessCount / SlavesCount),
  
  