Add UTF8 parser performance tests (dotnet/corefx#32026)

* Remove inner iteration count

* Add bool parsing perf test

* Add int16 parsing perf test

* Add int32 parsing perf test

* Add sbytes parsing perf test

* Add uint32 parsing perf test

* Add uint64 parsing perf test

* Rename 'wordy' test names

* Remove duplicate test

* Add inline data to ParserSbyte

* Rename test method

* Rename test method

* Remove all BytesConsumed suffixes

* Clean up some tests after review

* Update Perf.Utf8Parser.cs

* Update Perf.Utf8Parser.cs

Remove unused types

* Add inner iterations

* Fix syntax

* Remove some unused code

* Remove duplicate

* Remove duplicate ByteSpanToUint64

* Match StringToSByte inline data with ByteSpanToSByte

* Add more inline data

* Update Perf.Utf8Parser.cs

Add more consistency in names and inline data

* Rename to StringToSByte

* Remove some test data

* Remove all unsafe keywords

* Remove StringToUInt64_Baseline

* Rename test

* Add baseline prefix to stringToUInt64 test

* Add StringToUInt32Hex_Baseline test

* Add StringToUint32hex_variablelenght

* Match ByteSpanToInt16 with StringToInt16 test cases

* Add StringToTimeOffsetR

* Add StringToByte_Baseline test

* Match ByteSpanToInt32 and StringToInt32 test cases

* Add StringToInt64_Baseline test

* Use numberstyle overload for short parsing

* Use different overload on datetime baseline

* Update Perf.Utf8Parser.cs

Remove unneeded inline data on StringToSByte_baseline test

* Use DateTimeOffset.TryParseExact

Commit migrated from https://github.com/dotnet/corefx/commit/c655a9aa7a9df0fa19df8792f16e13543eeac7b6

diff --git a/src/libraries/System.Memory/tests/Performance/Perf.Utf8Parser.cs b/src/libraries/System.Memory/tests/Performance/Perf.Utf8Parser.cs
index 7d1294f..d4047e9 100644 (file)
--- a/src/libraries/System.Memory/tests/Performance/Perf.Utf8Parser.cs
+++ b/src/libraries/System.Memory/tests/Performance/Perf.Utf8Parser.cs
@@ -2,6 +2,7 @@
 // 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.Globalization;
 using System.Text;
 using Microsoft.Xunit.Performance;
 using Xunit;
@@ -10,12 +11,598 @@ namespace System.Buffers.Text.Tests
 {
     public static partial class Utf8ParserTests
     {
-        private const int InnerCount = 100000;
+        private const int InnerCount = 100_000;
 
-        [Benchmark]
+        private static readonly string[] s_UInt32TextArray = new string[10]
+        {
+            "42",
+            "429496",
+            "429496729",
+            "42949",
+            "4",
+            "42949672",
+            "4294",
+            "429",
+            "4294967295",
+            "4294967"
+        };
+
+        private static readonly string[] s_UInt32TextArrayHex = new string[8]
+        {
+            "A2",
+            "A29496",
+            "A2949",
+            "A",
+            "A2949672",
+            "A294",
+            "A29",
+            "A294967"
+        };
+
+        private static readonly string[] s_Int16TextArray = new string[13]
+        {
+            "21474",
+            "2",
+            "-21474",
+            "31484",
+            "-21",
+            "-2",
+            "214",
+            "2147",
+            "-2147",
+            "-9345",
+            "9345",
+            "1000",
+            "-214"
+        };
+
+        private static readonly string[] s_Int32TextArray = new string[20]
+        {
+            "214748364",
+            "2",
+            "21474836",
+            "-21474",
+            "21474",
+            "-21",
+            "-2",
+            "214",
+            "-21474836",
+            "-214748364",
+            "2147",
+            "-2147",
+            "-214748",
+            "-2147483",
+            "214748",
+            "-2147483648",
+            "2147483647",
+            "21",
+            "2147483",
+            "-214"
+        };
+
+        private static readonly string[] s_SByteTextArray = new string[17]
+        {
+            "95",
+            "2",
+            "112",
+            "-112",
+            "-21",
+            "-2",
+            "114",
+            "-114",
+            "-124",
+            "117",
+            "-117",
+            "-14",
+            "14",
+            "74",
+            "21",
+            "83",
+            "-127"
+        };
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("2134567890")] // standard parse
+        [InlineData("18446744073709551615")] // max value
+        [InlineData("0")] // min value
+        [InlineData("000000000000000000001235abcdfg")]
+        [InlineData("21474836abcdefghijklmnop")]
+        private static void StringToUInt64_Baseline(string text)
+        {
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        ulong.TryParse(text, out ulong value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("abcdef")] // standard parse
+        [InlineData("ffffffffffffffff")] // max value
+        [InlineData("0")] // min value
+        private static void StringToUInt64Hex_Baseline(string text)
+        {
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        ulong.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out ulong value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("2134567890")] // standard parse
+        [InlineData("18446744073709551615")] // max value
+        [InlineData("0")] // min value
+        [InlineData("000000000000000000001235abcdfg")]
+        [InlineData("21474836abcdefghijklmnop")]
+        private static void ByteSpanToUInt64(string text)
+        {
+            byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
+            ReadOnlySpan<byte> utf8ByteSpan = new ReadOnlySpan<byte>(utf8ByteArray);
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        Utf8Parser.TryParse(utf8ByteSpan, out ulong value, out int bytesConsumed);
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("abcdef")] // standard parse
+        [InlineData("ffffffffffffffff")] // max value
+        [InlineData("0")] // min value
+        private static void ByteSpanToUInt64Hex(string text)
+        {
+            byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
+            ReadOnlySpan<byte> utf8ByteSpan = new ReadOnlySpan<byte>(utf8ByteArray);
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        Utf8Parser.TryParse(utf8ByteSpan, out ulong value, out int bytesConsumed, 'X');
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("2134567890")] // standard parse
+        [InlineData("4294967295")] // max value
+        [InlineData("0")] // min value
+        [InlineData("000000000000000000001235abcdfg")]
+        [InlineData("21474836abcdefghijklmnop")]
+        private static void StringToUInt32_Baseline(string text)
+        {
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        uint.TryParse(text, out uint value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void StringToUInt32_VariableLength_Baseline()
+        {
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        uint.TryParse(s_UInt32TextArray[i % 10], out uint value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("abcdef")] // standard parse
+        [InlineData("ffffffff")] // max value
+        [InlineData("0")] // min value
+        private static void StringToUInt32Hex_Baseline(string text)
+        {
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        uint.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out uint value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void StringToUInt32Hex_VariableLength()
+        {
+            int textLength = s_UInt32TextArrayHex.Length;
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        string text = s_UInt32TextArrayHex[i % textLength];
+                        uint.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out uint value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("2134567890")] // standard parse
+        [InlineData("4294967295")] // max value
+        [InlineData("0")] // min value
+        [InlineData("000000000000000000001235abcdfg")]
+        [InlineData("21474836abcdefghijklmnop")]
+        private static void ByteSpanToUInt32(string text)
+        {
+            byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
+            var utf8ByteSpan = new ReadOnlySpan<byte>(utf8ByteArray);
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        Utf8Parser.TryParse(utf8ByteSpan, out uint value, out int bytesConsumed);
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void ByteSpanToUInt32_VariableLength()
+        {
+            int textLength = s_UInt32TextArray.Length;
+            byte[][] utf8ByteArray = (byte[][])Array.CreateInstance(typeof(byte[]), textLength);
+            for (var i = 0; i < textLength; i++)
+            {
+                utf8ByteArray[i] = Encoding.UTF8.GetBytes(s_UInt32TextArray[i]);
+            }
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray[i % textLength];
+                        Utf8Parser.TryParse(utf8ByteSpan, out uint value, out int bytesConsumed);
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("abcdef")] // standard parse
+        [InlineData("ffffffff")] // max value
+        [InlineData("0")] // min value
+        private static void ByteSpanToUInt32Hex(string text)
+        {
+            byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
+            var utf8ByteSpan = new ReadOnlySpan<byte>(utf8ByteArray);
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        Utf8Parser.TryParse(utf8ByteSpan, out uint value, out int bytesConsumed, 'X');
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void ByteSpanToUInt32Hex_VariableLength()
+        {
+            int textLength = s_UInt32TextArrayHex.Length;
+            byte[][] utf8ByteArray = (byte[][])Array.CreateInstance(typeof(byte[]), textLength);
+            for (var i = 0; i < textLength; i++)
+            {
+                utf8ByteArray[i] = Encoding.UTF8.GetBytes(s_UInt32TextArrayHex[i]);
+            }
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray[i % textLength];
+                        Utf8Parser.TryParse(utf8ByteSpan, out uint value, out int bytesConsumed, 'X');
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void ByteSpanToSByte_VariableLength()
+        {
+            int textLength = s_SByteTextArray.Length;
+            byte[][] utf8ByteArray = (byte[][])Array.CreateInstance(typeof(byte[]), textLength);
+            for (var i = 0; i < textLength; i++)
+            {
+                utf8ByteArray[i] = Encoding.UTF8.GetBytes(s_SByteTextArray[i]);
+            }
+
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray[i % textLength];
+                        Utf8Parser.TryParse(utf8ByteSpan, out sbyte value, out int bytesConsumed);
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("0")]
+        [InlineData("107")] // standard parse
+        [InlineData("127")] // max value
+        [InlineData("-128")] // min value
+        [InlineData("-21abcdefghijklmnop")]
+        [InlineData("21abcdefghijklmnop")]
+        [InlineData("00000000000000000000123")]
+        private static void StringToSByte_Baseline(string text)
+        {
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        sbyte.TryParse(text, out sbyte value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void StringToSByte_VariableLength_Baseline()
+        {
+            int textLength = s_SByteTextArray.Length;
+            byte[][] utf8ByteArray = (byte[][])Array.CreateInstance(typeof(byte[]), textLength);
+            for (var i = 0; i < textLength; i++)
+            {
+                utf8ByteArray[i] = Encoding.UTF8.GetBytes(s_SByteTextArray[i]);
+            }
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        sbyte.TryParse(s_SByteTextArray[i % textLength], out sbyte value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("0")]
+        [InlineData("107374182")] // standard parse
+        [InlineData("2147483647")] // max value
+        [InlineData("-2147483648")] // min value
+        [InlineData("000000000000000000001235abcdfg")]
+        [InlineData("21474836abcdefghijklmnop")]
+        [InlineData("-21474abcdefghijklmnop")]
+        private static void ByteSpanToInt32(string text)
+        {
+            byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
+            var utf8ByteSpan = new ReadOnlySpan<byte>(utf8ByteArray);
+
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        Utf8Parser.TryParse(utf8ByteSpan, out int value, out int bytesConsumed);
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void ByteSpanToInt32_VariableLength()
+        {
+            int textLength = s_Int32TextArray.Length;
+            byte[][] utf8ByteArray = (byte[][])Array.CreateInstance(typeof(byte[]), textLength);
+            for (var i = 0; i < textLength; i++)
+            {
+                utf8ByteArray[i] = Encoding.UTF8.GetBytes(s_Int32TextArray[i]);
+            }
+
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray[i % textLength];
+                        Utf8Parser.TryParse(utf8ByteSpan, out int value, out int bytesConsumed);
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("0")]
+        [InlineData("107374182")] // standard parse
+        [InlineData("2147483647")] // max value
+        [InlineData("-2147483648")] // min value
+        [InlineData("000000000000000000001235abcdfg")]
+        [InlineData("21474836abcdefghijklmnop")]
+        [InlineData("-21474abcdefghijklmnop")]
+        private static void StringToInt32_Baseline(string text)
+        {
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        int.TryParse(text, out int value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void StringToInt32_VariableLength_Baseline()
+        {
+            int textLength = s_Int32TextArray.Length;
+            byte[][] utf8ByteArray = (byte[][])Array.CreateInstance(typeof(byte[]), textLength);
+            for (var i = 0; i < textLength; i++)
+            {
+                utf8ByteArray[i] = Encoding.UTF8.GetBytes(s_Int32TextArray[i]);
+            }
+
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        int.TryParse(s_Int32TextArray[i % textLength], out int value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void ByteSpanToInt16_VariableLength()
+        {
+            int textLength = s_Int16TextArray.Length;
+            byte[][] utf8ByteArray = (byte[][])Array.CreateInstance(typeof(byte[]), textLength);
+            for (var i = 0; i < textLength; i++)
+            {
+                utf8ByteArray[i] = Encoding.UTF8.GetBytes(s_Int16TextArray[i]);
+            }
+
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray[i % textLength];
+                        Utf8Parser.TryParse(utf8ByteSpan, out short value, out int bytesConsumed);
+                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("0")]
+        [InlineData("10737")] // standard parse
+        [InlineData("32767")] // max value
+        [InlineData("-32768")] // min value
+        [InlineData("000000000000000000001235abcdfg")]
+        private static void StringToInt16_Baseline(string text)
+        {
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        short.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out short value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        private static void StringToInt16_VariableLength_Baseline()
+        {
+            int textLength = s_Int16TextArray.Length;
+            byte[][] utf8ByteArray = (byte[][])Array.CreateInstance(typeof(byte[]), textLength);
+            for (var i = 0; i < textLength; i++)
+            {
+                utf8ByteArray[i] = Encoding.UTF8.GetBytes(s_Int16TextArray[i]);
+            }
+
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        short.TryParse(s_Int16TextArray[i % textLength], out short value);
+                        TestHelpers.DoNotIgnore(value, 0);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("True")]
+        [InlineData("False")]
+        private static void StringToBool_Baseline(string text)
+        {
+            foreach (BenchmarkIteration iteration in Benchmark.Iterations)
+            {
+                using (iteration.StartMeasurement())
+                {
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        bool.TryParse(text, out bool value);
+                    }
+                }
+            }
+        }
+
+        [Benchmark(InnerIterationCount = InnerCount)]
         [InlineData("True")]
         [InlineData("False")]
-        private static void PrimitiveParserByteSpanToBool(string text)
+        private static void BytesSpanToBool(string text)
         {
             byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
             ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
@@ -33,10 +620,14 @@ namespace System.Buffers.Text.Tests
         }
 
         [Benchmark(InnerIterationCount = InnerCount)]
-        [InlineData("42")] // standard parse
-        [InlineData("-128")] // min value
+        [InlineData("0")]
+        [InlineData("107")] // standard parse
         [InlineData("127")] // max value
-        private static void ParserSByte(string text)
+        [InlineData("-128")] // min value
+        [InlineData("-21abcdefghijklmnop")]
+        [InlineData("21abcdefghijklmnop")]
+        [InlineData("00000000000000000000123")]
+        private static void ByteSpanToSByte(string text)
         {
             byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
             ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
@@ -58,7 +649,7 @@ namespace System.Buffers.Text.Tests
         [InlineData("42")] // standard parse
         [InlineData("0")] // min value
         [InlineData("255")] // max value
-        private static void ParserByte(string text)
+        private static void ByteSpanToByte(string text)
         {
             byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
             ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
@@ -76,11 +667,12 @@ namespace System.Buffers.Text.Tests
             }
         }
 
+
         [Benchmark(InnerIterationCount = InnerCount)]
-        [InlineData("4212")] // standard parse
-        [InlineData("-32768")] // min value
-        [InlineData("32767")] // max value
-        private static void ParserInt16(string text)
+        [InlineData("42")] // standard parse
+        [InlineData("0")] // min value
+        [InlineData("255")] // max value
+        private static void StringToByte_Baseline(string text)
         {
             byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
             ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
@@ -91,18 +683,20 @@ namespace System.Buffers.Text.Tests
                 {
                     for (int i = 0; i < Benchmark.InnerIterationCount; i++)
                     {
-                        Utf8Parser.TryParse(utf8ByteSpan, out short value, out int bytesConsumed);
-                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                        byte.TryParse(text, out byte value);
+                        TestHelpers.DoNotIgnore(value, 0);
                     }
                 }
             }
         }
 
         [Benchmark(InnerIterationCount = InnerCount)]
+        [InlineData("0")]
         [InlineData("4212")] // standard parse
-        [InlineData("0")] // min value
-        [InlineData("65535")] // max value
-        private static void ParserUInt16(string text)
+        [InlineData("-32768")] // min value
+        [InlineData("32767")] // max value
+        [InlineData("000000000000000000001235abcdfg")]
+        private static void ByteSpanToInt16(string text)
         {
             byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
             ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
@@ -113,7 +707,7 @@ namespace System.Buffers.Text.Tests
                 {
                     for (int i = 0; i < Benchmark.InnerIterationCount; i++)
                     {
-                        Utf8Parser.TryParse(utf8ByteSpan, out ushort value, out int bytesConsumed);
+                        Utf8Parser.TryParse(utf8ByteSpan, out short value, out int bytesConsumed);
                         TestHelpers.DoNotIgnore(value, bytesConsumed);
                     }
                 }
@@ -121,10 +715,10 @@ namespace System.Buffers.Text.Tests
         }
 
         [Benchmark(InnerIterationCount = InnerCount)]
-        [InlineData("12837467")] // standard parse
-        [InlineData("-2147483648")] // min value
-        [InlineData("2147483647")] // max value
-        private static void ParserInt32(string text)
+        [InlineData("4212")] // standard parse
+        [InlineData("0")] // min value
+        [InlineData("65535")] // max value
+        private static void ByteSpanToUInt16(string text)
         {
             byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
             ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
@@ -135,7 +729,7 @@ namespace System.Buffers.Text.Tests
                 {
                     for (int i = 0; i < Benchmark.InnerIterationCount; i++)
                     {
-                        Utf8Parser.TryParse(utf8ByteSpan, out int value, out int bytesConsumed);
+                        Utf8Parser.TryParse(utf8ByteSpan, out ushort value, out int bytesConsumed);
                         TestHelpers.DoNotIgnore(value, bytesConsumed);
                     }
                 }
@@ -144,9 +738,11 @@ namespace System.Buffers.Text.Tests
 
         [Benchmark(InnerIterationCount = InnerCount)]
         [InlineData("12837467")] // standard parse
-        [InlineData("0")] // min value
-        [InlineData("4294967295")] // max value
-        private static void ParserUInt32(string text)
+        [InlineData("-9223372036854775808")] // min value
+        [InlineData("9223372036854775807")] // max value
+        [InlineData("000000000000000000001235abcdfg")]
+        [InlineData("21474836abcdefghijklmnop")]
+        private static void ByteSpanToInt64(string text)
         {
             byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
             ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
@@ -157,40 +753,38 @@ namespace System.Buffers.Text.Tests
                 {
                     for (int i = 0; i < Benchmark.InnerIterationCount; i++)
                     {
-                        Utf8Parser.TryParse(utf8ByteSpan, out uint value, out int bytesConsumed);
+                        Utf8Parser.TryParse(utf8ByteSpan, out long value, out int bytesConsumed);
                         TestHelpers.DoNotIgnore(value, bytesConsumed);
                     }
                 }
             }
         }
 
+
         [Benchmark(InnerIterationCount = InnerCount)]
         [InlineData("12837467")] // standard parse
         [InlineData("-9223372036854775808")] // min value
         [InlineData("9223372036854775807")] // max value
-        private static void ParserInt64(string text)
+        [InlineData("000000000000000000001235abcdfg")]
+        [InlineData("21474836abcdefghijklmnop")]
+        private static void StringToInt64_Baseline(string text)
         {
-            byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
-            ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
-
             foreach (BenchmarkIteration iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
                     for (int i = 0; i < Benchmark.InnerIterationCount; i++)
                     {
-                        Utf8Parser.TryParse(utf8ByteSpan, out long value, out int bytesConsumed);
-                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                        long.TryParse(text, out long value);
+                        TestHelpers.DoNotIgnore(value, 0);
                     }
                 }
             }
         }
 
         [Benchmark(InnerIterationCount = InnerCount)]
-        [InlineData("12837467")] // standard parse
-        [InlineData("0")] // min value
-        [InlineData("18446744073709551615")] // max value
-        private static void ParserUInt64(string text)
+        [InlineData("Fri, 30 Jun 2000 03:15:45 GMT")] // standard parse
+        private static void ByteSpanToTimeOffsetR(string text)
         {
             byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
             ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
@@ -201,7 +795,7 @@ namespace System.Buffers.Text.Tests
                 {
                     for (int i = 0; i < Benchmark.InnerIterationCount; i++)
                     {
-                        Utf8Parser.TryParse(utf8ByteSpan, out ulong value, out int bytesConsumed);
+                        Utf8Parser.TryParse(utf8ByteSpan, out DateTimeOffset value, out int bytesConsumed, 'R');
                         TestHelpers.DoNotIgnore(value, bytesConsumed);
                     }
                 }
@@ -210,19 +804,16 @@ namespace System.Buffers.Text.Tests
 
         [Benchmark(InnerIterationCount = InnerCount)]
         [InlineData("Fri, 30 Jun 2000 03:15:45 GMT")] // standard parse
-        private static void ParserDateTimeOffsetR(string text)
+        private static void StringToTimeOffsetR_Baseline(string text)
         {
-            byte[] utf8ByteArray = Encoding.UTF8.GetBytes(text);
-            ReadOnlySpan<byte> utf8ByteSpan = utf8ByteArray;
-
             foreach (BenchmarkIteration iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
                     for (int i = 0; i < Benchmark.InnerIterationCount; i++)
                     {
-                        Utf8Parser.TryParse(utf8ByteSpan, out DateTimeOffset value, out int bytesConsumed, 'R');
-                        TestHelpers.DoNotIgnore(value, bytesConsumed);
+                        DateTimeOffset.TryParseExact(text, "r", null, DateTimeStyles.None, out DateTimeOffset value);
+                        TestHelpers.DoNotIgnore(value, 0);
                     }
                 }
             }