Perf pass from the Astra review: direct-call invokers, local-state tokenizer, sealing, dead code

Priority 1, throughput. Measured A/B in one session with --sync 2 1 (seven runs):
3.2-4.1 M RPC/s (median 3.6 M) before, 4.0-4.8 M (median 4.4 M) after, on a
machine about 15% slower than the README tables. 745/745 tests on net8.0 and
net10.0 after every step; wire output unchanged.

- RpcMethod compiles a third invoker for the built-in serializer that reads
  parameters through static helpers on JsmnRequestReader and writes results
  through Utf8Json overloads on the concrete PooledByteBufferWriter. Expression
  trees compile to dynamic methods, which get no tiered PGO, so every virtual,
  delegate and interface call inside them was a real indirect call.
- JsmnTokenizer.Parse keeps position, token count, parent, depth and the arrays
  in locals and publishes them once; the string/primitive/bare-key scanners are
  static and return an end index; growth is a cold method. Largest single gain.
- Handler caches the last session hit per thread by reference (P4); the reader
  selects envelope keys by length (P5); Utf8KeyTable is one immutable snapshot
  of bucket heads into a contiguous entry array (P6); dictionary Add is compiled
  (P8); ordered named params use the identity map (P9); Utf8Json.Hash consumes
  eight bytes per step; strings over 512 chars are written in chunks; a nested
  scratch returns its buffers.
- Sealed Handler and JsonRpcContext; static readonly session registry and
  default id; readonly RpcParameter.NameUtf8 and JsonRpcStateAsync fields;
  JsmnToken packs its byte fields first (24 -> 20 bytes).
- Removed Basic.cs, EmptyBatchError, Utf8KeyTable.ReplaceWith/Count, TypePlan.Type,
  the always-true Where, MakeMember's owner argument, PrintFinalIterationStats,
  unused usings and comments that restated the code.
- --sync takes an optional thread count (--sync 2 1 runs the one-thread row).
- docs/reviews: the review itself plus an implementation record; the tokenizer
  header records the upstream jsmn state (unchanged since 2021) and the open
  PRs that were considered.

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

Author: Astn

Json-Rpc/Basic.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace AustinHarris.JsonRpc.Client

Json-Rpc/Client/InProcessJsonRpcClient.cs

@@ -6,28 +6,33 @@ namespace AustinHarris.JsonRpc
     using System.Reflection;
     using System.Threading;
     using AustinHarris.JsonRpc.Invocation;
+    using AustinHarris.JsonRpc.Jsmn;
     using AustinHarris.JsonRpc.Serialization;
     using NonBlocking;
 
-    public class Handler
+    public sealed class Handler
     {
         #region Members
         private static int _sessionHandlerMasterVersion = 1;
         [ThreadStatic]
         private static Dictionary<string, Handler> _sessionHandlersLocal;
         [ThreadStatic]
         private static int _sessionHandlerLocalVersion = 0;
-        private static ConcurrentDictionary<string, Handler> _sessionHandlersMaster;
+        // The last hit on this thread: a transport hands the same session-id string instance to every request, so
+        // one reference comparison replaces hashing a GUID-length string. Dropped with the local snapshot.
+        [ThreadStatic]
+        private static string _lastSessionId;
+        [ThreadStatic]
+        private static Handler _lastSessionHandler;
+        private static readonly ConcurrentDictionary<string, Handler> _sessionHandlersMaster = new ConcurrentDictionary<string, Handler>();
 
-        private static volatile string _defaultSessionId;
+        private static readonly string _defaultSessionId = Guid.NewGuid().ToString();
         #endregion
 
         #region Constructors
 
         static Handler()
         {
-            _defaultSessionId = Guid.NewGuid().ToString();
-            _sessionHandlersMaster = new ConcurrentDictionary<string, Handler>();
             _sessionHandlersMaster[_defaultSessionId] = new Handler(_defaultSessionId);
         }
 
@@ -56,9 +61,17 @@ public static Handler GetSessionHandler(string sessionId)
             {
                 _sessionHandlersLocal = new Dictionary<string, Handler>(_sessionHandlersMaster);
                 _sessionHandlerLocalVersion = _sessionHandlerMasterVersion;
+                _lastSessionId = null;
+                _lastSessionHandler = null;
+            }
+            else if (ReferenceEquals(sessionId, _lastSessionId))
+            {
+                return _lastSessionHandler;
             }
             if (_sessionHandlersLocal.TryGetValue(sessionId, out var local))
             {
+                _lastSessionId = sessionId;
+                _lastSessionHandler = local;
                 return local;
             }
             Interlocked.Increment(ref _sessionHandlerMasterVersion);
@@ -355,7 +368,11 @@ internal bool HandleRequest(JsonRpcRequestReader reader, int index, JsonRpcSeria
                 output.Write(ResultPrefix);
                 try
                 {
-                    method.Invoke(reader, map, serializer, output);
+                    // The built-in serializer's requests take the invoker compiled against the concrete reader and
+                    // writer: typed reads straight from the tokens and formatted writes into the pooled buffer, with
+                    // no virtual, delegate or interface call in between. Everything else goes through the serializer.
+                    if (reader is JsmnRequestReader jsmn && jsmn.IsBuiltIn) method.InvokeJsmn(jsmn, map, output);
+                    else method.Invoke(reader, map, serializer, output);
                 }
                 catch (Exception ex)
                 {
@@ -571,6 +588,13 @@ private static int[] BindMap(JsonRpcRequestReader reader, RpcMethod method, out
             }
             else
             {
+                if (given == expected && method.HasUniqueNames)
+                {
+                    // names supplied in declaration order: the common case for generated clients, and the identity map
+                    int p = 0;
+                    while (p < expected && reader.ParamNameUtf8(p).SequenceEqual(parameters[p].NameUtf8)) p++;
+                    if (p == expected) return method.IdentityMap;
+                }
                 var map = ArrayPool<int>.Shared.Rent(Math.Max(1, expected));
                 int matched = 0;
                 for (int p = 0; p < expected; p++)

Json-Rpc/Handler.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using AustinHarris.JsonRpc.Jsmn;
 using AustinHarris.JsonRpc.Serialization;
 
 namespace AustinHarris.JsonRpc.Invocation
@@ -18,13 +19,29 @@ namespace AustinHarris.JsonRpc.Invocation
     /// <summary>Same binding, but returns the boxed result. Used when pre/post handlers need a <see cref="JsonResponse"/>.</summary>
     public delegate object BoxedInvoker(JsonRpcRequestReader reader, int[] map);
 
+    /// <summary>
+    /// The invoker specialised for the built-in serializer: parameters are read from the tokens by direct static
+    /// calls and the result is formatted into the concrete pooled writer, so a primitive request goes from bytes to
+    /// bytes without a virtual, delegate or interface call around the service method.
+    /// </summary>
+    internal delegate void JsmnInvoker(JsmnRequestReader reader, int[] map, PooledByteBufferWriter output);
+
     public sealed class RpcParameter
     {
-        public string Name { get; internal set; }
-        public Type Type { get; internal set; }
-        public bool HasDefault { get; internal set; }
-        public object DefaultValue { get; internal set; }
-        internal byte[] NameUtf8;
+        internal RpcParameter(string name, Type type, bool hasDefault, object defaultValue)
+        {
+            Name = name;
+            Type = type;
+            HasDefault = hasDefault;
+            DefaultValue = defaultValue;
+            NameUtf8 = System.Text.Encoding.UTF8.GetBytes(name);
+        }
+
+        public string Name { get; }
+        public Type Type { get; }
+        public bool HasDefault { get; }
+        public object DefaultValue { get; }
+        internal readonly byte[] NameUtf8;
     }
 
     /// <summary>
@@ -40,8 +57,11 @@ public sealed class RpcMethod
         public int DefaultCount { get; private set; }
         public StreamingInvoker Invoke { get; private set; }
         public BoxedInvoker InvokeBoxed { get; private set; }
+        internal JsmnInvoker InvokeJsmn { get; private set; }
         /// <summary>The identity map (0,1,2,...) used when positional params match exactly.</summary>
         internal int[] IdentityMap { get; private set; }
+        /// <summary>True when no two parameters share a JSON name (named params in declaration order can then use <see cref="IdentityMap"/>).</summary>
+        internal bool HasUniqueNames { get; private set; }
 
         private static readonly MethodInfo ReadParamGeneric = typeof(JsonRpcRequestReader)
             .GetMethods(BindingFlags.Public | BindingFlags.Instance)
@@ -51,7 +71,34 @@ public sealed class RpcMethod
             .GetMethods(BindingFlags.Public | BindingFlags.Instance)
             .First(m => m.Name == nameof(JsonRpcSerializer.Write) && m.IsGenericMethodDefinition);
 
-        private static readonly MethodInfo WriteNullMethod = typeof(Utf8Json).GetMethod(nameof(Utf8Json.WriteNull));
+        private static readonly MethodInfo WriteNullMethod = typeof(Utf8Json).GetMethod(nameof(Utf8Json.WriteNull), new[] { typeof(IBufferWriter<byte>) });
+        private static readonly MethodInfo WriteNullPooled = typeof(Utf8Json).GetMethod(nameof(Utf8Json.WriteNull), new[] { typeof(PooledByteBufferWriter) });
+        private static readonly MethodInfo ReadTypedParamGeneric = typeof(JsmnRequestReader).GetMethod(nameof(JsmnRequestReader.ReadTypedParam), BindingFlags.NonPublic | BindingFlags.Static);
+        private static readonly MethodInfo ParamIsNullLiteral = typeof(JsmnRequestReader).GetMethod(nameof(JsmnRequestReader.ParamIsNullLiteral), BindingFlags.NonPublic | BindingFlags.Static);
+        private static readonly MethodInfo WriteValuePooledGeneric = typeof(RpcMethod).GetMethod(nameof(WriteValuePooled), BindingFlags.NonPublic | BindingFlags.Static);
+
+        /// <summary>The built-in typed writer for a non-primitive result (POCO, collection, nullable of a non-primitive).</summary>
+        private static void WriteValuePooled<T>(PooledByteBufferWriter output, T value) => JsmnWriter<T>.Write(output, value);
+
+        // primitive type -> (static reader on JsmnRequestReader, static writer on Utf8Json taking the pooled writer)
+        private static readonly Dictionary<Type, (MethodInfo Read, MethodInfo Write)> Primitives = BuildPrimitiveTable();
+
+        private static Dictionary<Type, (MethodInfo, MethodInfo)> BuildPrimitiveTable()
+        {
+            var reader = typeof(JsmnRequestReader);
+            MethodInfo Read(string name) => reader.GetMethod(name, BindingFlags.NonPublic | BindingFlags.Static);
+            MethodInfo Write(string name, Type t) => typeof(Utf8Json).GetMethod(name, new[] { typeof(PooledByteBufferWriter), t });
+            return new Dictionary<Type, (MethodInfo, MethodInfo)>
+            {
+                [typeof(string)] = (Read(nameof(JsmnRequestReader.ReadStringParam)), Write(nameof(Utf8Json.WriteString), typeof(string))),
+                [typeof(int)] = (Read(nameof(JsmnRequestReader.ReadInt32Param)), Write(nameof(Utf8Json.WriteInt64), typeof(long))),
+                [typeof(long)] = (Read(nameof(JsmnRequestReader.ReadInt64Param)), Write(nameof(Utf8Json.WriteInt64), typeof(long))),
+                [typeof(double)] = (Read(nameof(JsmnRequestReader.ReadDoubleParam)), Write(nameof(Utf8Json.WriteDouble), typeof(double))),
+                [typeof(float)] = (Read(nameof(JsmnRequestReader.ReadSingleParam)), Write(nameof(Utf8Json.WriteSingle), typeof(float))),
+                [typeof(bool)] = (Read(nameof(JsmnRequestReader.ReadBooleanParam)), Write(nameof(Utf8Json.WriteBool), typeof(bool))),
+                [typeof(decimal)] = (Read(nameof(JsmnRequestReader.ReadDecimalParam)), Write(nameof(Utf8Json.WriteDecimal), typeof(decimal))),
+            };
+        }
 
         /// <summary>Builds the invokers for an instance (or static) method; <paramref name="parameterNames"/> are the JSON names (null = CLR names).</summary>
         public static RpcMethod FromMethod(string name, MethodInfo method, object target, string[] parameterNames = null)
@@ -104,8 +151,13 @@ private static RpcMethod Build(string name, ParameterInfo[] ps, Type returnType,
             bool expectsRef = ps.Length > 0 && ps[ps.Length - 1].ParameterType == typeof(JsonRpcException).MakeByRefType();
             int bindable = expectsRef ? ps.Length - 1 : ps.Length;
 
+            // the built-in invoker binds the same parameters through direct static reads
+            var jsmnReader = Expression.Parameter(typeof(JsmnRequestReader), "reader");
+            var pooled = Expression.Parameter(typeof(PooledByteBufferWriter), "output");
+
             var parameters = new RpcParameter[bindable];
             var args = new Expression[ps.Length];
+            var jsmnArgs = new Expression[ps.Length];
             int defaultCount = 0;
             for (int i = 0; i < bindable; i++)
             {
@@ -117,59 +169,63 @@ private static RpcMethod Build(string name, ParameterInfo[] ps, Type returnType,
                 else if (p.IsOptional && p.DefaultValue != DBNull.Value && p.DefaultValue != Type.Missing) defaultValue = p.DefaultValue;
                 if (hasDefault) defaultCount++;
 
-                parameters[i] = new RpcParameter
-                {
-                    Name = jsonName,
-                    Type = p.ParameterType,
-                    HasDefault = hasDefault,
-                    DefaultValue = defaultValue,
-                    NameUtf8 = System.Text.Encoding.UTF8.GetBytes(jsonName)
-                };
+                parameters[i] = new RpcParameter(jsonName, p.ParameterType, hasDefault, defaultValue);
 
                 var index = Expression.ArrayIndex(map, Expression.Constant(i));
                 var read = Expression.Call(reader, ReadParamGeneric.MakeGenericMethod(p.ParameterType), index);
                 Expression fallback = MakeDefault(p.ParameterType, hasDefault, defaultValue);
-                args[i] = Expression.Condition(Expression.GreaterThanOrEqual(index, Expression.Constant(0)), read, fallback);
+                var supplied = Expression.GreaterThanOrEqual(index, Expression.Constant(0));
+                args[i] = Expression.Condition(supplied, read, fallback);
+                jsmnArgs[i] = Expression.Condition(supplied, MakeJsmnRead(jsmnReader, index, p.ParameterType), fallback);
             }
-            if (expectsRef) args[ps.Length - 1] = refEx;
+            if (expectsRef) args[ps.Length - 1] = jsmnArgs[ps.Length - 1] = refEx;
 
             var call = makeCall(args);
+            var jsmnCall = makeCall(jsmnArgs);
             var throwIfRef = expectsRef
                 ? (Expression)Expression.IfThen(Expression.NotEqual(refEx, Expression.Constant(null, typeof(JsonRpcException))), Expression.Throw(refEx))
                 : Expression.Empty();
+            var clearRef = Expression.Assign(refEx, Expression.Constant(null, typeof(JsonRpcException)));
 
             // streaming: result = call(); if (refEx != null) throw; serializer.Write<TRet>(output, result)
             Expression streamingBody;
             Expression boxedBody;
+            Expression jsmnBody;
             if (returnType == typeof(void))
             {
-                streamingBody = Expression.Block(new[] { refEx },
-                    Expression.Assign(refEx, Expression.Constant(null, typeof(JsonRpcException))),
-                    call, throwIfRef, Expression.Call(WriteNullMethod, output));
-                boxedBody = Expression.Block(typeof(object), new[] { refEx },
-                    Expression.Assign(refEx, Expression.Constant(null, typeof(JsonRpcException))),
-                    call, throwIfRef, Expression.Constant(null, typeof(object)));
+                streamingBody = Expression.Block(new[] { refEx }, clearRef, call, throwIfRef, Expression.Call(WriteNullMethod, output));
+                boxedBody = Expression.Block(typeof(object), new[] { refEx }, clearRef, call, throwIfRef, Expression.Constant(null, typeof(object)));
+                jsmnBody = Expression.Block(new[] { refEx }, clearRef, jsmnCall, throwIfRef, Expression.Call(WriteNullPooled, pooled));
             }
             else
             {
                 var result = Expression.Variable(returnType, "result");
                 streamingBody = Expression.Block(new[] { refEx, result },
-                    Expression.Assign(refEx, Expression.Constant(null, typeof(JsonRpcException))),
+                    clearRef,
                     Expression.Assign(result, call),
                     throwIfRef,
                     Expression.Call(serializer, WriteGeneric.MakeGenericMethod(returnType), output, result));
                 boxedBody = Expression.Block(typeof(object), new[] { refEx, result },
-                    Expression.Assign(refEx, Expression.Constant(null, typeof(JsonRpcException))),
+                    clearRef,
                     Expression.Assign(result, call),
                     throwIfRef,
                     Expression.Convert(result, typeof(object)));
+                jsmnBody = Expression.Block(new[] { refEx, result },
+                    clearRef,
+                    Expression.Assign(result, jsmnCall),
+                    throwIfRef,
+                    MakeJsmnWrite(pooled, result, returnType));
             }
 
             var streaming = Expression.Lambda<StreamingInvoker>(streamingBody, reader, map, serializer, output).Compile();
             var boxed = Expression.Lambda<BoxedInvoker>(boxedBody, reader, map).Compile();
+            var jsmnInvoker = Expression.Lambda<JsmnInvoker>(jsmnBody, jsmnReader, map, pooled).Compile();
 
             var identity = new int[bindable];
             for (int i = 0; i < bindable; i++) identity[i] = i;
+            var names = new HashSet<string>();
+            bool unique = true;
+            foreach (var parameter in parameters) unique &= names.Add(parameter.Name);
 
             return new RpcMethod
             {
@@ -180,10 +236,52 @@ private static RpcMethod Build(string name, ParameterInfo[] ps, Type returnType,
                 DefaultCount = defaultCount,
                 Invoke = streaming,
                 InvokeBoxed = boxed,
-                IdentityMap = identity
+                InvokeJsmn = jsmnInvoker,
+                IdentityMap = identity,
+                HasUniqueNames = unique
             };
         }
 
+        /// <summary>
+        /// The built-in read of parameter <paramref name="index"/> as <paramref name="type"/>: a direct static call
+        /// for the primitives, a null test plus the value read for their nullables, the typed reader cache for the rest.
+        /// </summary>
+        private static Expression MakeJsmnRead(ParameterExpression reader, Expression index, Type type)
+        {
+            if (Primitives.TryGetValue(type, out var primitive)) return Expression.Call(primitive.Read, reader, index);
+            var underlying = Nullable.GetUnderlyingType(type);
+            if (underlying != null && Primitives.TryGetValue(underlying, out var inner))
+            {
+                return Expression.Condition(
+                    Expression.Call(ParamIsNullLiteral, reader, index),
+                    Expression.Constant(null, type),
+                    Expression.Convert(Expression.Call(inner.Read, reader, index), type));
+            }
+            return Expression.Call(ReadTypedParamGeneric.MakeGenericMethod(type), reader, index);
+        }
+
+        /// <summary>The built-in write of <paramref name="result"/>: the concrete-writer formatter for primitives (and their nullables), the typed writer cache otherwise.</summary>
+        private static Expression MakeJsmnWrite(ParameterExpression output, ParameterExpression result, Type type)
+        {
+            if (Primitives.TryGetValue(type, out var primitive))
+            {
+                Expression value = result;
+                if (type == typeof(int)) value = Expression.Convert(result, typeof(long));
+                return Expression.Call(primitive.Write, output, value);
+            }
+            var underlying = Nullable.GetUnderlyingType(type);
+            if (underlying != null && Primitives.TryGetValue(underlying, out var inner))
+            {
+                Expression value = Expression.Property(result, "Value");
+                if (underlying == typeof(int)) value = Expression.Convert(value, typeof(long));
+                return Expression.IfThenElse(
+                    Expression.Property(result, "HasValue"),
+                    Expression.Call(inner.Write, output, value),
+                    Expression.Call(WriteNullPooled, output));
+            }
+            return Expression.Call(WriteValuePooledGeneric.MakeGenericMethod(type), output, result);
+        }
+
         private static Expression MakeDefault(Type type, bool hasDefault, object value)
         {
             if (!hasDefault || value == null) return Expression.Default(type);