just

Author: Petr Sramek

benchmarks/PolylineAlgorithm.Benchmarks/PolylineAlgorithm.Benchmarks.csproj

@@ -14,6 +14,10 @@
 		<IsPackable>false</IsPackable>
 	</PropertyGroup>
 
+	<PropertyGroup>
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+	</PropertyGroup>
+
 	<ItemGroup>
 		<PackageReference Include="BenchmarkDotNet" Version="0.13.12" />
 	</ItemGroup>

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -9,6 +9,7 @@ namespace PolylineAlgorithm.Benchmarks;
 using BenchmarkDotNet.Engines;
 using PolylineAlgorithm;
 using PolylineAlgorithm.Benchmarks.Internal;
+using System.Text;
 
 /// <summary>
 /// Benchmarks for the <see cref="PolylineDecoder"/> class.
@@ -32,10 +33,12 @@ public class PolylineDecoderBenchmark {
     /// </summary>
     public char[] CharArray { get; private set; }
 
+    public byte[] ByteArray { get; private set; }
+
     /// <summary>
     /// Gets the read-only memory representing the encoded polyline.
     /// </summary>
-    public ReadOnlyMemory<char> Memory { get; private set; }
+    public ReadOnlyMemory<byte> Memory { get; private set; }
 #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
 
     /// <summary>
@@ -55,7 +58,8 @@ public class PolylineDecoderBenchmark {
     public void SetupData() {
         StringValue = ValueProvider.GetPolyline(N).ToString();
         CharArray = StringValue.ToCharArray();
-        Memory = StringValue.AsMemory();
+        ByteArray = Encoding.UTF8.GetBytes(StringValue);
+        Memory = Encoding.UTF8.GetBytes(StringValue).AsMemory();
     }
 
     /// <summary>

benchmarks/PolylineAlgorithm.Benchmarks/Program.cs

@@ -17,10 +17,10 @@ internal class Program {
     /// </summary>
     /// <param name="args">The command-line arguments.</param>
     static void Main(string[] args) {
-        Directory.Delete("C:\\temp\\benchmark", true);
+        //Directory.Delete("C:\\temp\\benchmark", true);
 
         BenchmarkSwitcher
             .FromAssembly(typeof(Program).Assembly)
-            .Run(args, new DebugInProcessConfig());
+            .Run(args/*, new DebugInProcessConfig()*/);
     }
 }

benchmarks/PolylineAlgorithm.Benchmarks/ReadOnlySequenceSequenceEqualBenchmark.cs

@@ -0,0 +1,189 @@
+//
+// Copyright © Pete Sramek. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+//
+
+namespace PolylineAlgorithm.Benchmarks;
+
+using BenchmarkDotNet.Attributes;
+using PolylineAlgorithm;
+using System;
+using System.Buffers;
+using System.Diagnostics;
+
+/// <summary>
+/// Benchmarks for the <see cref="PolylineDecoder"/> class.
+/// </summary>
+[RankColumn]
+[ShortRunJob]
+public class ReadOnlySequenceSequenceEqualBenchmark {
+    [Params(1, 10, 100, 500, 1_000, 10_000, 100_000, 1_000_000, 10_000_000)]
+    public int ArrayLength;
+
+    [ParamsAllValues]
+    public SequenceStructure? Structure;
+
+    [ParamsAllValues]
+    public bool AllowEmptySequence;
+
+    /// <summary>
+    /// Gets the string value representing the encoded polyline.
+    /// </summary>
+    public ReadOnlySequence<char> S1 { get; private set; }
+
+    /// <summary>
+    /// Gets the string value representing the encoded polyline.
+    /// </summary>
+    public ReadOnlySequence<char> S2 { get; private set; }
+
+    //[ParamsAllValues]
+    //public bool AllowEmpty { get; set; }
+
+    /// <summary>
+    /// Sets up the data for the benchmarks.
+    /// </summary>
+    [GlobalSetup]
+    public void SetupData() {
+        var a1 = CreateArray(ArrayLength);
+
+        S1 = CreateSequence(a1, AllowEmptySequence);
+
+        if(Structure == SequenceStructure.EqualSegments) {
+            S2 = S1;
+        } else if (Structure == SequenceStructure.EqualContents) {
+            S2 = CreateSequence(a1, AllowEmptySequence);
+        } else {
+            S2 = CreateSequence(CreateArray(ArrayLength), AllowEmptySequence);
+        }
+
+        static ReadOnlySequence<T> CreateSequence<T>(Memory<T> array, bool allowEmpty = false) {
+            ReadOnlySegment<T> initial = null!;
+            ReadOnlySegment<T> last = null!;
+
+            int consumed = 0;
+            while (consumed < array.Length) {
+                var length = Random.Shared.Next(allowEmpty ? 0 : 1, array.Length - consumed + 1);
+                var slice = length == 0 ? Memory<T>.Empty : array.Slice(consumed, length);
+                var segment = new ReadOnlySegment<T>(slice);
+
+                if (initial is null) {
+                    initial = segment;
+                    last = segment;
+                } else {
+                    last.Append(segment);
+                    last = segment;
+                }
+
+                consumed += length;
+            }
+
+            var sequence = new ReadOnlySequence<T>(initial, 0, last, last.Memory.Length);
+
+            return sequence;
+        }
+
+        static Memory<char> CreateArray(int length) {
+            Memory<char> array = new char[length];
+
+            for (int i = 0; i < length; i++) {
+
+                array.Span[i] = Convert.ToChar(Random.Shared.Next(Char.MinValue, Char.MaxValue + 1));
+            }
+
+            return array;
+        }
+    }
+
+    /// <summary>
+    /// Benchmarks the decoding of a polyline from a string.
+    /// </summary>
+    [Benchmark]
+    public bool SequenceEqual_SequenceReader_IsNext_V1() {
+        var left = new SequenceReader<char>(S1);
+        var right = new SequenceReader<char>(S2);
+
+        while (true) {
+            if(!right.IsNext(left.CurrentSpan)) {
+                break;
+            }
+
+            left.Advance(left.CurrentSpan.Length);
+            right.Advance(left.CurrentSpan.Length);
+
+            if (left.Remaining == 0) {
+                return true;
+            }
+        }
+
+        Debug.Assert(false);
+        return false;
+    }
+
+    /// <summary>
+    /// Benchmarks the decoding of a polyline from a string.
+    /// </summary>
+    [Benchmark]
+    public bool SequenceEqual_NerdBank_SpanEnumeration() {
+        ReadOnlySequence<char>.Enumerator aEnumerator = S1.GetEnumerator();
+        ReadOnlySequence<char>.Enumerator bEnumerator = S2.GetEnumerator();
+
+        ReadOnlySpan<char> aCurrent = default;
+        ReadOnlySpan<char> bCurrent = default;
+
+        while (true) {
+            bool aNext = TryGetNonEmptySpan(ref aEnumerator, ref aCurrent);
+            bool bNext = TryGetNonEmptySpan(ref bEnumerator, ref bCurrent);
+            if (!aNext && !bNext) {
+                // We've reached the end of both sequences at the same time.
+                return true;
+            } else if (aNext != bNext) {
+                // One ran out of bytes before the other.
+                // We don't anticipate this, because we already checked the lengths.
+                throw new InvalidOperationException();
+            }
+
+            int commonLength = Math.Min(aCurrent.Length, bCurrent.Length);
+            if (!aCurrent[..commonLength].SequenceEqual(bCurrent[..commonLength])) {
+                Debug.Assert(false);
+
+                return false;
+            }
+
+            aCurrent = aCurrent.Slice(commonLength);
+            bCurrent = bCurrent.Slice(commonLength);
+        }
+
+        static bool TryGetNonEmptySpan(ref ReadOnlySequence<char>.Enumerator enumerator, ref ReadOnlySpan<char> span) {
+            while (span.Length == 0) {
+                if (!enumerator.MoveNext()) {
+                    return false;
+                }
+
+                span = enumerator.Current.Span;
+            }
+
+            return true;
+        }
+    }
+
+    private class ReadOnlySegment<T> : ReadOnlySequenceSegment<T> {
+        public ReadOnlySegment(ReadOnlyMemory<T> memory, long runningIndex = 0) {
+            Memory = memory;
+            RunningIndex = runningIndex;
+        }
+
+        public void Append(ReadOnlyMemory<T> memory) {
+            Append(new ReadOnlySegment<T>(memory));
+        }
+
+        public void Append(ReadOnlySegment<T> next) {
+            next.RunningIndex = RunningIndex + Memory.Length;
+            Next = next;
+        }
+    }
+
+    public enum SequenceStructure {
+        EqualSegments = 0,
+        EqualContents = 1,
+    }
+}

src/PolylineAlgorithm.IO.Pipelines/PolylineDecoder.cs

@@ -5,9 +5,11 @@
 
 namespace PolylineAlgorithm.IO.Pipelines;
 
+using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.IO.Pipelines.Internal;
 using System.Buffers;
 using System.IO.Pipelines;
+using System.Runtime.CompilerServices;
 using System.Text;
 
 
@@ -34,45 +36,34 @@ public async Task DecodeAsync(PipeReader reader, PipeWriter writer, Cancellation
             throw new ArgumentNullException(nameof(writer));
         }
 
-        ReadResult result;
-        int latitude = 0;
-        int longitude = 0;
-        SequencePosition position;
-        Memory<byte> temp = new byte[6];
-        Memory<char> buffer = new char[6];
+        int latitude;
+        int longitude;
+
+        Memory<byte> buffer = new byte[6];
+
+        PolylineCoordinate current = Coordinate.Default;
 
         while (true) {
-            result = await reader
-                .ReadAtLeastAsync(6, cancellation)
+            latitude = await ReadAsync(reader, buffer, cancellation)
                 .ConfigureAwait(false);
 
-            position = Process(result, ref latitude, ref temp, ref buffer);
-            reader.AdvanceTo(position);
-
-            result = await reader
-                .ReadAtLeastAsync(6, cancellation)
+            longitude = await ReadAsync(reader, buffer, cancellation)
                 .ConfigureAwait(false);
 
-            position = Process(result, ref longitude, ref temp, ref buffer);
-            reader.AdvanceTo(position);
+            current += CoordinateVariance.Create(latitude, longitude);
+
+            if (!await Formatter.TryWriteAsync(writer, current, cancellation).ConfigureAwait(false)) {
+                throw new InvalidOperationException();
+            }
 
-            if (result.IsCompleted) {
+            if (!reader.TryRead(out var result) || (result.IsCompleted || result.IsCanceled)) {
                 break;
             }
         }
 
         await CompleteAsync(reader, writer)
             .ConfigureAwait(false);
 
-        static SequencePosition Process(ReadResult result, ref int latitude, ref Memory<byte> temp, ref Memory<char> buffer) {
-            result.Buffer.Slice(0, 6).CopyTo(temp.Span);
-            Encoding.UTF8.GetChars(temp.Span, buffer.Span);
-
-            long consumed = Decode(buffer.Span, ref latitude);
-
-            return result.Buffer.GetPosition(consumed);
-        }
-
         static async Task CompleteAsync(PipeReader reader, PipeWriter writer) {
             await reader
                 .CompleteAsync()
@@ -81,30 +72,48 @@ await writer
                 .CompleteAsync()
                 .ConfigureAwait(false);
         }
-    }
 
-    internal static int Decode(ref readonly Span<char> buffer, ref int value) {
-        int position = 0;
-        int chunk = 0;
-        int sum = 0;
-        int shifter = 0;
+        static async Task<int> ReadAsync(PipeReader reader, Memory<byte> buffer, CancellationToken cancellationToken) {
+            var result = await reader
+                .ReadAtLeastAsync(buffer.Length, cancellationToken)
+                .ConfigureAwait(false);
 
-        while (buffer.Length < position) {
-            chunk = value - Defaults.Algorithm.QuestionMark;
-            sum |= (chunk & Defaults.Algorithm.UnitSeparator) << shifter;
-            shifter += Defaults.Algorithm.ShiftLength;
+            result.Buffer
+                .CopyTo(buffer.Span);
 
-            if (chunk < Defaults.Algorithm.Space) {
-                break;
-            }
-        }
+            int consumed = VarianceEncoding.Default
+                .Decode(buffer.Span, out int value);
 
-        if (buffer.Length == position && chunk >= Defaults.Algorithm.Space) {
-            //InvalidPolylineException.Throw(reader.Length - reader.Remaining);
-        }
+            var position = result.Buffer.GetPosition(consumed);
 
-        value += (sum & 1) == 1 ? ~(sum >> 1) : sum >> 1;
+            reader.AdvanceTo(position);
 
-        return position;
+            return value;
+        }
     }
+
+    //internal static int Decode(ref int value, ref readonly Span<byte> buffer) {
+    //    int position = 0;
+    //    int chunk = 0;
+    //    int sum = 0;
+    //    int shifter = 0;
+
+    //    while (buffer.Length < position) {
+    //        chunk = value - Defaults.Algorithm.QuestionMark;
+    //        sum |= (chunk & Defaults.Algorithm.UnitSeparator) << shifter;
+    //        shifter += Defaults.Algorithm.ShiftLength;
+
+    //        if (chunk < Defaults.Algorithm.Space) {
+    //            break;
+    //        }
+    //    }
+
+    //    if (buffer.Length == position && chunk >= Defaults.Algorithm.Space) {
+    //        //InvalidPolylineException.Throw(reader.Length - reader.Remaining);
+    //    }
+
+    //    value += (sum & 1) == 1 ? ~(sum >> 1) : sum >> 1;
+
+    //    return position;
+    //}
 }