Benchmark: gRPC for .NET rows in the compare mode

--compare now also hosts gRPC for .NET (Grpc.AspNetCore 2.84.0, HTTP/2 +
protobuf) on the same Kestrel, answering the benchmark's five calls from
Protos/calculator.proto, and drives it with Grpc.Net.Client in the same shape
as the other rows: 16 channels with 256 calls in flight each. Two rows: unary
calls, and one bidirectional stream per channel with batched writes
(BufferHint on all but the last message of a refill; the server flushes when
its input runs dry, the once-per-read-group flush JsonRpcConnectionHandler
does). protobuf has no decimal, so Test2 uses the units/nanos DecimalValue
message; nullable values use proto3 optional. Every reply is checked.

Two 3 s runs: unary 142-183k RPC/s, stream 173-182k. The gRPC client shares the
8 cores with the server (there is no cheap raw client for HTTP/2 + protobuf),
which the README says; one channel alone reaches about 130k unary calls/s.

Also: the header line prints NuGet package versions (StreamJsonRpc 2.25.29,
not the 2.25.0.0 assembly version); the chart labels a sub-million range that
rounds to one value as that value; --compare help text names gRPC.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: Astn

README.md

@@ -233,7 +233,7 @@ Registering a pre- or post-process handler switches the affected session onto a
 ```
 dotnet run -c Release --project TestServer_Console -- --sync 3      # library only, 1..N threads (add a thread count, e.g. --sync 3 1, for one row)
 dotnet run -c Release --project TestServer_Console -- --kestrel 3   # through the AspNetCore package, HTTP and TCP
-dotnet run -c Release --project TestServer_Console -- --compare 3   # the same requests through StreamJsonRpc, side by side
+dotnet run -c Release --project TestServer_Console -- --compare 3   # the same calls through StreamJsonRpc and gRPC for .NET, side by side
 dotnet run -c Release --project TestServer_Console                  # menu: Enter = Task mode, s = sync, k = Kestrel, x = compare, q = quit
 dotnet run --project samples/WasmHost                               # browser: "Run benchmark" on the page
 ```
@@ -289,11 +289,11 @@ Sync beats Task mode because Task mode measures the .NET thread pool and per-req
 
 The TCP client keeps 256 requests in flight per connection and refills from a precomputed ring of request bytes with one `Send` per refill; the server side is the same `Process` call the HTTP endpoint makes, fed by `JsonFramer`.
 
-### Versus StreamJsonRpc
+### Versus StreamJsonRpc and gRPC
 
-[StreamJsonRpc](https://www.nuget.org/packages/StreamJsonRpc) is Microsoft's JSON-RPC library, the one behind Visual Studio and the language-server stack. `--compare` hosts both libraries on the same Kestrel TCP listener and drives them with the same pipelining client (16 connections, 256 requests in flight each), so the only variable is the library answering. StreamJsonRpc requires the `jsonrpc` member, so every request in this mode carries `"jsonrpc":"2.0"`, which is why the JSON-RPC.Net rows are a little below the other tables. Each row was run twice for 3 s; both results are shown.
+[StreamJsonRpc](https://www.nuget.org/packages/StreamJsonRpc) is Microsoft's JSON-RPC library, the one behind Visual Studio and the language-server stack. `--compare` hosts both libraries on the same Kestrel TCP listener and drives them with the same pipelining client (16 connections, 256 requests in flight each), so the only variable is the library answering. StreamJsonRpc requires the `jsonrpc` member, so every request in this mode carries `"jsonrpc":"2.0"`, which is why the JSON-RPC.Net rows are a little below the other tables. The same mode also hosts [gRPC for .NET](https://learn.microsoft.com/aspnet/core/grpc/) (HTTP/2, protobuf) on the same Kestrel, answering the same five calls from [calculator.proto](TestServer_Console/Protos/calculator.proto), driven by its own client with the same shape: 16 channels, 256 calls in flight each. Each row was run twice for 3 s; both results are shown.
 
-![JSON-RPC.Net vs StreamJsonRpc](benchmarks/charts/compare-streamjsonrpc.svg)
+![JSON-RPC.Net vs StreamJsonRpc vs gRPC](benchmarks/charts/compare-streamjsonrpc.svg)
 
 | Library and path | RPC/s |
 | --- | ---: |
@@ -304,9 +304,13 @@ The TCP client keeps 256 requests in flight per connection and refills from a pr
 | StreamJsonRpc over Kestrel TCP, newline framing, System.Text.Json formatter | 1.05 M to 1.10 M |
 | StreamJsonRpc over Kestrel TCP, `Content-Length` framing, System.Text.Json formatter | 1.14 M to 1.18 M |
 | StreamJsonRpc over Kestrel TCP, `Content-Length` framing, Json.NET formatter (its default) | 515 k to 518 k |
+| gRPC for .NET, unary calls over HTTP/2 (Grpc.Net.Client, 16 channels × 256 in flight) | 142 k to 183 k |
+| gRPC for .NET, one bidirectional stream per channel, 256 in flight, batched writes | 173 k to 182 k |
 
 StreamJsonRpc 2.25.29, defaults apart from the formatter and framing named in each row. It is a full bidirectional RPC framework (client proxies, cancellation, progress, marshaled objects, events), and its server side has no "document in, document out" call, so its in-process row is a pair of `System.IO.Pipelines` pipes, the closest it has to a direct call. The comparison is of the server side answering the same five requests; on that measure JSON-RPC.Net is about 10× faster on the same connections with the same JSON library underneath.
 
+gRPC for .NET 2.84.0 with default settings apart from Kestrel's `MaxStreamsPerConnection` (raised to 256 so the pipeline depth is not capped at 100). protobuf has no `decimal`, so `Test2` carries the units/nanos `DecimalValue` message the gRPC docs recommend; nullable values use proto3 `optional`. The gRPC rows are a different kind of measurement from the rows above them: there is no cheap raw client for HTTP/2 + protobuf, so the client is Grpc.Net.Client on the same 8 cores as the server, and the figure is what a .NET caller and a .NET service get end to end. One channel alone reaches about 130 k unary calls per second; sixteen channels do not scale much further because client and server compete for the same cores. The streaming row batches its writes the way the TCP client does (BufferHint on every message but the last of a refill), and the server flushes only when its input runs dry, the same once-per-read-group flush `JsonRpcConnectionHandler` does.
+
 ### WebAssembly: in the browser
 
 The [WasmHost sample](samples/WasmHost/README.md) compares JSON-RPC through JS interop with plain Blazor interop for the same `add(1, 2)` under the .NET 10 interpreter in Chrome. A plain `DotNet.invokeMethod` add costs about 64 µs (the JSON marshalling Blazor does); a JSON-RPC document written as UTF-8 straight into WebAssembly memory and run through a `[JSExport]` costs 53 µs, a batch of 100 that way reaches 27k RPC/s, and a typed `[JSExport]` add takes 0.35 µs. The interpreter is the bottleneck; `dotnet publish` AOT-compiles the sample when the `wasm-tools` workload is installed.

TestServer_Console/CompareBenchmark.cs

@@ -13,6 +13,7 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Connections;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Server.Kestrel.Core;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using StreamJsonRpc;
@@ -26,7 +27,8 @@ namespace TestServer_Console;
 /// pipelining client, so the only variable is the RPC library. Every request carries <c>"jsonrpc":"2.0"</c>
 /// because StreamJsonRpc requires it. StreamJsonRpc has no "document in, document out" call, so its in-process
 /// row runs over a pair of <see cref="Pipe"/>s, the closest thing it has to a direct call; a sequential
-/// proxy row shows what a typical <c>await proxy.AddAsync(1, 2)</c> costs end to end.
+/// proxy row shows what a typical <c>await proxy.AddAsync(1, 2)</c> costs end to end. gRPC for .NET answers the
+/// same five calls on an HTTP/2 listener of the same Kestrel (<see cref="GrpcCompare"/>), unary and streamed.
 /// </summary>
 internal static class CompareBenchmark
 {
@@ -65,7 +67,7 @@ internal static async Task RunAsync(Action<string> print, double seconds = 3, in
         var newLine = Requests.Select(r => Encoding.UTF8.GetBytes(r + "\n")).ToArray();
         var header = Requests.Select(r => Encoding.UTF8.GetBytes("Content-Length: " + Encoding.UTF8.GetByteCount(r) + "\r\n\r\n" + r)).ToArray();
 
-        int oursPort = KestrelBenchmark.FreePort(), sjrNewLineStjPort = KestrelBenchmark.FreePort(), sjrHeaderStjPort = KestrelBenchmark.FreePort(), sjrHeaderNewtonsoftPort = KestrelBenchmark.FreePort();
+        int oursPort = KestrelBenchmark.FreePort(), sjrNewLineStjPort = KestrelBenchmark.FreePort(), sjrHeaderStjPort = KestrelBenchmark.FreePort(), sjrHeaderNewtonsoftPort = KestrelBenchmark.FreePort(), grpcPort = KestrelBenchmark.FreePort();
         var builder = WebApplication.CreateBuilder();
         builder.Logging.ClearProviders();
         builder.WebHost.ConfigureKestrel(k =>
@@ -74,14 +76,18 @@ internal static async Task RunAsync(Action<string> print, double seconds = 3, in
             k.Listen(IPAddress.Loopback, sjrNewLineStjPort, l => l.Run(c => ServeStreamJsonRpc(c, Framing.NewLine, Formatter.SystemTextJson)));
             k.Listen(IPAddress.Loopback, sjrHeaderStjPort, l => l.Run(c => ServeStreamJsonRpc(c, Framing.Header, Formatter.SystemTextJson)));
             k.Listen(IPAddress.Loopback, sjrHeaderNewtonsoftPort, l => l.Run(c => ServeStreamJsonRpc(c, Framing.Header, Formatter.Newtonsoft)));
+            k.Listen(IPAddress.Loopback, grpcPort, l => l.Protocols = HttpProtocols.Http2);
+            k.Limits.Http2.MaxStreamsPerConnection = pipeline;   // Kestrel's default of 100 would cap the gRPC rows below the pipeline depth
         });
         builder.Services.AddJsonRpc();
+        builder.Services.AddGrpc();
         var app = builder.Build();
+        app.MapGrpcService<GrpcCompare.CalculatorGrpc>();
         await app.StartAsync();
 
         try
         {
-            print($"JSON-RPC.Net {typeof(JsonRpcProcessor).Assembly.GetName().Version} vs StreamJsonRpc {typeof(JsonRpc).Assembly.GetName().Version}; Kestrel TCP on loopback, {clients} clients, pipeline {pipeline}, {seconds:0.#} s per row\n");
+            print($"JSON-RPC.Net {typeof(JsonRpcProcessor).Assembly.GetName().Version} vs StreamJsonRpc {PackageVersion(typeof(JsonRpc))} vs gRPC for .NET {PackageVersion(typeof(Grpc.Net.Client.GrpcChannel))}; Kestrel on loopback, {clients} clients, pipeline {pipeline}, {seconds:0.#} s per row\n");
             var rows = new List<BenchmarkRunner.ChartRow>();
             var session = Handler.DefaultSessionId();
 
@@ -118,7 +124,18 @@ internal static async Task RunAsync(Action<string> print, double seconds = 3, in
                 print($"  {label} done ({count / secs:N0} RPC/s)");
             }
 
-            BenchmarkRunner.PrintBarChart("JSON-RPC.Net vs StreamJsonRpc - RPC/s", "Library / transport", rows);
+            // ---- gRPC for .NET on the same Kestrel: HTTP/2 + protobuf, one channel per client
+            await GrpcCompare.UnaryRun(grpcPort, clients, pipeline, 0.5);
+            (count, secs) = await GrpcCompare.UnaryRun(grpcPort, clients, pipeline, seconds);
+            rows.Add(new BenchmarkRunner.ChartRow("gRPC for .NET unary, HTTP/2", count / secs, $"{count,12:N0} RPCs  {clients} channels, {pipeline} calls in flight each"));
+            print($"  gRPC unary done ({count / secs:N0} RPC/s)");
+
+            await GrpcCompare.StreamRun(grpcPort, clients, pipeline, 0.5);
+            (count, secs) = await GrpcCompare.StreamRun(grpcPort, clients, pipeline, seconds);
+            rows.Add(new BenchmarkRunner.ChartRow("gRPC for .NET bidirectional stream", count / secs, $"{count,12:N0} RPCs  {clients} streams, {pipeline} calls in flight each"));
+            print($"  gRPC stream done ({count / secs:N0} RPC/s)");
+
+            BenchmarkRunner.PrintBarChart("JSON-RPC.Net vs StreamJsonRpc vs gRPC - RPC/s", "Library / transport", rows);
         }
         finally
         {
@@ -127,6 +144,15 @@ internal static async Task RunAsync(Action<string> print, double seconds = 3, in
         }
     }
 
+    /// <summary>The NuGet package version of an assembly (its informational version without the commit suffix).</summary>
+    private static string PackageVersion(Type t)
+    {
+        var info = t.Assembly.GetCustomAttributes(typeof(System.Reflection.AssemblyInformationalVersionAttribute), false);
+        var text = info.Length > 0 ? ((System.Reflection.AssemblyInformationalVersionAttribute)info[0]).InformationalVersion : t.Assembly.GetName().Version.ToString();
+        int plus = text.IndexOf('+');
+        return plus > 0 ? text.Substring(0, plus) : text;
+    }
+
     private static IJsonRpcMessageHandler CreateHandler(PipeWriter writer, PipeReader reader, Framing framing, Formatter formatter)
     {
         IJsonRpcMessageTextFormatter f = formatter == Formatter.SystemTextJson ? new SystemTextJsonFormatter() : new JsonMessageFormatter();