internal struct ValueStringBuilder; Optimizations of string concatenations (#109)

* internal struct ValueStringBuilder

* stackalloc 256 chars

Author: SergeiPavlov

Orm/Xtensive.Orm/Core/Extensions/EnumerableExtensions.cs

@@ -200,12 +200,12 @@ public static string ToDelimitedString<TItem>(this IEnumerable<TItem> source, st
     {
       if (source==null)
         return string.Empty;
-      var sb = new StringBuilder();
+      var sb = new ValueStringBuilder(stackalloc char[4096]);
       bool insertDelimiter = false;
       foreach (var item in source) {
         if (insertDelimiter)
           sb.Append(delimiter);
-        sb.Append(item);
+        sb.Append(item?.ToString());
         insertDelimiter = true;
       }
       return sb.ToString();
@@ -222,12 +222,12 @@ public static string ToDelimitedString(this IEnumerable source, string separator
     {
       if (source==null)
         return string.Empty;
-      var sb = new StringBuilder();
+      var sb = new ValueStringBuilder(stackalloc char[4096]);
       bool insertDelimiter = false;
       foreach (object item in source) {
         if (insertDelimiter)
           sb.Append(separator);
-        sb.Append(item);
+        sb.Append(item?.ToString());
         insertDelimiter = true;
       }
       return sb.ToString();

Orm/Xtensive.Orm/Core/Extensions/StringExtensions.cs

@@ -96,7 +96,7 @@ public static string Indent(this string value, int indentSize, bool indentFirstL
     {
       ArgumentValidator.EnsureArgumentNotNull(value, "value");
       var indent = new string(' ', indentSize);
-      var sb = new StringBuilder();
+      var sb = new ValueStringBuilder(stackalloc char[4096]);
       if (indentFirstLine)
         sb.Append(indent);
       int start = 0;
@@ -207,7 +207,7 @@ public static string RevertibleJoin(this IEnumerable<string> source, char escape
         throw new ArgumentException(
           Strings.ExEscapeCharacterMustDifferFromDelimiterCharacter);
 
-      var sb = new StringBuilder();
+      var sb = new ValueStringBuilder(stackalloc char[4096]);
       bool needDelimiter = false;
       foreach (var part in source) {
         if (needDelimiter)
@@ -283,7 +283,7 @@ public static Pair<string> RevertibleSplitFirstAndTail(this string source, char
         throw new ArgumentException(
           Strings.ExEscapeCharacterMustDifferFromDelimiterCharacter);
 
-      var sb = new StringBuilder();
+      var sb = new ValueStringBuilder(stackalloc char[4096]);
       bool previousCharIsEscape = false;
       for (int i = 0; i<source.Length; i++) {
         char c = source[i];
@@ -315,7 +315,7 @@ public static string Escape(this string source, char escape, char[] escapedChars
       if (escapedChars==null)
         throw new ArgumentNullException("escapedChars");
       var chars = escapedChars.Append(escape);
-      var sb = new StringBuilder();
+      var sb = new ValueStringBuilder(stackalloc char[4096]);
       foreach (var c in source) {
         var found = false;
         for (int i = 0; i < chars.Length && !found; i++)
@@ -336,7 +336,7 @@ public static string Unescape(this string source, char escape)
     {
       if (source==null)
         throw new ArgumentNullException("source");
-      var sb = new StringBuilder(source.Length);
+      var sb = new ValueStringBuilder(source.Length);
       var previousCharIsEscape = false;
       foreach (var c in source) {
         if (previousCharIsEscape) {

Orm/Xtensive.Orm/Core/ValueStringBuilder.cs

@@ -0,0 +1,298 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// Copy/pasted from https://github.com/dotnet/runtime/blob/main/src/libraries/Common/src/System/Text/ValueStringBuilder.cs
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+#nullable enable
+
+namespace Xtensive.Core
+{
+  internal ref struct ValueStringBuilder
+  {
+    private char[]? _arrayToReturnToPool;
+    private Span<char> _chars;
+    private int _pos;
+
+    public ValueStringBuilder(Span<char> initialBuffer)
+    {
+      _arrayToReturnToPool = null;
+      _chars = initialBuffer;
+      _pos = 0;
+    }
+
+    public ValueStringBuilder(int initialCapacity)
+    {
+      _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
+      _chars = _arrayToReturnToPool;
+      _pos = 0;
+    }
+
+    public int Length
+    {
+      get => _pos;
+      set {
+        Debug.Assert(value >= 0);
+        Debug.Assert(value <= _chars.Length);
+        _pos = value;
+      }
+    }
+
+    public int Capacity => _chars.Length;
+
+    public void EnsureCapacity(int capacity)
+    {
+      // This is not expected to be called this with negative capacity
+      Debug.Assert(capacity >= 0);
+
+      // If the caller has a bug and calls this with negative capacity, make sure to call Grow to throw an exception.
+      if ((uint) capacity > (uint) _chars.Length)
+        Grow(capacity - _pos);
+    }
+
+    /// <summary>
+    /// Get a pinnable reference to the builder.
+    /// Does not ensure there is a null char after <see cref="Length"/>
+    /// This overload is pattern matched in the C# 7.3+ compiler so you can omit
+    /// the explicit method call, and write eg "fixed (char* c = builder)"
+    /// </summary>
+    public ref char GetPinnableReference()
+    {
+      return ref MemoryMarshal.GetReference(_chars);
+    }
+
+    /// <summary>
+    /// Get a pinnable reference to the builder.
+    /// </summary>
+    /// <param name="terminate">Ensures that the builder has a null char after <see cref="Length"/></param>
+    public ref char GetPinnableReference(bool terminate)
+    {
+      if (terminate) {
+        EnsureCapacity(Length + 1);
+        _chars[Length] = '\0';
+      }
+
+      return ref MemoryMarshal.GetReference(_chars);
+    }
+
+    public ref char this[int index]
+    {
+      get {
+        Debug.Assert(index < _pos);
+        return ref _chars[index];
+      }
+    }
+
+    public override string ToString()
+    {
+      string s = _chars.Slice(0, _pos).ToString();
+      Dispose();
+      return s;
+    }
+
+    /// <summary>Returns the underlying storage of the builder.</summary>
+    public Span<char> RawChars => _chars;
+
+    /// <summary>
+    /// Returns a span around the contents of the builder.
+    /// </summary>
+    /// <param name="terminate">Ensures that the builder has a null char after <see cref="Length"/></param>
+    public ReadOnlySpan<char> AsSpan(bool terminate)
+    {
+      if (terminate) {
+        EnsureCapacity(Length + 1);
+        _chars[Length] = '\0';
+      }
+
+      return _chars.Slice(0, _pos);
+    }
+
+    public ReadOnlySpan<char> AsSpan() => _chars.Slice(0, _pos);
+    public ReadOnlySpan<char> AsSpan(int start) => _chars.Slice(start, _pos - start);
+    public ReadOnlySpan<char> AsSpan(int start, int length) => _chars.Slice(start, length);
+
+    public bool TryCopyTo(Span<char> destination, out int charsWritten)
+    {
+      if (_chars.Slice(0, _pos).TryCopyTo(destination)) {
+        charsWritten = _pos;
+        Dispose();
+        return true;
+      }
+      else {
+        charsWritten = 0;
+        Dispose();
+        return false;
+      }
+    }
+
+    public void Insert(int index, char value, int count)
+    {
+      if (_pos > _chars.Length - count) {
+        Grow(count);
+      }
+
+      int remaining = _pos - index;
+      _chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count));
+      _chars.Slice(index, count).Fill(value);
+      _pos += count;
+    }
+
+    public void Insert(int index, string? s)
+    {
+      if (s == null) {
+        return;
+      }
+
+      int count = s.Length;
+
+      if (_pos > (_chars.Length - count)) {
+        Grow(count);
+      }
+
+      int remaining = _pos - index;
+      _chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count));
+      s.CopyTo(_chars.Slice(index));
+      _pos += count;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Append(char c)
+    {
+      int pos = _pos;
+      Span<char> chars = _chars;
+      if ((uint) pos < (uint) chars.Length) {
+        chars[pos] = c;
+        _pos = pos + 1;
+      }
+      else {
+        GrowAndAppend(c);
+      }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Append(string? s)
+    {
+      if (s == null) {
+        return;
+      }
+
+      int pos = _pos;
+      if (s.Length == 1 &&
+          (uint) pos < (uint) _chars
+            .Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc.
+      {
+        _chars[pos] = s[0];
+        _pos = pos + 1;
+      }
+      else {
+        AppendSlow(s);
+      }
+    }
+
+    private void AppendSlow(string s)
+    {
+      int pos = _pos;
+      if (pos > _chars.Length - s.Length) {
+        Grow(s.Length);
+      }
+
+      s.CopyTo(_chars.Slice(pos));
+      _pos += s.Length;
+    }
+
+    public void Append(char c, int count)
+    {
+      if (_pos > _chars.Length - count) {
+        Grow(count);
+      }
+
+      Span<char> dst = _chars.Slice(_pos, count);
+      for (int i = 0; i < dst.Length; i++) {
+        dst[i] = c;
+      }
+
+      _pos += count;
+    }
+
+    public void Append(ReadOnlySpan<char> value)
+    {
+      int pos = _pos;
+      if (pos > _chars.Length - value.Length) {
+        Grow(value.Length);
+      }
+
+      value.CopyTo(_chars.Slice(_pos));
+      _pos += value.Length;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public Span<char> AppendSpan(int length)
+    {
+      int origPos = _pos;
+      if (origPos > _chars.Length - length) {
+        Grow(length);
+      }
+
+      _pos = origPos + length;
+      return _chars.Slice(origPos, length);
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void GrowAndAppend(char c)
+    {
+      Grow(1);
+      Append(c);
+    }
+
+    /// <summary>
+    /// Resize the internal buffer either by doubling current buffer size or
+    /// by adding <paramref name="additionalCapacityBeyondPos"/> to
+    /// <see cref="_pos"/> whichever is greater.
+    /// </summary>
+    /// <param name="additionalCapacityBeyondPos">
+    /// Number of chars requested beyond current position.
+    /// </param>
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void Grow(int additionalCapacityBeyondPos)
+    {
+      Debug.Assert(additionalCapacityBeyondPos > 0);
+      Debug.Assert(_pos > _chars.Length - additionalCapacityBeyondPos,
+        "Grow called incorrectly, no resize is needed.");
+
+      const uint ArrayMaxLength = 0x7FFFFFC7; // same as Array.MaxLength
+
+      // Increase to at least the required size (_pos + additionalCapacityBeyondPos), but try
+      // to double the size if possible, bounding the doubling to not go beyond the max array length.
+      int newCapacity = (int) Math.Max(
+        (uint) (_pos + additionalCapacityBeyondPos),
+        Math.Min((uint) _chars.Length * 2, ArrayMaxLength));
+
+      // Make sure to let Rent throw an exception if the caller has a bug and the desired capacity is negative.
+      // This could also go negative if the actual required length wraps around.
+      char[] poolArray = ArrayPool<char>.Shared.Rent(newCapacity);
+
+      _chars.Slice(0, _pos).CopyTo(poolArray);
+
+      char[]? toReturn = _arrayToReturnToPool;
+      _chars = _arrayToReturnToPool = poolArray;
+      if (toReturn != null) {
+        ArrayPool<char>.Shared.Return(toReturn);
+      }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Dispose()
+    {
+      char[]? toReturn = _arrayToReturnToPool;
+      this = default; // for safety, to avoid using pooled array if this instance is erroneously appended to again
+      if (toReturn != null) {
+        ArrayPool<char>.Shared.Return(toReturn);
+      }
+    }
+  }
+}