anchor.diff:  start() ->
       %% init
       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")),
  +    WorkersPerNode = list_to_integer(os:getenv("WORKERS_PER_NODE", "100")),
  +    SlavesCount = list_to_integer(os:getenv("NODES_COUNT", "2")),
       SkipRegistry = case os:getenv("SKIP_REGISTRY") of false -> false; _ -> true end,
  -    SkipGroups = case os:getenv("SKIP_GROUPS") of false -> false; _ -> true end,
  +    SkipPG = case os:getenv("SKIP_PG") of false -> false; _ -> true end,
   
       ProcessesPerNode = round(ProcessCount / SlavesCount),
   
  -    io:format("-----> Starting benchmark~n"),
  -    io:format("       --> Nodes: ~w / ~w slave(s)~n", [SlavesCount + 1, SlavesCount]),
  -    io:format("       --> Total processes: ~w (~w / slave node)~n", [ProcessCount, ProcessesPerNode]),
  -    io:format("       --> Workers per node: ~w~n~n", [WorkersPerNode]),
  +    io:format("====> Starting benchmark~n"),
  +    io:format("      --> Nodes: ~w / ~w slave(s)~n", [SlavesCount + 1, SlavesCount]),
  +    io:format("      --> Total processes: ~w (~w / slave node)~n", [ProcessCount, ProcessesPerNode]),
  +    io:format("      --> Workers per node: ~w~n~n", [WorkersPerNode]),
   
       %% start nodes
       NodesInfo = lists:foldl(fun(I, Acc) ->
  
positive.code:             io:format("      --> MIN: ~p secs.~n", [lists:min(ReJoinRemoteNodesTimes)]),
              io:format("      --> MAX: ~p secs.~n", [lists:max(ReJoinRemoteNodesTimes)]),
  
              {ReJoinPropagationTimeMs, _} = timer:tc(?MODULE, wait_groups_propagation, [ProcessCount]),
              ReJoinPropagationTime = ReJoinPropagationTimeMs / 1000000,
              io:format("----> Eventual additional time to propagate all to master: ~p secs.~n", [ReJoinPropagationTime]),
  
  
negative.code: 
      %% start syn locally
      ok = syn:start(),
      ok = syn:add_node_to_scopes([?TEST_SCOPE]),
      timer:sleep(1000),
  
      CollectorPid = self(),
  
      case SkipRegistry of
          false ->
              io:format("~n====> Starting REGISTRY benchmark~n~n"),
  
              %% start processes
              RegistryPidsMap = lists:foldl(fun({Node, _FromName, _ToName}, Acc) ->
                  Pids = rpc:call(Node, ?MODULE, start_processes, [ProcessesPerNode]),
                  maps:put(Node, Pids, Acc)
              end, #{}, NodesInfo),
  
              %% start registration
              lists:foreach(fun({Node, FromName, _ToName}) ->
                  Pids = maps:get(Node, RegistryPidsMap),
                  rpc:cast(Node, ?MODULE, register_on_node, [CollectorPid, WorkersPerNode, FromName, Pids])
              end, NodesInfo),
  
  