public void NewActorSelectionOnNewActorThroughput(BenchmarkContext context)
 {
     var actorRef = System.ActorOf(_oneMessageBenchmarkProps); // create a new actor every time
     System.ActorSelection(actorRef.Path).Tell("foo"); // send that actor a message via selection
     _resetEvent.Wait();
     _resetEvent.Reset();
 }

 public void OneWayThroughputBenchmark(BenchmarkContext context)
 {
     for (var i = 0; i < MessageCount; i++)
     {
         Send(message);
     }
     _resentEvent.Wait();
 }

 public void UntypedActorMemoryFootprint(BenchmarkContext context)
 {
     for (var i = 0; i < ActorCreateNumber; i++)
     {
         _system.ActorOf(UntypedActorProps);
         _createActorThroughput.Increment();
     }
 }

 public void Setup(BenchmarkContext context)
 {
     _selectionOpCounter = context.GetCounter(ActorSelectionCounterName);
     System = ActorSystem.Create("MailboxThroughputSpecBase" + Counter.GetAndIncrement());
     _receiver = System.ActorOf(Props.Create(() => new BenchmarkActor(_selectionOpCounter, NumberOfMessages, _resetEvent)));
     _receiverActorPath = _receiver.Path;
     _oneMessageBenchmarkProps = Props.Create(() => new BenchmarkActor(_selectionOpCounter, 1, _resetEvent));
 }

 public void AddThroughput_IterationsMode(BenchmarkContext context)
 {
     for (var i = 0; i < AcceptableMinAddThroughput; i++)
     {
         dictionary.Add(i, i);
         addCounter.Increment();
     }
 }

        public void SetUp(BenchmarkContext context)
        {
            _inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName);
            _counterHandlerInbound = new CounterHandlerInbound(_inboundThroughputCounter);
            _outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName);
            _counterHandlerOutbound = new CounterHandlerOutbound(_outboundThroughputCounter);

            channel = new EmbeddedChannel(_counterHandlerOutbound, _counterHandlerInbound);
        }

 public void FiberThroughputSingleDelegate(BenchmarkContext context)
 {
     for (var i = 0; i < ExecutorOperations;)
     {
         _executor.Execute(Operation);
         ++i;
     }
     SpinWait.SpinUntil(() => eventCount.Current >= ExecutorOperations, TimeSpan.FromSeconds(3));
 }

        public void Setup(BenchmarkContext context)
        {
            _counter = context.GetCounter("TestCounter");

            var fixture = new Fixture();
            fixture.RepeatCount = 100;
            _list = fixture.Create<List<string>>();
            _algorithm = new Algorithm1();
        }

 public void ConcurrentCircularBufferWithResizing(BenchmarkContext context)
 {
     for (var i = 0; i < ResizedItemCount;)
     {
         concurrentCircularBuffer.Add(i);
         _insertsCounter.Increment();
         ++i;
     }
 }

 public void Setup(BenchmarkContext context)
 {
     _actorSystem = ActorSystem.Create("MaterializationBenchmark",
         ConfigurationFactory.FromResource<AkkaSpec>("Akka.Streams.TestKit.Tests.reference.conf"));
     _actorSystem.Settings.InjectTopLevelFallback(ActorMaterializer.DefaultConfig());
     _materializerSettings =
         ActorMaterializerSettings.Create(_actorSystem).WithDispatcher("akka.test.stream-dispatcher");
     _materializer = _actorSystem.Materializer(_materializerSettings);
 }

 public void Setup(BenchmarkContext context)
 {
     _createMailboxThroughput = context.GetCounter(CreateThroughputCounter);
     _mailboxes = new List<Mailbox>(MailboxCreateNumber);
     _unboundedMailboxType = new UnboundedMailbox();
     _boundedMailboxType = new BoundedMailbox(_actorSystem.Settings, MailboxConfig);
     _unboundedDequeBasedMailboxType = new UnboundedDequeBasedMailbox(_actorSystem.Settings, MailboxConfig);
     _boundedDequeBasedMailboxType = new BoundedDequeBasedMailbox(_actorSystem.Settings, MailboxConfig);
 }

 public void Benchmark(BenchmarkContext context)
 {
     for (var i = 0; i < MailboxMessageCount;)
     {
         _receiver.Tell(string.Empty);
         ++i;
     }
     _resetEvent.Wait(); //wait up to a second
 }

 public void FiberThroughputDynamicDelegate(BenchmarkContext context)
 {
     for (var i = 0; i < FiberOperations;)
     {
         _fiber.Add(() => Operation());
         ++i;
     }
     SpinWait.SpinUntil(() => eventCount.Current >= FiberOperations, TimeSpan.FromSeconds(3));
 }

 public void MemoryFootprint(BenchmarkContext context)
 {
     var actorPaths = new Address[100000];
     for (var i = 0; i < 100000;)
     {
         actorPaths[i] = new Address("akka", "foo", "localhost", 9091);
         ++i;
         _parseThroughput.Increment();
     }
 }

 public void ReusedActorSelectionOnPreExistingActorThroughput(BenchmarkContext context)
 {
     var actorSelection = System.ActorSelection(_receiverActorPath);
     for (var i = 0; i < NumberOfMessages;)
     {
         actorSelection.Tell("foo");
         ++i;
     }
     _resetEvent.Wait();
 }

        public void Setup(BenchmarkContext context)
        {
            _actorSystem = ActorSystem.Create("FileSourcesBenchmark");
            _materializer = _actorSystem.Materializer();

            _file = CreateFile();

            _fileChannelSource = FileIO.FromFile(_file, BufferSize);
            _fileInputStreamSource = StreamConverters.FromInputStream(() => File.OpenRead(_file.FullName), BufferSize);
            _ioSourceLinesIterator = Source.FromEnumerator(() => File.ReadLines(_file.FullName).Select(ByteString.FromString).GetEnumerator());
        }

 public void TearDown(BenchmarkContext context)
 {
     var shutdownTimeout = TimeSpan.FromSeconds(5);
     try
     {
         _sys?.Terminate().Wait(shutdownTimeout);
     }
     catch (Exception ex)
     {
         context.Trace.Error(ex, $"failed to shutdown actorsystem within {shutdownTimeout}");
     }
 }

 public void PerfSetUp(BenchmarkContext context)
 {
     benchmarkCounter = context.GetCounter(MessagesReceivedCounter);
     StartServer((data, channel) =>
     {
         benchmarkCounter.Increment();
         var serverReceived = ServerReceived.GetAndIncrement();
         if (serverReceived >= MessageCount - 1)
             _resentEvent.Set();
     });
     StartClient();
     message = new byte[MessageLength];
 }

        public void Setup(BenchmarkContext context)
        {
            MsgReceived = context.GetCounter("MsgReceived");
            System = ActorSystem.Create("PerfSys", Config);
            Action<IActorDsl> actor = d => d.ReceiveAny((o, c) =>
            {
                MsgReceived.Increment();
            });
            TestActor = System.ActorOf(Props.Create(() => new Act(actor)).WithDispatcher("calling-thread-dispatcher"), "testactor");

            // force initialization of the actor
            TestActor.Tell("warmup");
            MsgReceived.Decrement();
        }

        public void Setup(BenchmarkContext context)
        {
            MsgReceived = context.GetCounter("MsgReceived");
            System = ActorSystem.Create("PerfSys");
            Action<IActorDsl> actor = d => d.ReceiveAny((o, c) =>
            {
                MsgReceived.Increment();
            });
            TestActor = System.ActorOf(Props.Create(() => new Act(actor)), "testactor");
            var id = TestActor.Ask<ActorIdentity>(new Identify(null), TimeSpan.FromSeconds(3)).Result;

            Mailbox = new Mailbox(new UnboundedMessageQueue());
            Mailbox.SetActor(TestActor.AsInstanceOf<RepointableActorRef>().Underlying.AsInstanceOf<ActorCell>());
        }