Benchmarks for ReadOnlySequence.Slice.

src/benchmarks/micro/MicroBenchmarks.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <!-- Used by Python script to narrow down the the specified target frameworks to test, and avoid downloading all supported SDKs -->
@@ -83,6 +83,7 @@
     <Compile Remove="coreclr\Math\Functions\Single\ILogB.cs" />
     <Compile Remove="coreclr\Math\Functions\Single\Log2.cs" />
     <Compile Remove="coreclr\Math\Functions\Single\ScaleB.cs" />
+    <Compile Remove="corefx\System.Memory\SequenceReader.cs" />
     <Compile Remove="corefx\System.Text.Json\**\*.cs" />
   </ItemGroup>
 

src/benchmarks/micro/corefx/System.Memory/ReadOnlySequence.cs

@@ -0,0 +1,100 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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.Buffers;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using MicroBenchmarks;
+
+namespace System.Memory
+{
+    internal class BufferSegment<T> : ReadOnlySequenceSegment<T>
+    {
+        public BufferSegment(System.ReadOnlyMemory<T> memory) => Memory = memory;
+
+        public BufferSegment<T> Append(System.ReadOnlyMemory<T> memory)
+        {
+            var segment = new BufferSegment<T>(memory)
+            {
+                RunningIndex = RunningIndex + Memory.Length
+            };
+            Next = segment;
+            return segment;
+        }
+    }
+
+    [BenchmarkCategory(Categories.CoreFX)]
+    public class ReadOnlySequence
+    {
+        public enum SequenceKind { Single, Multiple };
+
+        [Params(SequenceKind.Single, SequenceKind.Multiple)]
+        public SequenceKind Segment { get; set; }
+
+        private ReadOnlySequence<byte> _sequence;
+        private SequencePosition _start;
+        private SequencePosition _end;
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            System.Memory<byte> memory = new System.Memory<byte>(Enumerable.Repeat((byte)1, 10000).ToArray());
+
+            if (Segment == SequenceKind.Single)
+            {
+                _sequence = new ReadOnlySequence<byte>(memory);
+                _start = _sequence.GetPosition(10);
+                _end = _sequence.GetPosition(9990);
+            }
+            else
+            {
+                BufferSegment<byte> firstSegment = new BufferSegment<byte>(memory.Slice(0, memory.Length / 2));
+                BufferSegment<byte> secondSegment = firstSegment.Append(memory.Slice(memory.Length / 2, memory.Length / 2));
+                _sequence = new ReadOnlySequence<byte>(firstSegment, 0, secondSegment, firstSegment.Memory.Length);
+                _start = _sequence.GetPosition(10);
+                _end = _sequence.GetPosition(9990);
+            }
+        }
+
+        [Benchmark]
+        public ReadOnlySequence<byte> Slice_StartPosition() => _sequence.Slice(_start);
+
+        [Benchmark]
+        public ReadOnlySequence<byte> Slice_Start() => _sequence.Slice(0);
+
+        [Benchmark]
+        public ReadOnlySequence<byte> Slice_Start_And_Length() => _sequence.Slice(0, 10000);
+
+        [Benchmark]
+        public ReadOnlySequence<byte> Slice_Start_And_EndPosition() => _sequence.Slice(0, _end);
+
+        [Benchmark]
+        public ReadOnlySequence<byte> Slice_StartPosition_And_Length() => _sequence.Slice(_start, 3);
+
+        [Benchmark]
+        public ReadOnlySequence<byte> Slice_StartPosition_And_EndPosition() => _sequence.Slice(_start, _end);
+
+        [Benchmark]
+        public ReadOnlySequence<byte> Slice_Repeat()
+        {
+            ReadOnlySequence<byte> localSequence = _sequence.Slice(0, 10000);
+            localSequence = localSequence.Slice(0, 5000);
+            localSequence = localSequence.Slice(0, 2500);
+            localSequence = localSequence.Slice(0, 1250);
+            localSequence = localSequence.Slice(0, 625);
+            return localSequence;
+        }
+
+        [Benchmark]
+        public ReadOnlySequence<byte> Slice_Repeat_StartPosition_And_EndPosition()
+        {
+            ReadOnlySequence<byte> localSequence = _sequence.Slice(_start, _end);
+            localSequence = localSequence.Slice(_start, localSequence.End);
+            localSequence = localSequence.Slice(_start, localSequence.End);
+            localSequence = localSequence.Slice(_start, localSequence.End);
+            localSequence = localSequence.Slice(_start, localSequence.End);
+            return localSequence;
+        }
+    }
+}

src/benchmarks/micro/corefx/System.Memory/SequenceReader.cs

@@ -0,0 +1,45 @@
+using BenchmarkDotNet.Attributes;
+using MicroBenchmarks;
+using System.Buffers;
+using System.Linq;
+
+namespace System.Memory
+{
+    [BenchmarkCategory(Categories.CoreFX)]
+    public class SequenceReader
+    {
+        private const int Count = 10000;
+
+        private ReadOnlySequence<int> _multiSegmentSequence;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            System.Memory<int> memory = new System.Memory<int>(Enumerable.Range(1, Count).ToArray());
+
+            BufferSegment<int> firstSegment = new BufferSegment<int>(memory.Slice(0, memory.Length / 2));
+            BufferSegment<int> secondSegment = firstSegment.Append(memory.Slice(memory.Length / 2, memory.Length / 2));
+
+            _multiSegmentSequence = new ReadOnlySequence<int>(firstSegment, 0, secondSegment, firstSegment.Memory.Length);
+        }
+
+        [Benchmark(OperationsPerInvoke = 16)]
+        public ReadOnlySequence<int> TryReadTo()
+        {
+            var sequenceReader = new System.Buffers.SequenceReader<int>(_multiSegmentSequence);
+
+            ReadOnlySequence<int> outSequence;
+
+            sequenceReader.TryReadTo(out outSequence, Count / 16); sequenceReader.TryReadTo(out outSequence, Count / 15);
+            sequenceReader.TryReadTo(out outSequence, Count / 14); sequenceReader.TryReadTo(out outSequence, Count / 13);
+            sequenceReader.TryReadTo(out outSequence, Count / 12); sequenceReader.TryReadTo(out outSequence, Count / 11);
+            sequenceReader.TryReadTo(out outSequence, Count / 10); sequenceReader.TryReadTo(out outSequence, Count / 09);
+            sequenceReader.TryReadTo(out outSequence, Count / 08); sequenceReader.TryReadTo(out outSequence, Count / 07);
+            sequenceReader.TryReadTo(out outSequence, Count / 06); sequenceReader.TryReadTo(out outSequence, Count / 05);
+            sequenceReader.TryReadTo(out outSequence, Count / 04); sequenceReader.TryReadTo(out outSequence, Count / 03);
+            sequenceReader.TryReadTo(out outSequence, Count / 02); sequenceReader.TryReadTo(out outSequence, Count / 01);
+
+            return outSequence;
+        }
+    }
+}