fix(benchmarks): restore server call admission hot-path benchmark

.github/actions/allocation-gate/action.yml

@@ -31,6 +31,16 @@ runs:
         --allocation-gate-self-test
         --output "${{ inputs.artifact-directory }}/self-test.json"
 
+    - name: Server call admission benchmark smoke test
+      shell: bash
+      run: >-
+        dotnet run
+        --project test/SharpLink.Benchmarks/SharpLink.Benchmarks.csproj
+        -c Release
+        --no-build
+        --
+        --server-call-admission-smoke-test
+
     - name: Enforce allocation budgets
       shell: bash
       env:

eng/perf/README.md

@@ -30,6 +30,15 @@ dotnet run --project test/SharpLink.Benchmarks/SharpLink.Benchmarks.csproj \
   --output artifacts/perf/allocation-gate-self-test.json
 ```
 
+The server call-admission benchmark also has a fast smoke test that initializes its real TCP-backed
+benchmark environment, acquires and releases one call slot, and cleans up without running the full
+BenchmarkDotNet measurement suite. CI runs this after building the benchmark project:
+
+```bash
+dotnet run --project test/SharpLink.Benchmarks/SharpLink.Benchmarks.csproj \
+  -c Release --no-build -- --server-call-admission-smoke-test
+```
+
 A negative-control run can inject managed allocation into each measured target operation:
 
 ```bash

test/SharpLink.Benchmarks/Program.cs

@@ -38,6 +38,12 @@ public static async Task Main(string[] args)
             AllocationGateRunner.RunSelfTests(args[1..]);
             return;
         }
+        if (args.Length > 0 && string.Equals(
+            args[0], "--server-call-admission-smoke-test", StringComparison.Ordinal))
+        {
+            await ServerCallAdmissionHotPathBenchmarks.RunSmokeTestAsync();
+            return;
+        }
         if (args.Length > 0 && string.Equals(
             args[0], "--unsafe-blit-padding-evidence", StringComparison.Ordinal))
         {

test/SharpLink.Benchmarks/ServerCallAdmissionHotPathBenchmarks.cs

@@ -1,4 +1,3 @@
-using System.Collections.Concurrent;
 using System.Linq;
 using System.Reflection;
 using BenchmarkDotNet.Attributes;
@@ -31,23 +30,34 @@ public async Task Setup()
                 options.FlowControl.MaxConcurrentCallsPerServer = 1_024;
             });
 
-        _server = (SharpLinkServer)(typeof(BenchmarkEnvironment).GetField(
-            "_server",
-            BindingFlags.Instance | BindingFlags.NonPublic)
-            ?.GetValue(_environment)
-            ?? throw new InvalidOperationException("Cannot resolve benchmark server."));
-        var connections = (ConcurrentDictionary<string, ServerConnectionState>)(
-            typeof(SharpLinkServer).GetField(
-                "_connections",
+        _server = (SharpLinkServer)_environment.Server;
+        var registry = typeof(SharpLinkServer).GetField(
+                "_connectionRegistry",
                 BindingFlags.Instance | BindingFlags.NonPublic)
-            ?.GetValue(_server)
-            ?? throw new InvalidOperationException("Cannot resolve benchmark connection table."));
-        _connection = connections.Values.Single();
+            ?.GetValue(_server) as ServerConnectionRegistry
+            ?? throw new InvalidOperationException("Cannot resolve benchmark connection registry.");
+        _connection = registry.SnapshotActive().Single();
     }
 
     [GlobalCleanup]
     public async Task Cleanup() => await _environment.DisposeAsync();
 
+    // Exercise GlobalSetup and a balanced admission without a full BenchmarkDotNet measurement run.
+    internal static async Task RunSmokeTestAsync()
+    {
+        var benchmark = new ServerCallAdmissionHotPathBenchmarks();
+        await benchmark.Setup();
+        try
+        {
+            if (benchmark.AcquireAndRelease() != 0)
+                throw new InvalidOperationException("Call-admission benchmark did not release its capacity.");
+        }
+        finally
+        {
+            await benchmark.Cleanup();
+        }
+    }
+
     [Benchmark]
     public int AcquireAndRelease()
     {