anchor.diff:        [default_manager_test]},
   
        {with_parallelism, [],
  -      [default_manager_test]},
  +      [default_manager_test,
  +       performance_test]},
        
        {with_channels, [],
         [default_manager_test]},
  
positive.code:                             end
                          end, Channels)
                    end, Nodes),
  
      case os:getenv("PROFILE", false) of
          "true" ->
              %% Perform end to end messaging between two nodes.
              [{_Name1, Node1}, {_Name2, Node2}|_] = Nodes,
  
              ReceiverFun = fun() ->
                  receive
                      _ ->
                          ok
                  end,
                  receive
                      _ ->
                          ok
                  end
              end,
              Node2ReceiverPid = rpc:call(Node2, erlang, spawn, [ReceiverFun]),
  
              ct:pal("Enabling eprof on ~p", [Node1]),
              {ok, _} = rpc:call(Node1, eprof, start, []),
  
              ct:pal("Sending a profiled message from ~p to ~p, ~p", [Node1, Node2, Node2ReceiverPid]),
              Object = rand_bits(10 * 1024 * 1024 * 8),
  
              SendFun = fun() ->
                  ok = Manager:forward_message(Node2, undefined, Node2ReceiverPid, Object, [])
              end,
              {ok, ok} = rpc:call(Node1, eprof, profile, [SendFun]), 
              {ok, ok} = rpc:call(Node1, eprof, profile, [SendFun]), 
  
              Suffix = case ?config(parallelism, Config) of
                  undefined ->
                      "partisan";
                  Conns ->
                      "partisan-" ++ integer_to_list(Conns)
              end,
  
              timer:sleep(2000),
  
              ok = rpc:call(Node1, eprof, log, ["/mnt/c/Users/chris/GitHub/unir/_checkouts/partisan/eprof-" ++ Suffix]),
              ok = rpc:call(Node1, eprof, analyze, []),
              ct:pal("Message sent, and profile completed!", []);
          _ ->
              ok
      end,
  
      %% Stop nodes.
      stop(Nodes),
  
negative.code: 
      ok.
  
  performance_test(Config) ->
      %% Use the default peer service manager.
      Manager = partisan_default_peer_service_manager,
  
      %% Specify servers.
      Servers = node_list(1, "server", Config),
  
      %% Specify clients.
      Clients = node_list(1, "client", Config),
  
      %% Start nodes.
      Nodes = start(default_manager_test, Config,
                    [{partisan_peer_service_manager, Manager},
                     {servers, Servers},
                     {clients, Clients}]),
  
      %% Pause for clustering.
      timer:sleep(1000),
  
      [{_, Node1}, {_, Node2}] = Nodes,
      Concurrency = 4,
      NumMessages = 100,
      BenchPid = self(),
  
      %% Prime a binary at each node.
      ct:pal("Generating binaries!"),
      Binary = rand_bits(1 * 1024 * 1024 * 8),
  
      lists:foreach(fun(N) ->
          ct:pal("Installing binary at node ~p.", [N]),
          ok = rpc:call(N, partisan_config, set, [echo_binary, Binary])
      end, [Node1, Node2]),
  
      %% Spawn processes to send receive messages on node 1.
      ct:pal("Spawning processes."),
      SenderPids = lists:map(fun(_) ->
          ReceiverFun = fun() ->
              receiver(Manager, BenchPid, NumMessages)
          end,
          ReceiverPid = rpc:call(Node2, erlang, spawn, [ReceiverFun]),
  
          SenderFun = fun() ->
              sender(Manager, Node2, ReceiverPid, NumMessages)
          end,
          SenderPid = rpc:call(Node1, erlang, spawn, [SenderFun]),
          SenderPid
      end, lists:seq(1, Concurrency)),
  
      %% Start bench.
      ProfileFun = fun() ->
          %% Start sending.
          lists:foreach(fun(SenderPid) ->
              SenderPid ! start
          end, SenderPids),
  
          %% Wait for them all.
          bench_receiver(Concurrency)
      end,
      {Time, _Value} = timer:tc(ProfileFun),
  
      ct:pal("Time: ~p", [Time]),
  
      %% Stop nodes.
      stop(Nodes),
  
      ok.
  
  default_manager_test(Config) ->
      %% Use the default peer service manager.
      Manager = partisan_default_peer_service_manager,
  