Performance improvements

Author: YohDeadfall

src/libraries/System.Text.Json/Common/JsonConstants.cs

@@ -8,5 +8,8 @@ internal static partial class JsonConstants
         // Standard format for double and single on non-inbox frameworks.
         public const string DoubleFormatString = "G17";
         public const string SingleFormatString = "G9";
+
+        public const int StackallocByteThreshold = 256;
+        public const int StackallocCharThreshold = StackallocByteThreshold / 2;
     }
 }

src/libraries/System.Text.Json/Common/JsonSeparatorNamingPolicy.cs

@@ -16,36 +16,56 @@ internal JsonSeparatorNamingPolicy(bool lowercase, char separator) =>
 
         public override string ConvertName(string name)
         {
-            int bufferLength = name.Length * 2;
-            char[]? buffer = bufferLength > 512
+            // Rented buffer 20% longer that the input.
+            int bufferLength = (12 * name.Length) / 10;
+            char[]? buffer = bufferLength > JsonConstants.StackallocCharThreshold
                 ? ArrayPool<char>.Shared.Rent(bufferLength)
                 : null;
 
             int resultLength = 0;
             Span<char> result = buffer is null
-                ? stackalloc char[512]
+                ? stackalloc char[JsonConstants.StackallocCharThreshold]
                 : buffer;
 
-            void WriteWord(ref Span<char> result, ReadOnlySpan<char> word)
+            void ExpandBuffer(ref Span<char> result)
+            {
+                var bufferNew = ArrayPool<char>.Shared.Rent(bufferLength *= 2);
+
+                result.CopyTo(bufferNew);
+
+                if (buffer is not null)
+                {
+                    ArrayPool<char>.Shared.Return(buffer, clearArray: true);
+                }
+
+                buffer = bufferNew;
+                result = buffer;
+            }
+
+            void WriteWord(ReadOnlySpan<char> word, ref Span<char> result)
             {
                 if (word.IsEmpty)
+                {
                     return;
+                }
 
-                int required = result.IsEmpty
-                    ? word.Length
-                    : word.Length + 1;
+                Span<char> destination = result.Slice(resultLength != 0
+                    ? resultLength + 1
+                    : resultLength);
 
-                if (required >= result.Length)
+                int written;
+                while (true)
                 {
-                    int bufferLength = result.Length * 2;
-                    char[] bufferNew = ArrayPool<char>.Shared.Rent(bufferLength);
-
-                    result.CopyTo(bufferNew);
+                    written = _lowercase
+                        ? word.ToLowerInvariant(destination)
+                        : word.ToUpperInvariant(destination);
 
-                    if (buffer is not null)
-                        ArrayPool<char>.Shared.Return(buffer);
+                    if (written > 0)
+                    {
+                        break;
+                    }
 
-                    buffer = bufferNew;
+                    ExpandBuffer(ref result);
                 }
 
                 if (resultLength != 0)
@@ -54,18 +74,7 @@ void WriteWord(ref Span<char> result, ReadOnlySpan<char> word)
                     resultLength += 1;
                 }
 
-                Span<char> destination = result.Slice(resultLength);
-
-                if (_lowercase)
-                {
-                    word.ToLowerInvariant(destination);
-                }
-                else
-                {
-                    word.ToUpperInvariant(destination);
-                }
-
-                resultLength += word.Length;
+                resultLength += written;
             }
 
             int first = 0;
@@ -81,7 +90,7 @@ void WriteWord(ref Span<char> result, ReadOnlySpan<char> word)
                     currentCategoryUnicode >= UnicodeCategory.ConnectorPunctuation &&
                     currentCategoryUnicode <= UnicodeCategory.OtherPunctuation)
                 {
-                    WriteWord(ref result, chars.Slice(first, index - first));
+                    WriteWord(chars.Slice(first, index - first), ref result);
 
                     previousCategory = CharCategory.Boundary;
                     first = index + 1;
@@ -102,7 +111,7 @@ void WriteWord(ref Span<char> result, ReadOnlySpan<char> word)
                     if (currentCategory == CharCategory.Lowercase && char.IsUpper(next) ||
                         next == '_')
                     {
-                        WriteWord(ref result, chars.Slice(first, index - first + 1));
+                        WriteWord(chars.Slice(first, index - first + 1), ref result);
 
                         previousCategory = CharCategory.Boundary;
                         first = index + 1;
@@ -114,7 +123,7 @@ void WriteWord(ref Span<char> result, ReadOnlySpan<char> word)
                         currentCategoryUnicode == UnicodeCategory.UppercaseLetter &&
                         char.IsLower(next))
                     {
-                        WriteWord(ref result, chars.Slice(first, index - first));
+                        WriteWord(chars.Slice(first, index - first), ref result);
 
                         previousCategory = CharCategory.Boundary;
                         first = index;
@@ -126,14 +135,14 @@ void WriteWord(ref Span<char> result, ReadOnlySpan<char> word)
                 }
             }
 
-            WriteWord(ref result, chars.Slice(first));
+            WriteWord(chars.Slice(first), ref result);
 
-            name = result
-                .Slice(0, resultLength)
-                .ToString();
+            name = result.Slice(0, resultLength).ToString();
 
             if (buffer is not null)
-                ArrayPool<char>.Shared.Return(buffer);
+            {
+                ArrayPool<char>.Shared.Return(buffer, clearArray: true);
+            }
 
             return name;
         }

src/libraries/System.Text.Json/src/System/Text/Json/JsonConstants.cs

@@ -50,9 +50,6 @@ internal static partial class JsonConstants
         public const int SpacesPerIndent = 2;
         public const int RemoveFlagsBitMask = 0x7FFFFFFF;
 
-        public const int StackallocByteThreshold = 256;
-        public const int StackallocCharThreshold = StackallocByteThreshold / 2;
-
         // In the worst case, an ASCII character represented as a single utf-8 byte could expand 6x when escaped.
         // For example: '+' becomes '\u0043'
         // Escaping surrogate pairs (represented by 3 or 4 utf-8 bytes) would expand to 12 bytes (which is still <= 6x).