More benchmarks

.vscode/settings.json

@@ -1,6 +1,8 @@
 {
     "cSpell.words": [
         "Backpresure",
-        "Schedulable"
+        "EPYC",
+        "Schedulable",
+        "unscheduling"
     ]
 }

Actors.Benchmarks/AckDelivery.cs → Actors.Benchmarks/AckDeliveryBenchmark.cs

@@ -5,7 +5,7 @@
 
 namespace Actors.Benchmarks;
 
-public class AckDelivery
+public class AckDeliveryBenchmark
 {
     class WorkItem
     {

Actors.Benchmarks/EchoBenchmark.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Threading.Tasks;
+using BenchmarkDotNet;
+using BenchmarkDotNet.Attributes;
+
+namespace Actors.Benchmarks;
+#nullable enable
+
+public class EchoBenchmark
+{
+    class SendPings(int pings)
+    {
+        public int Pings { get; } = pings;
+
+        public TaskCompletionSource Completion { get; } = new TaskCompletionSource();
+    }
+
+    class Ping {}
+
+    class Pong {}
+
+    class PingActor : Actor
+    {
+        internal PongActor? Opponent { get; set; }
+
+        private int remainingMessages;
+
+        private SendPings? sendPings;
+
+        protected override Task Perform(Inbox inbox)
+        {
+            switch (inbox.Receive())
+            {
+                case SendPings message:
+                    this.sendPings = message;
+                    this.remainingMessages = sendPings.Pings;
+                    Opponent!.Send(new Ping());
+                    break;
+
+                case Pong message:
+                    remainingMessages--;
+                    if (remainingMessages > 0)
+                    {
+                        Opponent!.Send(new Ping());
+                    }
+                    else
+                    {
+                        sendPings!.Completion.SetResult();
+                    }
+                    break;
+
+                default:
+                    throw new NotSupportedException();
+            }
+            return Task.CompletedTask;
+        }
+    }
+
+    class PongActor : Actor
+    {
+        internal PingActor? Opponent { get; set; }
+
+        protected override Task Perform(Inbox inbox)
+        {
+            switch (inbox.Receive())
+            {
+                case Ping message:
+                    Opponent!.Send(new Pong());
+                    break;
+
+                default:
+                    throw new NotSupportedException();
+            }
+            return Task.CompletedTask;
+        }
+    }
+
+    private readonly PingActor pingActor = new();
+    private readonly PongActor pongActor = new();
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        pingActor.Opponent = pongActor;
+        pongActor.Opponent = pingActor;
+    }
+
+    [Params(1_000)]
+    public int numMessages;
+
+    [Benchmark]
+    public async Task StartAndWait()
+    {
+        var sendPings = new SendPings(numMessages);
+        pingActor.Send(sendPings);
+        await sendPings.Completion.Task;
+    }
+}

Actors.Benchmarks/FireAndForget.cs → Actors.Benchmarks/FireAndForgetBenchmark.cs

@@ -5,7 +5,7 @@
 
 namespace Actors.Benchmarks;
 
-public class FireAndForget
+public class FireAndForgetBenchmark
 {
     class FireAndForgetWorker : Actor<int>
     {

Actors.Benchmarks/Program.cs

@@ -8,8 +8,9 @@ public class Program
         public static void Main(string[] args)
         {
             var config = DefaultConfig.Instance;
-            BenchmarkRunner.Run<FireAndForget>(config, args);
-            BenchmarkRunner.Run<AckDelivery>(config, args);
+            BenchmarkRunner.Run<FireAndForgetBenchmark>(config, args);
+            BenchmarkRunner.Run<AckDeliveryBenchmark>(config, args);
+            BenchmarkRunner.Run<EchoBenchmark>(config, args);
 
             // Use this to select benchmarks from the console:
             // var summaries = BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, config);

README.md

@@ -45,3 +45,24 @@ Pass the name of an example to run just that. For example, to run the `Batch` ex
 ```sh
 just run Batch
 ```
+
+# Performance
+Most of the overhead in an actor system is in the scheduling of dormant actors when they receive their first message and the subsequent unscheduling when they process their last. We'll call this the 'slow path'.
+
+When an actor is constantly posted work at a rate close to its throughput, it will remain scheduled and the overhead is one monitor entry per `Send()` and one per `Receive()`. We'll call this the 'fast path'.
+
+Benchmarks were run using the following setup:
+
+|            | 
+|-----------------|-------------------------------------
+|Harness          |BenchmarkDotNet v0.13.12             
+|OS               |Ubuntu 22.04.3 LTS (Jammy Jellyfish) 
+|Framework        |.NET SDK 8.0.101
+|Processor        |AMD EPYC 7763, 1 CPU, 4 logical and 2 physical cores, virtualised
+
+Results:
+
+|Path             |Time-cost     |Methodology
+|-----------------|--------------|---------------
+|Fast             |106 ns/op     |FireAndForgetBenchmark, time / number of messages
+|Slow             |1 µs/op       |EchoBenchmark, time / number of messages / 2