The aim of this project is to measure the performances of actor model frameworks such as Akka.Net, Proto.Actor, Orleans. At the moment there are only Akka.Net and Proto.Actor benchmarks.

Skynet is a benchmark measuring actor creation performance.

Creates an actor (goroutine, whatever), which spawns 10 new actors, each of them spawns 10 more actors, etc. until one million actors are created on the final level. Then, each of them returns back its ordinal number (from 0 to 999999), which are summed on the previous level and sent back upstream, until reaching the root actor. (The answer should be 499999500000).

Scala akka codes in the skynet repository are adapted to Akka.Net and Proto.Actor.

Creates receive and echo actors as many as the number of cores, maps them to each other and sends messages between them. Measures how long to create N number of messages and how long it takes to send messages between receive and echo actors.

There are two kinds of ping pong benchmark and both of them have both in process and remote benchmarks. The benchmark named InProc is adapted from Proto.Actor repository and PingPong is adepted from Akka.Net repository.

Like the ping pong benchmark, actors and n number of messages are created. Actors calculates pi number as many as messages and send it back. It is aimed to simulate real world scenarios by making a calculation in Actors. There are both in process and remote benchmark examples.

You can use the dotnet CLI commands, or use Visual Studio 2017, or use Visual Studio Code. For VS Code user both launch.json and tasks.json files created and configurations added for all different benchmarks.

• Solution strucutered under two solution folders, Akka.Net and Proto.Actor.
• All benchmarks were run on a computer with Intel i7-6700HQ @ 2.6 GHz and 16 GB RAM configuration.
• Benchmark settings are separated into sections in the benchmark-settings.json file that added as link to all benchmark projects. Changes made in this file apply to both the Akka.Net and Proto.Actor benchmarks for the same benchmark.
• There is also seperate .hocon files for Akka.Net benchmarks.

You can change SkynetBenchmarkSettings.TimesToRun value in benchmark-settings.json for benchmark repeats.

19,269.76 ms avg for 3 repeats.

1,808 ms avg for 3 repeats.

You can change PingPongSettings.TimesToRun value for benchmark repeats and PingPongSettings.Throughputs for set throughput values in benchmark-settings.json.

The benchmark actor was separately tested, derived from both ActorBase and ReceiveActor.

ActorBase first start time: 15.12 ms ReceiveActor first start time: 42.80 ms

The benchmark actor is derived from IActor.

Actor first start time: 24.10 ms

The same settings were used in the Akka.Net benchmark since this benchmark was adapted from the Proto.Actor repository. In other words, 2048-capacity BoundedMailbox was used as a mailbox. Normally Akka.Net's default mailbox is unbounded mailbox. When unbounded mailbox was used on Akka.Net, two times increase in msg/sec was observed. You can also get different results by using ForkJoinDispatcher on Akka.Net and changing the thread numbers. I could'nt benchmark it for Proto.Actor because I could not find ForkJoinDispatcher.

In benchmark-settings.json file you can change dispatcher and mailbox types, for capacity and thread count, you need to change them in hocon file for Akka.Net.

"InprocBenchmarkSettings": {
  "MessageCount": 1000000,
  "BatchSize": 100,
   "DispatcherType": "custom-dispatcher",
   "MailboxType": "bounded-mailbox",
   //"DispatcherType": "custom-fork-join-dispatcher",
   //"MailboxType": "unbounded-mailbox",
   "Throughputs": [ 100, 200, 300, 400, 500, 600, 700, 800, 900 ]
   //"Throughputs": [ 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 400, 500, 600, 700, 800, 900 ]
   //"Throughputs": [ 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 ]
},

Is Server GC False

Avg Msg/sec : 22,902,699.1111111

Is Server GC False

Avg Msg/sec : 103,978,849.555556

Is Server GC False

Avg Msg/sec : 56,670,058.4444444

Is Server GC False

Avg Msg/sec : 99,640,941.5555556

This benchmark is adaptation of ping pong benchmark to the remote. The Benchmarks were prepared for both Proto.Actor and Akka.Net using both Google.Protobuff and Wire serializers. Hyperion serializer (fork of the Wire serializer) for Akka.Net, was used.

Within the Messages project there are both common messages and their Protobuf generated versions. All Protobuf messages are automatically generated on the prebuild event of the Messages project.

In the benchmark-settings.json file you can change the message count (that will send between nodes) and the ip and port values for Node1, Node2. For Akka.Net you also need to change ip and ports from hocon files for Node1 and Node2.

"RemoteBenchmarkSettings": {
  "MessageCount": 300000,
  "Node1Ip": "127.0.0.1",
  "Node2Ip": "127.0.0.1",
  "Node1Port": 8090,
  "Node2Port": 8091
}

In order to switch to Protobuff serializer in Akka.Net benchmarks, You need to comment the line using ActorModelBenchmarks.Messages; and uncomment the line using ActorModelBenchmarks.Messages.Protobuf; inside Program.cs for both Node1 and Node2.

You need to do the same think for the Proto.Actor benchmarks, additionally you need to replace the SwitchToWire method with the SwitchToProtobuf method inside Program.cs for both Node1 and Node2.

Elapsed 00:00:07.0944259
Throughput 84,573.4395506196 msg / sec

Elapsed 00:00:00.5927615
Throughput 1,012,211.48809428 msg / sec

Elapsed 00:00:06.7227722
Throughput 89,248.8964597075 msg / sec

Elapsed 00:00:00.2773321
Throughput 2,163,471.15966742 msg / sec

All these results were observed in the local environment (127.0.0.1). To make the benchmarks a bit more realistic, Node2 of both Akka.Net and Proto.actor has moved a Lubuntu 17.10 virtual machine with 2.6 GHz four core 2 GB RAM configuration on VMWare and benchmarks were repeated.

Elapsed 00:00:17.1707912
Throughput 34,943.0607484179 msg / sec

Elapsed 00:00:09.3672863
Throughput 64,052.7022217737 msg / sec

Elapsed 00:00:16.3266224
Throughput 36,749.7933926615 msg / sec

Elapsed 00:00:08.3608386
Throughput 71,763.1362959213 msg / sec

On the remote Proto.Actor is still twice as fast, but it has not reached million msg/sec like it was in the local environment.

Also, if you set the logging level to WARNING on Akka.Net, you get a warning as follows;

[WARNING][3/1/2018 5:38:45 PM][Thread 0013][[akka://remote-sys/system/endpointManager/reliableEndpointWriter-akka.tcp%3A%2F%2Fremote-sys%40192.168.135.128%3A8091-1/endpointWriter#1364445640]] [143971] buffered messages in EndpointWriter for [akka.tcp://[email protected]:8091]. You should probably implement flow control to avoid flooding the remote connection.

Messages are being buffered. You can tweak the DotNetty pool-size, socket-worker-pool values to achieve different results.