Optimize GC.AllocateUninitializedArray and use it in StringBuilder by adamsitnik · Pull Request #27364 · dotnet/coreclr (original) (raw)

I wanted to use GC.AllocateUninitializedArray in StringBuilder, but it was initially too slow. Calling it for small buffers was causing quite noticeable performance degradation.

I've tuned it up to ensure that it does not slow down the StringBuilder in "unlucky path" (small arrays) and does improve the perf in "lucky path" (big arrays). It should make this API more profitable to use in other places in the future.

Changes:

• remove one branch by changing the int to uint (if (length < 0)). This changes the behavior of this internal API for length < 0 - previously the caller would get IndexOutOfRangeException. Since this is an internal API, I hope it's OK.
• increase the threshold from 256 to 2048 bytes - please see the results below.
• enforce inlining of GC.AllocateUninitializedArray, move the expensive native call to separate method to not increase the size too much.

Micro benchmarks for the GC API:

[GenericTypeArguments(typeof(byte))] [GenericTypeArguments(typeof(char))] [GenericTypeArguments(typeof(object))] public class Perf_GC { private readonly Func<int, T[]> _allocateUninitializedArrayDelegate = CreateDelegate(typeof(GC), "AllocateUninitializedArray"); private readonly Func<int, T[]> _allocateArrayDelegate = CreateDelegate(typeof(Mimic), "AllocateArray");

[Params(256, 256 * 2, 256 * 3, 256 * 4, 256 * 6, 256 * 8)]
public int Length;

[Benchmark]
public T[] AllocateUninitializedArray() => _allocateUninitializedArrayDelegate(Length);

[Benchmark]
public T[] AllocateArray() => _allocateArrayDelegate(Length); // using delegate for apples to apples comparison

private static Func<N, T[]> CreateDelegate<N>(Type type, string methodName)
{
    // this method is not a part of .NET Standard so we need to use reflection
    var method = type
        .GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static)
        .MakeGenericMethod(typeof(T));

    return method != null ? (Func<N, T[]>)method.CreateDelegate(typeof(Func<N, T[]>)) : null;
}

}

public static class Mimic { internal static T[] AllocateArray(int size) => new T[size]; }

I've simplified the default BDN output to make it easier to compare the results. In the table below the "Before" is the execution time for GC.AllocateUninitializedArray before my changes, in the "After" are with my changes. The new T[] contains the time for calling new operator (to have some base comparison)