Fastest Possible Reverse String faster then using Array.Reverse.

[KoromaruKoruko]

Description

So, me and my bf were playing around with a simple exercise. Reverse a String.
Well we overcomplicated it, and found out that the fastest 2 ways are rather Interesting.

This is a test comprised of a few different ways that we ended up going about the problem.

Note: StringBuilder and Direct String Manipulation were removed, as with anything over 10_000 chars would take far too long.

Configuration

Windows 10 21H1 (OS Build 19043.1348) X64
Running an AMD Ryzen 5 3600 @ 4Ghz all core, stock cooler
Using BenchmarkDotNet 0.13.1
16 GB of ram

Regression?

There hasn't been any regression, just that with new performance optimizations it has exposed an area which can be optimized further.

Data

// * Summary *

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1348 (21H1/May2021Update)
AMD Ryzen 5 3600, 1 CPU, 12 logical and 6 physical cores
.NET SDK=6.0.100
  [Host]   : .NET 6.0.0 (6.0.21.52210), X64 RyuJIT
  .NET 6.0 : .NET 6.0.0 (6.0.21.52210), X64 RyuJIT

Job=.NET 6.0  Runtime=.NET 6.0

|                                          Method |      Mean |    Error |   StdDev |
|------------------------------------------------ |----------:|---------:|---------:|
|                        ReverseString_StackAlloc |  61.86 us | 0.463 us | 0.410 us |
|              ReverseString_AllocateArray_Pinned | 112.38 us | 1.998 us | 1.869 us |
| ReverseString_AllocateUninitializedArray_Pinned | 106.41 us | 0.608 us | 0.539 us |
|                     ReverseString_Uninitialized |  63.27 us | 0.276 us | 0.231 us |
|                       ReverseString_ToCharArray |  71.33 us | 0.764 us | 0.714 us |
|                    ReverseString_EmptyCharArray |  62.49 us | 0.391 us | 0.365 us |
|                      ReverseString_ArrayReverse |  71.85 us | 0.741 us | 0.657 us |
|                     ReverseString_AllocateArray |  66.04 us | 0.220 us | 0.206 us |
|                    ReverseString_FixedUnsafeFor |  65.89 us | 0.259 us | 0.242 us |

// * Hints *
Outliers
  FastStringTests.ReverseString_StackAlloc: .NET 6.0                        -> 1 outlier  was  removed (63.51 us)
  FastStringTests.ReverseString_AllocateUninitializedArray_Pinned: .NET 6.0 -> 1 outlier  was  removed (108.54 us)
  FastStringTests.ReverseString_Uninitialized: .NET 6.0                     -> 2 outliers were removed (64.02 us, 65.20 us)
  FastStringTests.ReverseString_ArrayReverse: .NET 6.0                      -> 1 outlier  was  removed (73.29 us)

// * Legends *
  Mean   : Arithmetic mean of all measurements
  Error  : Half of 99.9% confidence interval
  StdDev : Standard deviation of all measurements
  1 us   : 1 Microsecond (0.000001 sec)

Analysis

From the Benchmark results you can see that there have been across the board improvements. Nothing has gotten slower, however one thing to note is that Array.Reverse is slower then a Fixed Unsafe loop, which means that the underlying implementation of Array.Reverse could be improved.

Benchmark Code (1 File)

using System;
using System.Collections.Generic;
using System.Globalization;

using BenchmarkDotNet.Running;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Reports;
using BenchmarkDotNet.Order;
using BenchmarkDotNet.Analysers;
using BenchmarkDotNet.Columns;
using BenchmarkDotNet.Diagnosers;
using BenchmarkDotNet.Exporters;
using BenchmarkDotNet.Filters;
using BenchmarkDotNet.Loggers;
using BenchmarkDotNet.Validators;

namespace Benchmarks
{
    [SimpleJob(runtimeMoniker: RuntimeMoniker.Net60)]
    public class FastStringTests
    {
        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_StackAlloc(String Str)
        {
            Char* output_bptr = stackalloc Char[Str.Length];
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output_bptr, 0, Str.Length);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_AllocateArray(String Str)
        {
            Char[] output = GC.AllocateArray<Char>(Str.Length, false);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_AllocateArray_Pinned(String Str)
        {
            Char[] output = GC.AllocateArray<Char>(Str.Length, true);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_AllocateUninitializedArray_Pinned(String Str)
        {
            Char[] output= GC.AllocateUninitializedArray<Char>(Str.Length, true);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_Uninitialized(String Str)
        {
            Char[] output = GC.AllocateUninitializedArray<Char>(Str.Length, false);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_ToCharArray(String Str)
        {
            Char[] chars = Str.ToCharArray();
            fixed (char* charsPtr = chars)
            {
                char* output_bptr = charsPtr;
                fixed (char* strPtr = Str)
                {
                    Char* str_ptr = strPtr + Str.Length - 1;
                    Char* output_ptr = output_bptr;

                    while (str_ptr >= strPtr)
                        *(output_ptr++) = *(str_ptr--);
                }
                return new string(output_bptr, 0, Str.Length);
            }
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_EmptyCharArray(String Str)
        {
            Char[] chars = new Char[Str.Length];
            fixed (char* charsPtr = chars)
            {
                char* output_bptr = charsPtr;
                fixed (char* strPtr = Str)
                {
                    Char* str_ptr = strPtr + Str.Length - 1;
                    Char* output_ptr = output_bptr;

                    while (str_ptr >= strPtr)
                        *(output_ptr++) = *(str_ptr--);
                }
                return new string(output_bptr, 0, Str.Length);
            }
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_ArrayReverse(String Str)
        {
            Char[] chars = Str.ToCharArray();
            Array.Reverse(chars);
            return new string(chars);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_FixedUnsafeFor(String Str)
        {
            Char* output_bptr = stackalloc Char[Str.Length];
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                for(int x = 0; x < Str.Length; x++)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output_bptr, 0, Str.Length);
        }

        public IEnumerable<String> GetRandomString()
        {
            const int StringLength = 100_000; // must be divisable by 2

            Byte[] bytes = new Byte[StringLength / 2];
            (new Random()).NextBytes(bytes);
            yield return Convert.ToHexString(bytes);
        }
    }


    public static class Program
    {
        public static void Main()
        {
            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).RunAllJoined(new Config());
        }

        public class Config : IConfig
        {
            public IOrderer Orderer => DefaultConfig.Instance.Orderer;
            public SummaryStyle SummaryStyle => DefaultConfig.Instance.SummaryStyle;
            public ConfigUnionRule UnionRule => DefaultConfig.Instance.UnionRule;
            public string ArtifactsPath => DefaultConfig.Instance.ArtifactsPath;
            public CultureInfo CultureInfo => DefaultConfig.Instance.CultureInfo;
            public ConfigOptions Options => DefaultConfig.Instance.Options;


            public IEnumerable<IAnalyser> GetAnalysers() => DefaultConfig.Instance.GetAnalysers();

            public IEnumerable<IColumnProvider> GetColumnProviders() => DefaultConfig.Instance.GetColumnProviders().Where((IColumnProvider provider) => provider != DefaultColumnProviders.Params);

            public IEnumerable<IDiagnoser> GetDiagnosers() => DefaultConfig.Instance.GetDiagnosers();

            public IEnumerable<IExporter> GetExporters() => DefaultConfig.Instance.GetExporters();

            public IEnumerable<IFilter> GetFilters() => DefaultConfig.Instance.GetFilters();

            public IEnumerable<HardwareCounter> GetHardwareCounters() => DefaultConfig.Instance.GetHardwareCounters();

            public IEnumerable<Job> GetJobs() => DefaultConfig.Instance.GetJobs();

            public IEnumerable<ILogger> GetLoggers() => DefaultConfig.Instance.GetLoggers();

            public IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules() => DefaultConfig.Instance.GetLogicalGroupRules();

            public IEnumerable<IValidator> GetValidators() => DefaultConfig.Instance.GetValidators();
        }
    }
}

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

[KoromaruKoruko]

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

I would say 'area-System.Runtime' best suits this, as it is simply about the implementation of Array.Reverse

[stephentoub]

one thing to note is that Array.Reverse is slower then a Fixed Unsafe loop

I don't understand the Fixed Unsafe loop code. It's doing this:

                Char* output_ptr = output_bptr;

                while (output_ptr != output_bptr)

so it's first assigning a value to output_ptr and then looping while they're not equal, but they were just made equal, so the loop will never execute. Meaning that benchmark appears to not actually be measuring what you intend.

Regardless, Array.Reverse is already doing an unsafe loop internally. It could probably shave off a few cycles by skipping some of the argument validation in the overload that doesn't take offset and count, but other than that it's not clear how it would be significantly improved.

[KoromaruKoruko]

one thing to note is that Array.Reverse is slower then a Fixed Unsafe loop

I don't understand the Fixed Unsafe loop code. It's doing this:

                Char* output_ptr = output_bptr;

                while (output_ptr != output_bptr)

so it's first assigning a value to output_ptr and then looping while they're not equal, but they were just made equal, so the loop will never execute. Meaning that benchmark appears to not actually be measuring what you intend.

Regardless, Array.Reverse is already doing an unsafe loop internally. It could probably shave off a few cycles by skipping some of the argument validation in the overload that doesn't take offset and count, but other than that it's not clear how it would be significantly improved.

yes i noticed that. and re-ran the tests again, the result is still FixedUnsafe is faster. just not that much faster

[KoromaruKoruko]

Made a Version that uses a For Loop. And its even then Faster.
just not in .NET5

|                       Method |      Job |  Runtime |     Mean |    Error |   StdDev |
|----------------------------- |--------- |--------- |---------:|---------:|---------:|
|    ReverseString_FixedUnsafe | .NET 5.0 | .NET 5.0 | 26.21 ns | 0.291 ns | 0.273 ns |
|   ReverseString_ArrayReverse | .NET 5.0 | .NET 5.0 | 22.83 ns | 0.209 ns | 0.185 ns |
| ReverseString_FixedUnsafeFor | .NET 5.0 | .NET 5.0 | 27.26 ns | 0.317 ns | 0.297 ns |
|    ReverseString_FixedUnsafe | .NET 6.0 | .NET 6.0 | 17.47 ns | 0.155 ns | 0.138 ns |
|   ReverseString_ArrayReverse | .NET 6.0 | .NET 6.0 | 20.32 ns | 0.172 ns | 0.161 ns |
| ReverseString_FixedUnsafeFor | .NET 6.0 | .NET 6.0 | 18.38 ns | 0.333 ns | 0.312 ns |

[ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_FixedUnsafeFor(String Str)
        {
            Char* output_bptr = stackalloc Char[Str.Length];
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                for(int x = 0; x < Str.Length; x++)
                    *(output_bptr++) = *(str_ptr--);
            }
            return new string(output_bptr, 0, Str.Length);
        }

[stephentoub]

the result is still FixedUnsafe is faster. just not that much faster

Thanks. But I still don't think it's measuring a difference in the comparison; rather, it's really comparing the cost of stackalloc vs heap alloc for the output buffer. The FixedUnsafe code is using stackalloc, whereas the ArrayReverse code is using str.ToCharArray, which needs to allocate an array on the heap and then copy the contents of the string into it; that's a non-trivial expense for strings of this length. Try tweaking your FixedUnsafe to instead be:

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_FixedUnsafe2(String Str)
        {
            Char[] chars = Str.ToCharArray();
            fixed (char* charsPtr = chars)
            {
                char* output_bptr = charsPtr;
                fixed (char* strPtr = Str)
                {
                    Char* str_ptr = strPtr + Str.Length - 1;
                    Char* output_ptr = output_bptr;

                    while (str_ptr != strPtr)
                        *(output_bptr++) = *(str_ptr--);
                }
                return new string(output_bptr, 0, Str.Length);
            }
        }

i.e. the same as it was before but now using ToCharArray as well to even the score. I see that as being as being worse than the ArrayReverse case.

As noted, other than potentially saving a few cycles to avoid some argument validation, it's not clear what would be improved in Array.Reverse; it's already doing a loop without bounds checks.

[KoromaruKoruko]

Ok Testing Loads of Allocation Senario's
GC.AllocateArray (Both Pinned and Unpinned)
GC.AllocateUninitializedArray (Both Pinned and Unpinned)
ToCharArray
new Char[]

However Only Targeting .NET6 now

|                                          Method |      Mean |    Error |   StdDev |
|------------------------------------------------ |----------:|---------:|---------:|
|                        ReverseString_StackAlloc |  15.18 ns | 0.191 ns | 0.179 ns |
|                     ReverseString_AllocateArray |  47.11 ns | 0.474 ns | 0.444 ns |
|              ReverseString_AllocateArray_Pinned | 168.42 ns | 1.264 ns | 1.120 ns |
| ReverseString_AllocateUninitializedArray_Pinned | 170.62 ns | 3.399 ns | 3.338 ns |
|                     ReverseString_Uninitialized |  21.30 ns | 0.471 ns | 0.504 ns |
|                       ReverseString_ToCharArray |  24.17 ns | 0.429 ns | 0.401 ns |
|                    ReverseString_EmptyCharArray |  18.81 ns | 0.443 ns | 0.435 ns |
|                      ReverseString_ArrayReverse |  20.09 ns | 0.197 ns | 0.184 ns |
|                    ReverseString_FixedUnsafeFor |  17.09 ns | 0.174 ns | 0.163 ns |

[SimpleJob(runtimeMoniker: RuntimeMoniker.Net60)]
    public class FastStringTests
    {
        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_StackAlloc(String Str)
        {
            Char* output_bptr = stackalloc Char[Str.Length];
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (strPtr != str_ptr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output_bptr, 0, Str.Length);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_AllocateArray(String Str)
        {
            Char[] output = GC.AllocateArray<Char>(Str.Length, false);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (strPtr != str_ptr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_AllocateArray_Pinned(String Str)
        {
            Char[] output = GC.AllocateArray<Char>(Str.Length, true);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (strPtr != str_ptr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_AllocateUninitializedArray_Pinned(String Str)
        {
            Char[] output= GC.AllocateUninitializedArray<Char>(Str.Length, true);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (strPtr != str_ptr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_Uninitialized(String Str)
        {
            Char[] output = GC.AllocateUninitializedArray<Char>(Str.Length, false);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (strPtr != str_ptr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_ToCharArray(String Str)
        {
            Char[] chars = Str.ToCharArray();
            fixed (char* charsPtr = chars)
            {
                char* output_bptr = charsPtr;
                fixed (char* strPtr = Str)
                {
                    Char* str_ptr = strPtr + Str.Length - 1;
                    Char* output_ptr = output_bptr;

                    while (str_ptr != strPtr)
                        *(output_ptr++) = *(str_ptr--);
                }
                return new string(output_bptr, 0, Str.Length);
            }
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_EmptyCharArray(String Str)
        {
            Char[] chars = new Char[Str.Length];
            fixed (char* charsPtr = chars)
            {
                char* output_bptr = charsPtr;
                fixed (char* strPtr = Str)
                {
                    Char* str_ptr = strPtr + Str.Length - 1;
                    Char* output_ptr = output_bptr;

                    while (str_ptr != strPtr)
                        *(output_ptr++) = *(str_ptr--);
                }
                return new string(output_bptr, 0, Str.Length);
            }
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_ArrayReverse(String Str)
        {
            Char[] chars = Str.ToCharArray();
            Array.Reverse(chars);
            return new string(chars);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_FixedUnsafeFor(String Str)
        {
            Char* output_bptr = stackalloc Char[Str.Length];
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                for(int x = 0; x < Str.Length; x++)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output_bptr, 0, Str.Length);
        }

        public IEnumerable<String> GetRandomString()
        {
            const int StringLength = 100_000; // must be divisable by 2

            Byte[] bytes = new Byte[StringLength / 2];
            (new Random()).NextBytes(bytes);
            yield return $"{bytes}:X";
        }
    }

[KoromaruKoruko]

It seems that simply allocating an empty char array is still faster.
ToCharArray isn't however.

that and i thought pre-pinning would be faster, but DAMN thats slow.

[stephentoub]

It seems that simply allocating an empty char array is still faster. ToCharArray isn't however.

Allocating a char array is faster than both allocating that same char array and then also copying data into it.

That's not related to the reverse implementation, though.

[Tornhoof]

Are you aware that your GetRandomString() method only outputs System.Byte[]:X?
you probably mean:

yield return Convert.ToHexString(bytes);

You can always experiment with string.Create too.

[KoromaruKoruko]

well this looked stupid, not only did i put the format string in the wrong place, but also used it on an array when it can only be used on numeric primitives. yay.

I also had the While loops on the wrong way round on all the unsafe version.
I am honestly too tired right now.

|                                          Method |      Mean |    Error |   StdDev |
|------------------------------------------------ |----------:|---------:|---------:|
|                        ReverseString_StackAlloc |  61.86 us | 0.463 us | 0.410 us |
|              ReverseString_AllocateArray_Pinned | 112.38 us | 1.998 us | 1.869 us |
| ReverseString_AllocateUninitializedArray_Pinned | 106.41 us | 0.608 us | 0.539 us |
|                     ReverseString_Uninitialized |  63.27 us | 0.276 us | 0.231 us |
|                       ReverseString_ToCharArray |  71.33 us | 0.764 us | 0.714 us |
|                    ReverseString_EmptyCharArray |  62.49 us | 0.391 us | 0.365 us |
|                      ReverseString_ArrayReverse |  71.85 us | 0.741 us | 0.657 us |
|                     ReverseString_AllocateArray |  66.04 us | 0.220 us | 0.206 us |
|                    ReverseString_FixedUnsafeFor |  65.89 us | 0.259 us | 0.242 us |

[SimpleJob(runtimeMoniker: RuntimeMoniker.Net60)]
    public class FastStringTests
    {
        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_StackAlloc(String Str)
        {
            Char* output_bptr = stackalloc Char[Str.Length];
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output_bptr, 0, Str.Length);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_AllocateArray(String Str)
        {
            Char[] output = GC.AllocateArray<Char>(Str.Length, false);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_AllocateArray_Pinned(String Str)
        {
            Char[] output = GC.AllocateArray<Char>(Str.Length, true);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_AllocateUninitializedArray_Pinned(String Str)
        {
            Char[] output= GC.AllocateUninitializedArray<Char>(Str.Length, true);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_Uninitialized(String Str)
        {
            Char[] output = GC.AllocateUninitializedArray<Char>(Str.Length, false);
            fixed (char* output_bptr = output)
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                while (str_ptr >= strPtr)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_ToCharArray(String Str)
        {
            Char[] chars = Str.ToCharArray();
            fixed (char* charsPtr = chars)
            {
                char* output_bptr = charsPtr;
                fixed (char* strPtr = Str)
                {
                    Char* str_ptr = strPtr + Str.Length - 1;
                    Char* output_ptr = output_bptr;

                    while (str_ptr >= strPtr)
                        *(output_ptr++) = *(str_ptr--);
                }
                return new string(output_bptr, 0, Str.Length);
            }
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_EmptyCharArray(String Str)
        {
            Char[] chars = new Char[Str.Length];
            fixed (char* charsPtr = chars)
            {
                char* output_bptr = charsPtr;
                fixed (char* strPtr = Str)
                {
                    Char* str_ptr = strPtr + Str.Length - 1;
                    Char* output_ptr = output_bptr;

                    while (str_ptr >= strPtr)
                        *(output_ptr++) = *(str_ptr--);
                }
                return new string(output_bptr, 0, Str.Length);
            }
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_ArrayReverse(String Str)
        {
            Char[] chars = Str.ToCharArray();
            Array.Reverse(chars);
            return new string(chars);
        }

        [ArgumentsSource(nameof(GetRandomString))]
        [Benchmark]
        public unsafe string ReverseString_FixedUnsafeFor(String Str)
        {
            Char* output_bptr = stackalloc Char[Str.Length];
            fixed (char* strPtr = Str)
            {
                Char* str_ptr = strPtr + Str.Length - 1;
                Char* output_ptr = output_bptr;

                for(int x = 0; x < Str.Length; x++)
                    *(output_ptr++) = *(str_ptr--);
            }
            return new string(output_bptr, 0, Str.Length);
        }

        public IEnumerable<String> GetRandomString()
        {
            const int StringLength = 100_000; // must be divisable by 2

            Byte[] bytes = new Byte[StringLength / 2];
            (new Random()).NextBytes(bytes);
            yield return Convert.ToHexString(bytes);
        }
    }

[stephentoub]

@KoromaruKoruko, is there any action item here now or can this be closed?