optimization, updates, polishing

Author: Petr Sramek

benchmarks/PolylineAlgorithm.Benchmarks/Internal/ValueProvider.cs

@@ -0,0 +1,54 @@
+namespace PolylineAlgorithm.Benchmarks.Internal
+{
+    using System.Collections.Concurrent;
+
+    public static class ValueProvider
+    {
+        private static ConcurrentDictionary<int, CoordinatePair> _cache = new();
+        private static PolylineEncoder _encoder = new();
+
+        public static IEnumerable<Coordinate> GetCoordinates(int count) {
+            var entry = GetCaheEntry(count);
+
+            return entry.Coordinates;
+        }
+
+        public static Polyline GetPolyline(int count) {
+            var entry = GetCaheEntry(count);
+
+            return entry.Polyline;
+        }
+
+        private static CoordinatePair GetCaheEntry(int count) {
+            if (_cache.TryGetValue(count, out var entry)) {
+                return entry;
+            }
+
+            var enumeration = Enumerable
+                .Range(0, count)
+                .Select(i => new Coordinate(RandomLatitude(), RandomLongitude()));
+
+            entry = _cache.GetOrAdd(count, _ => new CoordinatePair(enumeration, _encoder.Encode(enumeration)));
+
+            return entry;
+        }
+
+        private static double RandomLongitude() {
+            return Random.Shared.Next(-180, 180) + Random.Shared.NextDouble();
+        }
+
+        private static double RandomLatitude() {
+            return Random.Shared.Next(-90, 90) + Random.Shared.NextDouble();
+        }
+
+        private readonly struct CoordinatePair {
+            public CoordinatePair(IEnumerable<Coordinate> coordinates, Polyline polyline) {
+                Coordinates = coordinates;
+                Polyline = polyline;
+            }
+
+            public IEnumerable<Coordinate> Coordinates { get; }
+            public Polyline Polyline { get; }
+        }
+    }
+}

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -8,6 +8,7 @@ namespace PolylineAlgorithm.Benchmarks;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Engines;
 using PolylineAlgorithm;
+using PolylineAlgorithm.Benchmarks.Internal;
 
 /// <summary>
 /// Benchmarks for the <see cref="PolylineDecoder"/> class.
@@ -16,6 +17,9 @@ namespace PolylineAlgorithm.Benchmarks;
 public class PolylineDecoderBenchmark {
     private readonly Consumer _consumer = new();
 
+    [Params(10, 100, 1_000, 10_000, 100_000)]
+    public int N;
+
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
     /// <summary>
     /// Gets the string value representing the encoded polyline.
@@ -43,7 +47,7 @@ public class PolylineDecoderBenchmark {
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
-        StringValue = @"sq_|Fptm{UrbxoHinoiEuhmbHctjfc@`rocCt|nfJgiauLvc_uIh`pg_@h_fkVgctZoyqfW{rxgQhhymFpuvvDwqcfTlqbcBiegdTwf{uNngc|z@{vhlDnsi_B~nz`O}d_hNp{n`E}kcoKm`bCiul~\jhg|Hv{qoWshzh\{lf_G`pzMqm|bLzswoQbhcm`@b`}cIgignPgxntR|}vo^f~|}L}|_jBa|ujWuxkjQfj|w[wsz`Pmdb{XohnwA`srxWjitms@c_~`Tava_l@jxxcF`d|zHcpnaMnd{kYzccwPxzpiHfsxlL}jjjQqvdbIikyvj@cjdqTh`zoDzqleHnfmik@tbnoB_t}gFkzx_Ct_eiP`wxrBcd_|w@zlhfPtlxgBkwyyZn|~tFlpj|HxqiwUnddkFoo|nTee}dSfkcg`@py`uQiguom@zkkpEfcgkAntuuDzl~il@ir_gCrd~nI_ryeC_qmmMl_kgCz`qgFzkejBmlchYyp`hZ`_cuYzuc}Onqz}Ew~Gcsmj@lp{Hqj_gz@ne{pJnny~]g{tuNxbno[lfq_Lqhwjt@qn|cCuxnMyivuIh{|tR`ylsQlqbfO}rf`LxghfBg~{nAv`gdNbjh_Fglt|NfxwyBowwhW{bdtNdbkqe@rxtwSy{_fX{btm@va`_LkhwuUyqgzK`xdnKgbwsFigt_Mofdn\h|x[ccoPtbpvNz}skb@pl~xEqascV_wsx[`f_z]zewFs`zjAhturWxayhJqmfaAjmhhHxwuwF_aru@ojemVq|beu@kkucBdmryTevflDcbmdAnp|dHfpbd^io}z@e~}dFzcybQ}`hxOyt|bNl}blLnuspKk|t|k@itjfHt}}aVyzmcF_rgmLct}x@bazdq@loajBxygb@f}krVgnuqOcrx_Daqvp_@ew}yUn}kpU|uwnItashEpe_aHusi{Fsu}_Ewfhv[dzhzKxh_qXucxfXmynkGxuqbW|ppgi@vrsq@clryZk`bt^spkyP";
+        StringValue = ValueProvider.GetPolyline(N).ToString();
         CharArray = StringValue.ToCharArray();
         Memory = StringValue.AsMemory();
     }

benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs

@@ -7,14 +7,16 @@ namespace PolylineAlgorithm.Benchmarks;
 
 using BenchmarkDotNet.Attributes;
 using PolylineAlgorithm;
+using PolylineAlgorithm.Benchmarks.Internal;
 using System.Collections.Generic;
 
 /// <summary>
 /// Benchmarks for the <see cref="PolylineEncoder"/> class.
 /// </summary>
 [RankColumn]
 public class PolylineEncoderBenchmark {
-    private static readonly Random R = new();
+    [Params(10, 100, 1_000, 10_000, 100_000)]
+    public int N;
 
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
     /// <summary>
@@ -38,8 +40,8 @@ public class PolylineEncoderBenchmark {
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
-        Enumeration = Enumerable.Range(0, 100).Select(i => new Coordinate(R.Next(-90, 90) + R.NextDouble(), R.Next(-180, 180) + R.NextDouble()));
-        List = new List<Coordinate>(Enumeration);
+        Enumeration = ValueProvider.GetCoordinates(N);
+        List = [..Enumeration];
     }
 
     /// <summary>

src/PolylineAlgorithm/Internal/Defaults.cs

@@ -43,6 +43,20 @@ public static class Algorithm {
         public const byte UnitSeparator = 31;
     }
 
+    /// <summary>
+    /// Contains default values related to polyline.
+    /// </summary>
+    public static class Polyline {
+        /// <summary>
+        /// The minimum length of an encoded coordinate.
+        /// </summary>
+        public const int MinEncodedCoordinateLength = 2;
+        /// <summary>
+        /// The maximum length of an encoded coordinate.
+        /// </summary>
+        public const int MaxEncodedCoordinateLength = 12;
+    }
+
     /// <summary>
     /// Contains default values related to coordinates.
     /// </summary>

src/PolylineAlgorithm/Internal/PolylineWriter.cs

@@ -15,13 +15,13 @@ namespace PolylineAlgorithm.Internal;
 [StructLayout(LayoutKind.Auto)]
 internal ref struct PolylineWriter {
     private WriterState _state = new();
-    private Memory<char> _buffer;
+    private Span<char> _buffer;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PolylineWriter"/> struct with the specified buffer.
     /// </summary>
     /// <param name="buffer">The buffer to write to.</param>
-    public PolylineWriter(Memory<char> buffer) {
+    public PolylineWriter(Span<char> buffer) {
         _buffer = buffer;
     }
 
@@ -90,7 +90,7 @@ void WriteNext(ref readonly int value) {
     void WriteChar(char value) {
         InvalidWriterStateException.ThrowIfCannotWrite(CanWrite, Position, _buffer.Length);
 
-        _buffer.Span[Position] = value;
+        _buffer[Position] = value;
         _state.Position += 1;
     }
 
@@ -115,8 +115,8 @@ void UpdateCurrent(ref readonly int latitude, ref readonly int longitude, out in
     /// </summary>
     /// <returns>The <see cref="Polyline"/> instance.</returns>
     public readonly Polyline ToPolyline() {
-        ReadOnlyMemory<char> buffer = _buffer[.._state.Position];
-        var polyline = Polyline.FromMemory(buffer);
+        Span<char> buffer = _buffer[.._state.Position];
+        var polyline = Polyline.FromString(buffer.ToString());
         return polyline;
     }
 

src/PolylineAlgorithm/PolylineDecoder.cs

@@ -7,13 +7,18 @@ namespace PolylineAlgorithm;
 
 using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.Properties;
+using System.Buffers;
+using System.Runtime.InteropServices;
 
 
 /// <summary>
 /// Performs polyline algorithm decoding
 /// </summary>
 public class PolylineDecoder : IPolylineDecoder {
 
+    private static readonly int _size = Marshal.SizeOf<Coordinate>();
+    private IMemoryOwner<Coordinate>? _pool;
+
     /// <inheritdoc />
     /// <exception cref="ArgumentException">Thrown when <paramref name="polyline"/> argument is null -or- empty.</exception>
     /// <exception cref="InvalidOperationException">Thrown when <paramref name="polyline"/> is not in correct format.</exception>
@@ -24,20 +29,36 @@ public IEnumerable<Coordinate> Decode(ref readonly Polyline polyline) {
         }
 
         // Initialize local variables
-        int capacity = polyline.Length / 9;
-        var result = new List<Coordinate>(capacity);
+        int capacity = polyline.Length / Defaults.Polyline.MinEncodedCoordinateLength;
+        Span<Coordinate> buffer = _size * capacity <= 512_000 ? stackalloc Coordinate[capacity] : RentMemory(capacity);
 
         PolylineReader reader = new(in polyline);
+        int index = 0;
 
         // Looping through encoded polyline char array
         while (reader.CanRead) {
             var coordinate = reader.Read();
-
+            
             InvalidCoordinateException.ThrowIfNotValid(coordinate);
 
-            result.Add(coordinate);
+            buffer[index] = coordinate;
+            index++;
         }
 
+        var result = buffer[..index].ToArray();
+
+        ReturnMemory();
+
         return result;
     }
+
+    private Span<Coordinate> RentMemory(int capacity) {
+        _pool = MemoryPool<Coordinate>.Shared.Rent(capacity);
+
+        return _pool.Memory.Span;
+    }
+
+    private void ReturnMemory() {
+        _pool?.Dispose();
+    }
 }

src/PolylineAlgorithm/PolylineEncoder.cs

@@ -8,14 +8,18 @@ namespace PolylineAlgorithm;
 using PolylineAlgorithm.Internal;
 using PolylineAlgorithm.Properties;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
 /// <summary>
 /// Provides methods to encode a set of coordinates into a polyline string.
-/// </summary>
+/// </summary>\
 public class PolylineEncoder : IPolylineEncoder {
+    private static readonly int _size = sizeof(char);
+    private IMemoryOwner<char>? _pool;
+
     /// <summary>
     /// Encodes a set of coordinates into a polyline string.
     /// </summary>
@@ -28,33 +32,48 @@ public Polyline Encode(IEnumerable<Coordinate> coordinates) {
             throw new ArgumentNullException(nameof(coordinates));
         }
 
-        int count = GetCount(in coordinates);
+        int count = GetCount(coordinates);
 
         if (count == 0) {
             throw new ArgumentException(ExceptionMessageResource.ArgumentCannotBeEmptyEnumerationMessage, nameof(coordinates));
         }
 
-        int capacity = count * 12;
-        Memory<char> buffer = new char[capacity];
+        int capacity = count * Defaults.Polyline.MaxEncodedCoordinateLength;
+        Span<char> buffer = _size * capacity <= 512_000 ? stackalloc char[capacity] : RentMemory(capacity);
         PolylineWriter writer = new(buffer);
 
         foreach (var coordinate in coordinates) {
             InvalidCoordinateException.ThrowIfNotValid(coordinate);
             writer.Write(coordinate);
         }
 
-        return writer.ToPolyline();
-
-        /// <summary>
-        /// Gets the count of coordinates in the enumerable.
-        /// </summary>
-        /// <param name="coordinates">The enumerable of coordinates.</param>
-        /// <returns>The count of coordinates.</returns>
-        [ExcludeFromCodeCoverage]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static int GetCount(ref readonly IEnumerable<Coordinate> coordinates) => coordinates switch {
-            ICollection<Coordinate> collection => collection.Count,
-            _ => coordinates.Count(),
-        };
+        var result = writer.ToPolyline();
+
+
+
+        return result;
+    }
+
+    /// <summary>
+    /// Gets the count of coordinates in the enumerable.
+    /// </summary>
+    /// <param name="coordinates">The enumerable of coordinates.</param>
+    /// <returns>The count of coordinates.</returns>
+    [ExcludeFromCodeCoverage]
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    static int GetCount(IEnumerable<Coordinate> coordinates) => coordinates switch {
+        ICollection<Coordinate> collection => collection.Count,
+        _ => coordinates.Count(),
+    };
+
+
+    private Span<char> RentMemory(int capacity) {
+        _pool = MemoryPool<char>.Shared.Rent(capacity);
+
+        return _pool.Memory.Span;
+    }
+
+    private void ReturnMemory() {
+        _pool?.Dispose();
     }
 }

tests/PolylineAlgorithm.Tests/Internal/PolylineReaderTest.cs

@@ -78,7 +78,7 @@ public void Read_Valid_Parameter_Ok() {
         int position = value.Length;
         Polyline polyline = Polyline.FromString(value);
         PolylineReader reader = new(in polyline);
-        List<Coordinate> expected = new(Values.Coordinates.Valid);
+        List<Coordinate> expected = [..Values.Coordinates.Valid];
         List<Coordinate> result = new(expected.Count);
 
         // Act

tests/PolylineAlgorithm.Tests/Internal/PolylineWriterTest.cs

@@ -61,7 +61,7 @@ public void Constructor_Parameterless_Ok() {
     [DynamicData(nameof(Valid_Constructor_Parameter))]
     public void Constructor_Valid_Parameter_Ok(int length) {
         // Arrange
-        Memory<char> buffer = new char[length];
+        Span<char> buffer = new char[length];
         bool canWrite = !buffer.IsEmpty;
         int position = 0;
 
@@ -81,7 +81,7 @@ public void Write_Valid_Parameter_Ok() {
         // Arrange
         IEnumerable<Coordinate> coordinates = Values.Coordinates.Valid;
         Polyline expected = Polyline.FromString(Values.Polyline.Valid);
-        Memory<char> buffer = new char[coordinates.Count() * 12];
+        Span<char> buffer = new char[coordinates.Count() * Defaults.Polyline.MaxEncodedCoordinateLength];
         PolylineWriter writer = new(buffer);
         bool canWrite = buffer.Length > expected.Length;
         int position = expected.Length;
@@ -106,11 +106,11 @@ public void Write_Valid_Parameter_Ok() {
     public void Write_Invalid_Coordinate_Parameter_Ok((double Latitude, double Longitude) value) {
         // Arrange
         Coordinate coordinate = new(value.Latitude, value.Longitude);
-        int bufferSize = 12;
+        int bufferSize = Defaults.Polyline.MaxEncodedCoordinateLength;
 
         // Act
         static void Write(Coordinate coordinate, int bufferSize) {
-            Memory<char> buffer = new char[bufferSize];
+            Span<char> buffer = new char[bufferSize];
             PolylineWriter writer = new(buffer);
             writer.Write(coordinate);
         }
@@ -131,7 +131,7 @@ public void Write_Buffer_Overflow_InvalidWriterStateException_Thrown(int bufferS
 
         // Act
         static void Write(Coordinate coordinate, int bufferSize) {
-            Memory<char> buffer = new char[bufferSize];
+            Span<char> buffer = new char[bufferSize];
             PolylineWriter writer = new(buffer);
 
             writer.Write(coordinate);