perf(core): optimize polymorphic serialization with per-instance caching

Major performance improvements to polymorphic type handling:
- Move caching from static fields to Reader/Writer instances to eliminate thread-safety overhead (Volatile/Interlocked)
- Add fast path for single subtype scenarios (common case optimization)
- Use Unsafe.As<T, TSub>() for reference types instead of pattern matching
- Remove unnecessary System.Threading dependency

Additional improvements:
- Fix FastMap nullability warnings (default! → default)
- Increase CI benchmark timeout to 180 minutes
- Improve benchmark result detection with dynamic file discovery

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: JasonXuDeveloper

.github/workflows/ci.yml

@@ -120,7 +120,7 @@ jobs:
     runs-on: ubuntu-latest
     needs: [ build-test ]
     if: github.event_name == 'pull_request'
-    timeout-minutes: 60
+    timeout-minutes: 180
     permissions:
       contents: read
       pull-requests: write
@@ -165,10 +165,10 @@ jobs:
           dotnet run -c Release --no-build
 
           # Verify benchmark results exist (check for any github markdown file)
-          MARKDOWN_COUNT=$(find BenchmarkDotNet.Artifacts/results -name "*-report-github.md" -type f 2>/dev/null | wc -l)
-          if [[ $MARKDOWN_COUNT -gt 0 ]]; then
-            echo "✅ Benchmark completed successfully - found $MARKDOWN_COUNT report file(s)"
-            find BenchmarkDotNet.Artifacts/results -name "*-report-github.md" -type f
+          MARKDOWN_FILE=$(find BenchmarkDotNet.Artifacts/results -name "*-report-github.md" -type f 2>/dev/null | head -n1)
+          if [[ -n "$MARKDOWN_FILE" && -f "$MARKDOWN_FILE" ]]; then
+            echo "✅ Benchmark completed successfully - found report file:"
+            echo "$MARKDOWN_FILE"
           else
             echo "❌ Benchmark results not found"
             echo "Looking for markdown files in results directory..."

.github/workflows/report.yml

@@ -30,7 +30,7 @@ jobs:
   benchmark:
     name: Run Performance Benchmarks
     runs-on: ubuntu-latest
-    timeout-minutes: 60
+    timeout-minutes: 180
 
     steps:
       - name: Determine target tag/ref
@@ -111,12 +111,13 @@ jobs:
           echo "Running benchmarks for ${{ env.tag_name }}..."
           dotnet run -c Release --no-build
           
-          # Verify benchmark results exist (we're in src/Nino.Benchmark directory)
-          if [[ -f "BenchmarkDotNet.Artifacts/results/Nino.Benchmark.SimpleTest-report-github.md" ]]; then
+          # Verify benchmark results exist (check for any github markdown file)
+          MARKDOWN_FILE=$(find BenchmarkDotNet.Artifacts/results -name "*-report-github.md" -type f 2>/dev/null | head -n1)
+          if [[ -n "$MARKDOWN_FILE" && -f "$MARKDOWN_FILE" ]]; then
             echo "✅ Benchmark completed successfully"
+            echo "Found: $MARKDOWN_FILE"
           else
             echo "❌ Benchmark results not found in $(pwd)"
-            echo "Looking for: BenchmarkDotNet.Artifacts/results/Nino.Benchmark.SimpleTest-report-github.md"
             echo "Available files in results directory:"
             if [[ -d "BenchmarkDotNet.Artifacts/results/" ]]; then
               ls -la BenchmarkDotNet.Artifacts/results/

src/Nino.Core/FastMap.cs

@@ -70,8 +70,8 @@ public void Remove(TKey key)
                 Array.Copy(_values, index + 1, _values, index, _count - index - 1);
             }
 
-            _keys[--_count] = default!; // Clear the last element
-            _values[_count] = default!;
+            _keys[--_count] = default; // Clear the last element
+            _values[_count] = default;
         }
 
         private void Grow()
@@ -267,4 +267,4 @@ private int LinearSearch(TKey key)
             return -1;
         }
     }
-}
+}

src/Nino.Core/NinoDeserializer.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
-using System.Threading;
 
 namespace Nino.Core
 {
@@ -148,6 +147,9 @@ public static class CachedDeserializer<T>
         private static DeserializeDelegateRef<T> _deserializerRef;
         private static readonly FastMap<int, DeserializeDelegate<T>> SubTypeDeserializers = new();
         private static readonly FastMap<int, DeserializeDelegateRef<T>> SubTypeDeserializerRefs = new();
+        private static int _singleSubTypeId = int.MinValue;
+        private static DeserializeDelegate<T> _singleSubTypeDeserializer;
+        private static DeserializeDelegateRef<T> _singleSubTypeDeserializerRef;
 
         // Inline cache for polymorphic deserialization (separate caches for out/ref)
         // Cache expensive type checks
@@ -160,12 +162,6 @@ public static class CachedDeserializer<T>
         // ReSharper disable once StaticMemberInGenericType
         private static readonly bool IsSealed = typeof(T).IsSealed || typeof(T).IsValueType;
 
-        // Shared cache for polymorphic deserialization (Volatile for thread-safety)
-        private static int _cachedTypeId;
-        private static int _cachedTypeIdRef;
-        private static DeserializeDelegate<T> _cachedDeserializer;
-        private static DeserializeDelegateRef<T> _cachedDeserializerRef;
-
         // ULTIMATE: JIT-eliminated constants for maximum performance
         // ReSharper disable once StaticMemberInGenericType
         internal static readonly bool IsSimpleType = !IsReferenceOrContainsReferences && !HasBaseType;
@@ -178,6 +174,9 @@ public static void SetDeserializer(int typeId, DeserializeDelegate<T> deserializ
             _deserializerRef = deserializerRef;
             SubTypeDeserializers.Add(typeId, _deserializer);
             SubTypeDeserializerRefs.Add(typeId, _deserializerRef);
+            _singleSubTypeId = int.MinValue;
+            _singleSubTypeDeserializer = null;
+            _singleSubTypeDeserializerRef = null;
         }
 
         public static void AddSubTypeDeserializer<TSub>(int subTypeId,
@@ -189,13 +188,27 @@ public static void AddSubTypeDeserializer<TSub>(int subTypeId,
             SubTypeDeserializerWrapper<TSub>.RefDeserializer = deserializerRef;
             SubTypeDeserializers.Add(subTypeId, SubTypeDeserializerWrapper<TSub>.DeserializeOutWrapper);
             SubTypeDeserializerRefs.Add(subTypeId, SubTypeDeserializerWrapper<TSub>.DeserializeRefWrapper);
+
+            if (SubTypeDeserializers.Count == 2)
+            {
+                _singleSubTypeId = subTypeId;
+                _singleSubTypeDeserializer = SubTypeDeserializerWrapper<TSub>.DeserializeOutWrapper;
+                _singleSubTypeDeserializerRef = SubTypeDeserializerWrapper<TSub>.DeserializeRefWrapper;
+            }
+            else
+            {
+                _singleSubTypeId = int.MinValue;
+                _singleSubTypeDeserializer = null;
+                _singleSubTypeDeserializerRef = null;
+            }
         }
 
         // Static wrapper class per TSub - allows better inlining than lambda
         private static class SubTypeDeserializerWrapper<TSub> where TSub : T
         {
             public static DeserializeDelegate<TSub> OutDeserializer;
             public static DeserializeDelegateRef<TSub> RefDeserializer;
+            private static readonly bool IsValueType = typeof(TSub).IsValueType;
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static void DeserializeOutWrapper(out T value, ref Reader reader)
@@ -207,13 +220,15 @@ public static void DeserializeOutWrapper(out T value, ref Reader reader)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static void DeserializeRefWrapper(ref T value, ref Reader reader)
             {
-                if (value is TSub val)
+                if (IsValueType)
                 {
-                    RefDeserializer(ref val, ref reader);
+                    TSub temp = default;
+                    RefDeserializer(ref temp, ref reader);
+                    value = temp;
                 }
                 else
                 {
-                    ThrowInvalidCast(value?.GetType());
+                    RefDeserializer(ref Unsafe.As<T, TSub>(ref value), ref reader);
                 }
             }
         }
@@ -271,10 +286,6 @@ public static void Deserialize(out T value, ref Reader reader)
                 // DIRECT DELEGATE: Generated code path - no polymorphism possible
                 _deserializer(out value, ref reader);
             }
-            else if (SubTypeDeserializers.Count == 1)
-            {
-                SubTypeDeserializers.Values[0](out value, ref reader);
-            }
             else
             {
                 DeserializePolymorphic(out value, ref reader);
@@ -325,53 +336,26 @@ private static void DeserializePolymorphic(out T value, ref Reader reader)
                 _deserializer!(out value, ref reader);
                 return;
             }
-            
+
             // FAST PATH: Exact type match for single subtype
-            if (SubTypeDeserializers.Count == 2)
+            if (typeId == _singleSubTypeId && _singleSubTypeDeserializer is not null)
             {
-                var keys = SubTypeDeserializers.Keys;
-                if (typeId == keys[0])
-                {
-                    SubTypeDeserializers.Values[0](out value, ref reader);
-                    return;
-                }
-
-                SubTypeDeserializers.Values[1](out value, ref reader);
+                _singleSubTypeDeserializer(out value, ref reader);
                 return;
             }
-            
+
             // FAST PATH: Cache hit (optimized for monomorphic arrays)
-#if NET5_0_OR_GREATER && !UNITY_WEBGL
-            // On 64-bit platforms, Volatile is atomic and faster (~1-2 cycles)
-            var cachedId = Volatile.Read(ref _cachedTypeId);
-            if (typeId == cachedId)
-            {
-                var cachedDeser = Volatile.Read(ref _cachedDeserializer);
-                cachedDeser!(out value, ref reader);
-                return;
-            }
-#else
-            // On 32-bit platforms and WebGL, use Interlocked for atomicity (~10-20 cycles)
-            var cachedId = Interlocked.CompareExchange(ref _cachedTypeId, 0, 0);
-            if (typeId == cachedId)
+            if (typeId == reader.CachedTypeId && reader.CachedDeserializer is DeserializeDelegate<T> cachedDeserializer)
             {
-                var cachedDeser = Interlocked.CompareExchange(ref _cachedDeserializer, null, null);
-                cachedDeser!(out value, ref reader);
+                cachedDeserializer(out value, ref reader);
                 return;
             }
-#endif
 
             // SLOW PATH: Full lookup in subtype map and update cache
             if (SubTypeDeserializers.TryGetValue(typeId, out var subTypeDeserializer))
             {
-#if NET5_0_OR_GREATER && !UNITY_WEBGL
-                // Update cache for subsequent elements
-                Volatile.Write(ref _cachedTypeId, typeId);
-                Volatile.Write(ref _cachedDeserializer, subTypeDeserializer);
-#else
-                Interlocked.Exchange(ref _cachedTypeId, typeId);
-                Interlocked.Exchange(ref _cachedDeserializer, subTypeDeserializer);
-#endif
+                reader.CachedTypeId = typeId;
+                reader.CachedDeserializer = subTypeDeserializer;
                 subTypeDeserializer(out value, ref reader);
                 return;
             }
@@ -400,51 +384,25 @@ private static void DeserializeRefPolymorphic(ref T value, ref Reader reader)
             }
 
             // FAST PATH: Exact type match for single subtype
-            if (SubTypeDeserializerRefs.Count == 2)
+            if (typeId == _singleSubTypeId && _singleSubTypeDeserializerRef is not null)
             {
-                var keys = SubTypeDeserializerRefs.Keys;
-                if (typeId == keys[0])
-                {
-                    SubTypeDeserializerRefs.Values[0](ref value, ref reader);
-                    return;
-                }
-
-                SubTypeDeserializerRefs.Values[1](ref value, ref reader);
+                _singleSubTypeDeserializerRef(ref value, ref reader);
                 return;
             }
 
             // FAST PATH: Cache hit (optimized for monomorphic arrays)
-#if NET5_0_OR_GREATER && !UNITY_WEBGL
-            // On 64-bit platforms, Volatile is atomic and faster (~1-2 cycles)
-            var cachedIdRef = Volatile.Read(ref _cachedTypeIdRef);
-            if (typeId == cachedIdRef)
-            {
-                var cachedDeserRef = Volatile.Read(ref _cachedDeserializerRef);
-                cachedDeserRef!(ref value, ref reader);
-                return;
-            }
-#else
-            // On 32-bit platforms and WebGL, use Interlocked for atomicity (~10-20 cycles)
-            var cachedIdRef = Interlocked.CompareExchange(ref _cachedTypeIdRef, 0, 0);
-            if (typeId == cachedIdRef)
+            if (typeId == reader.CachedTypeIdRef &&
+                reader.CachedDeserializerRef is DeserializeDelegateRef<T> cachedDeserializerRef)
             {
-                var cachedDeserRef = Interlocked.CompareExchange(ref _cachedDeserializerRef, null, null);
-                cachedDeserRef!(ref value, ref reader);
+                cachedDeserializerRef(ref value, ref reader);
                 return;
             }
-#endif
 
             // SLOW PATH: Full lookup in subtype map and update cache
             if (SubTypeDeserializerRefs.TryGetValue(typeId, out var subTypeDeserializer))
             {
-#if NET5_0_OR_GREATER && !UNITY_WEBGL
-                // Update cache for subsequent elements
-                Volatile.Write(ref _cachedTypeIdRef, typeId);
-                Volatile.Write(ref _cachedDeserializerRef, subTypeDeserializer);
-#else
-                Interlocked.Exchange(ref _cachedTypeIdRef, typeId);
-                Interlocked.Exchange(ref _cachedDeserializerRef, subTypeDeserializer);
-#endif
+                reader.CachedTypeIdRef = typeId;
+                reader.CachedDeserializerRef = subTypeDeserializer;
                 subTypeDeserializer(ref value, ref reader);
                 return;
             }

src/Nino.Core/NinoSerializer.cs

@@ -182,37 +182,30 @@ public static class CachedSerializer<T>
         // ReSharper disable once StaticMemberInGenericType
         internal static readonly bool IsSimpleType = !IsReferenceOrContainsReferences && !HasBaseType;
 
-        [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] // Cold exception path
-        private static void ThrowInvalidCast(Type actualType) =>
-            throw new InvalidCastException($"Cannot cast {actualType?.FullName ?? "null"} to {typeof(T).FullName}");
-
         public static void AddSubTypeSerializer<TSub>(SerializeDelegate<TSub> serializer) where TSub : T
         {
             // Use a static generic helper class to create an inlineable wrapper
             SubTypeSerializerWrapper<TSub>.SubSerializer = serializer;
             SubTypeSerializers.Add(typeof(TSub).TypeHandle.Value, SubTypeSerializerWrapper<TSub>.SerializeWrapper);
         }
 
-        // Shared cache for polymorphic serialization (Interlocked for thread-safety)
-        private static IntPtr _cachedTypeHandle;
-        private static SerializeDelegate<T> _cachedSerializer;
-
         // Static wrapper class per TSub - allows better inlining than lambda
         private static class SubTypeSerializerWrapper<TSub> where TSub : T
         {
             public static SerializeDelegate<TSub> SubSerializer;
+            private static readonly bool IsValueType = typeof(TSub).IsValueType;
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static void SerializeWrapper(T val, ref Writer writer)
             {
-                if (val is TSub sub)
+                if (IsValueType)
                 {
-                    // This can be inlined by JIT since it's a static method call with known target
-                    SubSerializer(sub, ref writer);
+                    SubSerializer((TSub)(object)val!, ref writer);
                 }
                 else
                 {
-                    ThrowInvalidCast(val?.GetType());
+                    // Runtime handle check already guaranteed T is TSub so skip casts for reference types.
+                    SubSerializer(Unsafe.As<T, TSub>(ref val), ref writer);
                 }
             }
         }
@@ -277,45 +270,23 @@ private static unsafe void SerializePolymorphic(T val, ref Writer writer)
                 return;
             }
 
-            // FAST PATH: 1 subtype (common for simple polymorphic usage)
             if (SubTypeSerializers.Count == 1)
             {
                 SubTypeSerializers.Values[0](val, ref writer);
                 return;
             }
 
-            // FAST PATH: Cache hit (optimized for monomorphic arrays)
-#if NET5_0_OR_GREATER && !UNITY_WEBGL
-            // On 64-bit platforms, Volatile is atomic and faster (~1-2 cycles)
-            var cachedHandle = Volatile.Read(ref _cachedTypeHandle);
-            if (actualTypeHandle == cachedHandle)
+            if (actualTypeHandle == writer.CachedTypeHandle &&
+                writer.CachedSerializer is SerializeDelegate<T> cachedSer)
             {
-                var cachedSer = Volatile.Read(ref _cachedSerializer);
-                cachedSer!(val, ref writer);
+                cachedSer(val, ref writer);
                 return;
             }
-#else
-            // On 32-bit platforms and WebGL, use Interlocked for atomicity (~10-20 cycles)
-            var cachedHandle = Interlocked.CompareExchange(ref _cachedTypeHandle, IntPtr.Zero, IntPtr.Zero);
-            if (actualTypeHandle == cachedHandle)
-            {
-                var cachedSer = Interlocked.CompareExchange(ref _cachedSerializer, null, null);
-                cachedSer!(val, ref writer);
-                return;
-            }
-#endif
 
-            // SLOW PATH: Full lookup in subtype map and update cache
             if (SubTypeSerializers.TryGetValue(actualTypeHandle, out var subTypeSerializer))
             {
-#if NET5_0_OR_GREATER && !UNITY_WEBGL
-                // Update cache for subsequent elements
-                Volatile.Write(ref _cachedTypeHandle, actualTypeHandle);
-                Volatile.Write(ref _cachedSerializer, subTypeSerializer);
-#else
-                Interlocked.Exchange(ref _cachedTypeHandle, actualTypeHandle);
-                Interlocked.Exchange(ref _cachedSerializer, subTypeSerializer);
-#endif
+                writer.CachedTypeHandle = actualTypeHandle;
+                writer.CachedSerializer = subTypeSerializer;
                 subTypeSerializer(val, ref writer);
                 return;
             }