Improve deserialization perf with changes to property name lookup

src/System.Text.Json/src/System/Text/Json/Serialization/JsonClassInfo.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text.Json.Serialization;
 using System.Text.Json.Serialization.Converters;
@@ -16,7 +17,9 @@ namespace System.Text.Json
  internal sealed partial class JsonClassInfo
  {
  // The length of the property name embedded in the key (in bytes).
- private const int PropertyNameKeyLength = 6;
+ // The key is a ulong (8 bytes) containing the first 7 bytes of the property name
+ // followed by a byte representing the length.
+ private const int PropertyNameKeyLength = 7;
 
  // The limit to how many property names from the JSON are cached in _propertyRefsSorted before using PropertyCache.
  private const int PropertyNameCountCacheThreshold = 64;
@@ -257,85 +260,132 @@ private JsonPropertyInfo GetPropertyWithUniqueAttribute(Type attributeType, Dict
  return property;
  }
 
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private static bool TryIsPropertyRefEqual(in PropertyRef propertyRef, ReadOnlySpan<byte> propertyName, ulong key, ref JsonPropertyInfo info)
+ {
+ if (key == propertyRef.Key)
+ {
+ // We compare the whole name, although we could skip the first 7 bytes (but it's not any faster)
+ if (propertyName.Length <= PropertyNameKeyLength ||
+ propertyName.SequenceEqual(propertyRef.Info.Name))
+ {
+ info = propertyRef.Info;
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ // AggressiveInlining used although a large method it is only called from one location and is on a hot path.
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
  public JsonPropertyInfo GetProperty(ReadOnlySpan<byte> propertyName, ref ReadStackFrame frame)
  {
  JsonPropertyInfo info = null;
 
  // Keep a local copy of the cache in case it changes by another thread.
  PropertyRef[] localPropertyRefsSorted = _propertyRefsSorted;
 
+ ulong key = GetKey(propertyName);
+
  // If there is an existing cache, then use it.
  if (localPropertyRefsSorted != null)
  {
- ulong key = GetKey(propertyName);
-
  // Start with the current property index, and then go forwards\backwards.
  int propertyIndex = frame.PropertyIndex;
 
  int count = localPropertyRefsSorted.Length;
  int iForward = Math.Min(propertyIndex, count);
  int iBackward = iForward - 1;
 
- while (iForward < count || iBackward >= 0)
+ for (;;)
  {
  if (iForward < count)
  {
- if (TryIsPropertyRefEqual(localPropertyRefsSorted[iForward], propertyName, key, ref info))
+ PropertyRef propertyRef = localPropertyRefsSorted[iForward];
+ if (TryIsPropertyRefEqual(propertyRef, propertyName, key, ref info))
  {
  return info;
  }
+
  ++iForward;
- }
 
- if (iBackward >= 0)
+ if (iBackward >= 0)
+ {
+ propertyRef = localPropertyRefsSorted[iBackward];
+ if (TryIsPropertyRefEqual(propertyRef, propertyName, key, ref info))
+ {
+ return info;
+ }
+
+ --iBackward;
+ }
+ }
+ else if (iBackward >= 0)
  {
- if (TryIsPropertyRefEqual(localPropertyRefsSorted[iBackward], propertyName, key, ref info))
+ PropertyRef propertyRef = localPropertyRefsSorted[iBackward];
+ if (TryIsPropertyRefEqual(propertyRef, propertyName, key, ref info))
  {
  return info;
  }
+
  --iBackward;
  }
+ else
+ {
+ // Property was not found.
+ break;
+ }
  }
  }
 
  // No cached item was found. Try the main list which has all of the properties.
 
  string stringPropertyName = JsonHelpers.Utf8GetString(propertyName);
- if (PropertyCache.TryGetValue(stringPropertyName, out info))
+ if (!PropertyCache.TryGetValue(stringPropertyName, out info))
  {
- // Check if we should add this to the cache.
- // Only cache up to a threshold length and then just use the dictionary when an item is not found in the cache.
- int count;
- if (localPropertyRefsSorted != null)
- {
- count = localPropertyRefsSorted.Length;
- }
- else
+ info = JsonPropertyInfo.s_missingProperty;
+ }
+
+ Debug.Assert(info != null);
+
+ // Three code paths to get here:
+ // 1) info == s_missingProperty. Property not found.
+ // 2) key == info.PropertyNameKey. Exact match found.
+ // 3) key != info.PropertyNameKey. Match found due to case insensitivity.
+ Debug.Assert(info == JsonPropertyInfo.s_missingProperty || key == info.PropertyNameKey || Options.PropertyNameCaseInsensitive);
+
+ // Check if we should add this to the cache.
+ // Only cache up to a threshold length and then just use the dictionary when an item is not found in the cache.
+ int cacheCount;
+ if (localPropertyRefsSorted != null)
+ {
+ cacheCount = localPropertyRefsSorted.Length;
+ }
+ else
+ {
+ cacheCount = 0;
+ }
+
+ // Do a quick check for the stable (after warm-up) case.
+ if (cacheCount < PropertyNameCountCacheThreshold)
+ {
+ // Do a slower check for the warm-up case.
+ if (frame.PropertyRefCache != null)
  {
- count = 0;
+ cacheCount += frame.PropertyRefCache.Count;
  }
 
- // Do a quick check for the stable (after warm-up) case.
- if (count < PropertyNameCountCacheThreshold)
+ // Check again to append the cache up to the threshold.
+ if (cacheCount < PropertyNameCountCacheThreshold)
  {
- // Do a slower check for the warm-up case.
- if (frame.PropertyRefCache != null)
+ if (frame.PropertyRefCache == null)
  {
- count += frame.PropertyRefCache.Count;
+ frame.PropertyRefCache = new List<PropertyRef>();
  }
 
- // Check again to append the cache up to the threshold.
- if (count < PropertyNameCountCacheThreshold)
- {
- if (frame.PropertyRefCache == null)
- {
- frame.PropertyRefCache = new List<PropertyRef>();
- }
-
- ulong key = info.PropertyNameKey;
- PropertyRef propertyRef = new PropertyRef(key, info);
- frame.PropertyRefCache.Add(propertyRef);
- }
+ PropertyRef propertyRef = new PropertyRef(key, info);
+ frame.PropertyRefCache.Add(propertyRef);
  }
  }
 
@@ -360,74 +410,90 @@ private Dictionary<string, JsonPropertyInfo> CreatePropertyCache(int capacity)
 
  public JsonPropertyInfo PolicyProperty { get; private set; }
 
- private static bool TryIsPropertyRefEqual(in PropertyRef propertyRef, ReadOnlySpan<byte> propertyName, ulong key, ref JsonPropertyInfo info)
- {
- if (key == propertyRef.Key)
- {
- if (propertyName.Length <= PropertyNameKeyLength ||
- // We compare the whole name, although we could skip the first 6 bytes (but it's likely not any faster)
- propertyName.SequenceEqual(propertyRef.Info.Name))
- {
- info = propertyRef.Info;
- return true;
- }
- }
-
- return false;
- }
-
- private static bool IsPropertyRefEqual(ref PropertyRef propertyRef, PropertyRef other)
- {
- if (propertyRef.Key == other.Key)
- {
- if (propertyRef.Info.Name.Length <= PropertyNameKeyLength ||
- propertyRef.Info.Name.AsSpan().SequenceEqual(other.Info.Name.AsSpan()))
- {
- return true;
- }
- }
-
- return false;
- }
-
+ /// <summary>
+ /// Get a key from the property name.
+ /// The key consists of the first 7 bytes of the property name and then the length.
+ /// </summary>
  public static ulong GetKey(ReadOnlySpan<byte> propertyName)
  {
+ const int BitsInByte = 8;
  ulong key;
  int length = propertyName.Length;
 
- // Embed the propertyName in the first 6 bytes of the key.
- if (length > 3)
+ if (length > 7)
+ {
+ key = MemoryMarshal.Read<ulong>(propertyName);
+
+ // Clear the high byte so it can hold the length.
+ key &= 0x00FFFFFFFFFFFFFF;
+
+ // Use a length of 8. Any length > 7 (PropertyNameKeyLength) would work since
+ // the comparison logic tests for equality against the full contents instead of just
+ // the key if the property name is 8 or more characters.
+ key |= (ulong) 8 << (7 * BitsInByte);
+ }
+ else if (length > 3)
  {
  key = MemoryMarshal.Read<uint>(propertyName);
- if (length > 4)
+
+ if (length == 7)
+ {
+ key |= (ulong) propertyName[4] << (4 * BitsInByte)
+ | (ulong) propertyName[5] << (5 * BitsInByte)
+ | (ulong) propertyName[6] << (6 * BitsInByte)
+ | (ulong) 7 << (7 * BitsInByte);
+ }
+ else if (length == 6)
  {
- key |= (ulong)propertyName[4] << 32;
+ key |= (ulong) propertyName[4] << (4 * BitsInByte)
+ | (ulong) propertyName[5] << (5 * BitsInByte)
+ | (ulong) 6 << (7 * BitsInByte);
  }
- if (length > 5)
+ else if (length == 5)
+ {
+ key |= (ulong) propertyName[4] << (4 * BitsInByte)
+ | (ulong) 5 << (7 * BitsInByte);
+ }
+ else
  {
- key |= (ulong)propertyName[5] << 40;
+ key |= (ulong) 4 << (7 * BitsInByte);
  }
  }
  else if (length > 1)
  {
  key = MemoryMarshal.Read<ushort>(propertyName);
- if (length > 2)
+
+ if (length == 3)
  {
- key |= (ulong)propertyName[2] << 16;
+ key |= (ulong) propertyName[2] << (2 * BitsInByte)
+ | (ulong) 3 << (7 * BitsInByte);
+ }
+ else
+ {
+ key |= (ulong) 2 << (7 * BitsInByte);
  }
  }
  else if (length == 1)
  {
- key = propertyName[0];
+ key = propertyName[0]
+ | (ulong) 1 << (7 * BitsInByte);
  }
  else
  {
  // An empty name is valid.
  key = 0;
  }
 
- // Embed the propertyName length in the last two bytes.
- key |= (ulong)propertyName.Length << 48;
+ // Verify key contains the embedded bytes as expected.
+ Debug.Assert(
+ length < 1 || propertyName[0] == (key & ((ulong)0xFF << 8 * 0)) >> 8 * 0 &&
+ length < 2 || propertyName[1] == (key & ((ulong)0xFF << 8 * 1)) >> 8 * 1 &&
+ length < 3 || propertyName[2] == (key & ((ulong)0xFF << 8 * 2)) >> 8 * 2 &&
+ length < 4 || propertyName[3] == (key & ((ulong)0xFF << 8 * 3)) >> 8 * 3 &&
+ length < 5 || propertyName[4] == (key & ((ulong)0xFF << 8 * 4)) >> 8 * 4 &&
+ length < 6 || propertyName[5] == (key & ((ulong)0xFF << 8 * 5)) >> 8 * 5 &&
+ length < 7 || propertyName[6] == (key & ((ulong)0xFF << 8 * 6)) >> 8 * 6);
+
  return key;
  }
 

src/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Read.HandlePropertyName.cs

@@ -5,11 +5,14 @@
 using System.Buffers;
 using System.Collections;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 
 namespace System.Text.Json
 {
  public static partial class JsonSerializer
  {
+ // AggressiveInlining used although a large method it is only called from one locations and is on a hot path.
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
  private static void HandlePropertyName(
  JsonSerializerOptions options,
  ref Utf8JsonReader reader,
@@ -52,7 +55,7 @@ private static void HandlePropertyName(
  }
 
  JsonPropertyInfo jsonPropertyInfo = state.Current.JsonClassInfo.GetProperty(propertyName, ref state.Current);
- if (jsonPropertyInfo == null)
+ if (jsonPropertyInfo == JsonPropertyInfo.s_missingProperty)
  {
  JsonPropertyInfo dataExtProperty = state.Current.JsonClassInfo.DataExtensionProperty;
  if (dataExtProperty == null)
@@ -94,9 +97,10 @@ private static void HandlePropertyName(
  state.Current.JsonPropertyInfo.JsonPropertyName = propertyNameArray;
  }
  }
-
- state.Current.PropertyIndex++;
  }
+
+ // Increment the PropertyIndex so JsonClassInfo.GetProperty() starts with the next property.
+ state.Current.PropertyIndex++;
  }
  }
 

src/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Read.HandleValue.cs

@@ -2,15 +2,19 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Runtime.CompilerServices;
+
 namespace System.Text.Json
 {
  public static partial class JsonSerializer
  {
- private static bool HandleValue(JsonTokenType tokenType, JsonSerializerOptions options, ref Utf8JsonReader reader, ref ReadStack state)
+ // AggressiveInlining used although a large method it is only called from two locations and is on a hot path.
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private static void HandleValue(JsonTokenType tokenType, JsonSerializerOptions options, ref Utf8JsonReader reader, ref ReadStack state)
  {
  if (state.Current.SkipProperty)
  {
- return false;
+ return;
  }
 
  JsonPropertyInfo jsonPropertyInfo = state.Current.JsonPropertyInfo;
@@ -23,10 +27,7 @@ private static bool HandleValue(JsonTokenType tokenType, JsonSerializerOptions o
  jsonPropertyInfo = state.Current.JsonClassInfo.CreatePolymorphicProperty(jsonPropertyInfo, typeof(object), options);
  }
 
- bool lastCall = (!state.Current.IsProcessingEnumerableOrDictionary && state.Current.ReturnValue == null);
-
  jsonPropertyInfo.Read(tokenType, ref state, ref reader);
- return lastCall;
  }
  }
 }