anchor.diff:  %% keys in the dict pointing to empty list if they are disconnected or a
   %% socket pid if they are connected.
   %%
  -maybe_connect({Name, _, _} = Node, Connections0) ->
  +maybe_connect({Name, _, _} = Node, {Connections0, MemberParallelism}) ->
  +    %% Compute desired parallelism.
  +    Parallelism  = case dict:find(Node, MemberParallelism) of
  +        {ok, V} ->
  +            %% We learned about a node via an explicit join.
  +            V;
  +        error ->
  +            %% We learned about a node through a state merge; assume the
  +            %% default unless later specified.
  +            partisan_config:get(parallelism, ?PARALLELISM)
  +    end,
  +
  +    lager:debug("Connecting ~p with parallelism: ~p",
  +                [Node, Parallelism]),
  +
  +    %% Initiate connections.
       Connections = case dict:find(Name, Connections0) of
           %% Found in dict, and disconnected.
           {ok, []} ->
               case connect(Node) of
  -                {ok, Pids} ->
  -                    dict:store(Name, [Pids], Connections0);
  +                {ok, Pid} ->
  +                    dict:store(Name, [Pid], Connections0);
                   _ ->
                       dict:store(Name, [], Connections0)
               end;
           %% Found in dict and connected.
  -        {ok, _Pids} ->
  -            Connections0;
  +        {ok, Pids} ->
  +            lager:debug("Node ~p connected with ~p processes of ~p processes.",
  +                        [Node, length(Pids), Parallelism]),
  +            case length(Pids) < Parallelism of
  +                true ->
  +                    case connect(Node) of
  +                        {ok, Pid} ->
  +                            dict:store(Name, [Pid], Connections0);
  +                        _ ->
  +                            dict:store(Name, [], Connections0)
  +                    end;
  +                false ->
  +                    Connections0
  +            end;
           %% Not present; disconnected.
           error ->
               case connect(Node) of
  
positive.code:     Members = [P || {P, _, _} <- members(Membership)],
      {reply, {ok, Members}, State};
  
  handle_call(get_local_state, _From, #state{membership=Membership}=State) ->
      {reply, {ok, Membership}, State};
  
  
negative.code: 
  %% @doc Attempt to join a remote node.
  join(Node) ->
      Parallelism = partisan_config:get(parallelism, ?PARALLELISM),
      ct:pal("Joining node with parallelism: ~p", [Parallelism]),
      join(Node, Parallelism).
  
  %% @doc Attempt to join a remote node and maintain multiple connections.
  join(Node, NumConnections) ->
  