performance

Author: petesramek

samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineDecoder.cs

@@ -41,7 +41,7 @@ protected override Point CreateCoordinate(double latitude, double longitude) {
     /// <exception cref="ArgumentException">
     /// Thrown when the provided polyline string is null, empty, or consists only of whitespace characters.
     /// </exception>
-    protected override ReadOnlyMemory<char> GetReadOnlyMemory(string polyline) {
+    protected override ReadOnlyMemory<char> GetReadOnlyMemory(ref string polyline) {
         return polyline.AsMemory();
     }
 }

samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineEncoder.cs

@@ -21,7 +21,7 @@ public sealed class NetTopologyPolylineEncoder : AbstractPolylineEncoder<Point,
     /// <returns>
     /// An encoded polyline string representation of the provided polyline.
     /// </returns>
-    protected override string CreatePolyline(ref ReadOnlyMemory<char> polyline) {
+    protected override string CreatePolyline(ReadOnlyMemory<char> polyline) {
         if (polyline.IsEmpty) {
             return string.Empty;
         }

src/PolylineAlgorithm/Abstraction/AbstractPolylineDecoder.cs

@@ -73,20 +73,20 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {
         _logger.
             LogOperationStartedDebug(OperationName);
 
-        ValidateNullPolyline(ref polyline, _logger);
+        ValidateNullPolyline(polyline, _logger);
 
-        ReadOnlyMemory<char> sequence = GetReadOnlyMemory(polyline);
+        ReadOnlyMemory<char> sequence = GetReadOnlyMemory(ref polyline);
 
-        ValidateEmptySequence(ref sequence, _logger);
+        ValidateEmptySequence(sequence, _logger);
 
         int position = 0;
         int latitude = 0;
         int longitude = 0;
 
         while (position < sequence.Length) {
             // Read the next value from the polyline encoding
-            if (!PolylineEncoding.TryReadValue(ref latitude, ref sequence, ref position)
-                || !PolylineEncoding.TryReadValue(ref longitude, ref sequence, ref position)
+            if (!PolylineEncoding.TryReadValue(ref latitude, sequence, ref position)
+                || !PolylineEncoding.TryReadValue(ref longitude, sequence, ref position)
             ) {
                 _logger.
                     LogOperationFailedDebug(OperationName);
@@ -103,7 +103,7 @@ public IEnumerable<TCoordinate> Decode(TPolyline polyline) {
             .LogOperationFinishedDebug(OperationName);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static void ValidateNullPolyline(ref TPolyline polyline, ILogger logger) {
+        static void ValidateNullPolyline(TPolyline polyline, ILogger logger) {
             if (polyline is null) {
                 logger
                     .LogNullArgumentWarning(nameof(polyline));
@@ -113,7 +113,7 @@ static void ValidateNullPolyline(ref TPolyline polyline, ILogger logger) {
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static void ValidateEmptySequence(ref ReadOnlyMemory<char> polyline, ILogger logger) {
+        static void ValidateEmptySequence(ReadOnlyMemory<char> polyline, ILogger logger) {
             if (polyline.Length < Defaults.Polyline.Block.Length.Min) {
                 logger.
                     LogOperationFailedDebug(OperationName);
@@ -135,7 +135,7 @@ static void ValidateEmptySequence(ref ReadOnlyMemory<char> polyline, ILogger log
     /// A <see cref="ReadOnlyMemory{T}"/> representing the encoded polyline data.
     /// </returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    protected abstract ReadOnlyMemory<char> GetReadOnlyMemory(TPolyline polyline);
+    protected abstract ReadOnlyMemory<char> GetReadOnlyMemory(ref TPolyline polyline);
 
     /// <summary>
     /// Creates a coordinate instance from the given latitude and longitude values.

src/PolylineAlgorithm/Abstraction/AbstractPolylineEncoder.cs

@@ -11,9 +11,12 @@ namespace PolylineAlgorithm.Abstraction;
 using PolylineAlgorithm.Internal.Logging;
 using PolylineAlgorithm.Properties;
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
+using static PolylineAlgorithm.Internal.Defaults.Polyline.Block;
 
 /// <summary>
 /// Provides functionality to encode a collection of geographic coordinates into an encoded polyline string.
@@ -57,7 +60,6 @@ protected AbstractPolylineEncoder(PolylineEncodingOptions options) {
     /// </param>
     /// <returns>
     /// An instance of <typeparamref name="TPolyline"/> representing the encoded coordinates.
-    /// Returns <see langword="default"/> if the input collection is empty or null.
     /// </returns>
     /// <exception cref="ArgumentNullException">
     /// Thrown when <paramref name="coordinates"/> is <see langword="null"/>.
@@ -81,38 +83,48 @@ public TPolyline Encode(ReadOnlySpan<TCoordinate> coordinates) {
         int consumed = 0;
         int length = GetMaxBufferLength(coordinates.Length, _logger);
 
-        Span<char> buffer = stackalloc char[length];
+        char[]? temp = length <= Options.StackAllocLimit
+            ? null
+            : ArrayPool<char>.Shared.Rent(length);
 
-        for (var i = 0; i < coordinates.Length; i++) {
-            variance
-                .Next(
-                    PolylineEncoding.Normalize(GetLatitude(coordinates[i]), CoordinateValueType.Latitude),
-                    PolylineEncoding.Normalize(GetLongitude(coordinates[i]), CoordinateValueType.Longitude)
-                );
+        Span<char> buffer = temp is null ? stackalloc char[length] : temp.AsSpan(0, length);
 
-            ValidateBuffer(ref variance, ref position, ref buffer, _logger);
+        try {
+            for (var i = 0; i < coordinates.Length; i++) {
+                variance
+                    .Next(
+                        PolylineEncoding.Normalize(GetLatitude(coordinates[i]), CoordinateValueType.Latitude),
+                        PolylineEncoding.Normalize(GetLongitude(coordinates[i]), CoordinateValueType.Longitude)
+                    );
 
-            if (!PolylineEncoding.TryWriteValue(variance.Latitude, ref buffer, ref position)
-                || !PolylineEncoding.TryWriteValue(variance.Longitude, ref buffer, ref position)
-            ) {
-                // This shouldn't happen, but if it does, log the error and throw an exception.
-                _logger
-                    .LogOperationFailedDebug(OperationName);
-                _logger
-                    .LogCannotWriteValueToBufferWarning(position, consumed);
+                ValidateBuffer(variance, position, buffer, _logger);
 
-                throw new InvalidOperationException(ExceptionMessageResource.CouldNotWriteEncodedValueToTheBuffer);
-            }
+                if (!PolylineEncoding.TryWriteValue(variance.Latitude, buffer, ref position)
+                    || !PolylineEncoding.TryWriteValue(variance.Longitude, buffer, ref position)
+                ) {
+                    // This shouldn't happen, but if it does, log the error and throw an exception.
+                    _logger
+                        .LogOperationFailedDebug(OperationName);
+                    _logger
+                        .LogCannotWriteValueToBufferWarning(position, consumed);
+
+                    throw new InvalidOperationException(ExceptionMessageResource.CouldNotWriteEncodedValueToTheBuffer);
+                }
 
-            consumed++;
+                consumed++;
+            }
+        } finally {
+            if(temp is not null) {
+                ArrayPool<char>.Shared.Return(temp);
+            }
         }
 
+        
+
         _logger
             .LogOperationFinishedDebug(OperationName);
 
-        var result = buffer[..position].ToString().AsMemory();
-
-        return CreatePolyline(ref result);
+        return CreatePolyline(buffer[..position].ToString().AsMemory());
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static int GetRequiredLength(CoordinateVariance variance) =>
@@ -134,16 +146,8 @@ int GetMaxBufferLength(int count, ILogger logger) {
 
             int requestedBufferLength = count * Defaults.Polyline.Block.Length.Max;
 
-            Debug.Assert(Options.MaxBufferLength > 0, "Max buffer length must be greater than zero.");
             Debug.Assert(requestedBufferLength > 0, "Requested buffer length must be greater than zero.");
 
-            if (requestedBufferLength > Options.MaxBufferLength) {
-                logger
-                    .LogRequestedBufferSizeExceedsMaxBufferLengthWarning(requestedBufferLength, Options.MaxBufferLength);
-
-                return Options.MaxBufferLength;
-            }
-
             return requestedBufferLength;
         }
 
@@ -160,7 +164,7 @@ static void ValidateEmptyCoordinates(ref ReadOnlySpan<TCoordinate> coordinates,
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static void ValidateBuffer(ref CoordinateVariance variance, ref int position, ref Span<char> buffer, ILogger logger) {
+        static void ValidateBuffer(CoordinateVariance variance, int position, Span<char> buffer, ILogger logger) {
             if (GetRemainingBufferSize(position, buffer.Length) < GetRequiredLength(variance)) {
                 logger
                     .LogOperationFailedDebug(OperationName);
@@ -180,7 +184,7 @@ static void ValidateBuffer(ref CoordinateVariance variance, ref int position, re
     /// An instance of <typeparamref name="TPolyline"/> representing the encoded polyline.
     /// </returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    protected abstract TPolyline CreatePolyline(ref ReadOnlyMemory<char> polyline);
+    protected abstract TPolyline CreatePolyline(ReadOnlyMemory<char> polyline);
 
     /// <summary>
     /// Extracts the longitude value from the specified coordinate.

src/PolylineAlgorithm/Internal/CoordinateVariance.cs

@@ -13,8 +13,7 @@ namespace PolylineAlgorithm.Internal;
 /// Represents the difference (variance) in latitude and longitude between consecutive geographic coordinates.
 /// This struct is used to compute and store the change in coordinate values as integer deltas.
 /// </summary>
-[DebuggerDisplay($"{{{nameof(ToString)}(),nq}}")]
-[StructLayout(LayoutKind.Sequential, Pack = 4, Size = 16)]
+[DebuggerDisplay("{ToString(),nq}")]
 internal struct CoordinateVariance {
     private (int Latitude, int Longitude) _current;
 
@@ -59,22 +58,16 @@ public void Next(int latitude, int longitude) {
     /// <param name="next">The next coordinate value.</param>
     /// <returns>The computed variance between <paramref name="initial"/> and <paramref name="next"/>.</returns>
 
-    private static int Variance(int initial, int next) => (initial, next) switch {
-        (0, 0) => 0,
-        (0, _) => next,
-        (_, 0) => -initial,
-        ( < 0, < 0) => -(Math.Abs(next) - Math.Abs(initial)),
-        ( < 0, > 0) => next + Math.Abs(initial),
-        ( > 0, < 0) => -(Math.Abs(next) + initial),
-        ( > 0, > 0) => next - initial,
-    };
+    private static int Variance(int initial, int next) => next - initial;
 
     /// <summary>
     /// Returns a string representation of the current coordinate variance.
     /// </summary>
     /// <returns>
     /// A string in the format <c>{ Coordinate:  { Latitude: [int], Longitude: [int] }, Variance: { Latitude: [int], Longitude: [int] } }</c> representing the current coordinate and deltas to previous coordinate.
     /// </returns>
-    public override readonly string ToString()
-        => $"{{ Coordinate:  {{ Latitude: {Latitude}, Longitude: {Longitude} }}, Variance: {{ Latitude: {Latitude}, Longitude: {Longitude} }} }}";
+    public override readonly string ToString() =>
+        $"{{ Coordinate: {{ Latitude: {_current.Latitude}, Longitude: {_current.Longitude} }}, " +
+        $"Variance: {{ Latitude: {Latitude}, Longitude: {Longitude} }} }}";
+
 }

src/PolylineAlgorithm/PolylineDecoder.cs

@@ -23,7 +23,7 @@ protected override Coordinate CreateCoordinate(double latitude, double longitude
     }
 
     /// <inheritdoc />
-    protected override ReadOnlyMemory<char> GetReadOnlyMemory(Polyline polyline) {
+    protected override ReadOnlyMemory<char> GetReadOnlyMemory(ref Polyline polyline) {
         return polyline.Value;
     }
 }

src/PolylineAlgorithm/PolylineEncoder.cs

@@ -28,7 +28,7 @@ protected override double GetLongitude(Coordinate coordinate) {
     }
 
     /// <inheritdoc />
-    protected override Polyline CreatePolyline(ref ReadOnlyMemory<char> polyline) {
+    protected override Polyline CreatePolyline(ReadOnlyMemory<char> polyline) {
         return Polyline.FromMemory(polyline);
     }
 }

src/PolylineAlgorithm/PolylineEncoding.cs

@@ -38,7 +38,7 @@ public static class PolylineEncoding {
     /// langword="false"/>.
     /// </returns>
 
-    public static bool TryReadValue(ref int variance, ref ReadOnlyMemory<char> buffer, ref int position) {
+    public static bool TryReadValue(ref int variance, ReadOnlyMemory<char> buffer, ref int position) {
         // Validate that the position is within the bounds of the buffer.
         if (position == buffer.Length) {
             return false;
@@ -105,7 +105,7 @@ public static double Denormalize(int value, CoordinateValueType type) {
             return 0.0;
         }
 
-        return Math.Truncate((double)value) / Defaults.Algorithm.Precision;
+        return value / (double)Defaults.Algorithm.Precision;
     }
 
     /// <summary>
@@ -131,7 +131,7 @@ public static double Denormalize(int value, CoordinateValueType type) {
     /// <see langword="true"/> if the value was successfully written to the buffer; otherwise, <see langword="false"/>.
     /// </returns>
 
-    public static bool TryWriteValue(int variance, ref Span<char> buffer, ref int position) {
+    public static bool TryWriteValue(int variance, Span<char> buffer, ref int position) {
         // Validate that the position and required space for write is within the bounds of the buffer.
         if (buffer.Length < position + GetCharCount(variance)) {
             return false;

src/PolylineAlgorithm/PolylineEncodingOptions.cs

@@ -18,27 +18,18 @@ namespace PolylineAlgorithm;
 [DebuggerDisplay("MaxBufferSize: {MaxBufferSize}, MaxBufferLength: {MaxBufferLength}, LoggerFactoryType: {LoggerFactory.GetType().Name}")]
 public sealed class PolylineEncodingOptions {
     /// <summary>
-    /// Gets the maximum buffer size for encoding operations.
-    /// </summary>
-    /// <remarks>
-    /// The default maximum buffer size is 64,000 bytes (64 KB). This can be adjusted based on the expected size of the polyline data, but should be enough for common cases.
-    /// </remarks>
-    public int MaxBufferSize { get; internal set; } = 64_000;
-
-    /// <summary>
-    /// Gets or sets the precision for encoding coordinates.
+    /// Gets logger factory.
     /// </summary>
     /// <remarks>
     /// The default logger factory is <see cref="NullLoggerFactory"/>, which does not log any messages.
     /// </remarks>
     public ILoggerFactory LoggerFactory { get; internal set; } = NullLoggerFactory.Instance;
 
-
     /// <summary>
-    /// Gets the maximum length of the encoded polyline string.
+    /// Gets stackalloc limit.
     /// </summary>
     /// <remarks>
-    /// The maximum length is calculated based on the buffer size divided by the size of a character.
+    /// The default stack alloc limit is 512.
     /// </remarks>
-    internal int MaxBufferLength => MaxBufferSize / sizeof(char);
+    public int StackAllocLimit { get; internal set; } = 512;
 }

src/PolylineAlgorithm/PolylineEncodingOptionsBuilder.cs

@@ -13,7 +13,7 @@ namespace PolylineAlgorithm;
 /// Provides a builder for configuring options for polyline encoding operations.
 /// </summary>
 public class PolylineEncodingOptionsBuilder {
-    private int _bufferSize = 64_000;
+    private int _stackAllocLimit = 512;
     private ILoggerFactory _loggerFactory = NullLoggerFactory.Instance;
 
     private PolylineEncodingOptionsBuilder() { }
@@ -36,7 +36,7 @@ public static PolylineEncodingOptionsBuilder Create() {
     /// </returns>
     public PolylineEncodingOptions Build() {
         return new PolylineEncodingOptions {
-            MaxBufferSize = _bufferSize,
+            StackAllocLimit = _stackAllocLimit,
             LoggerFactory = _loggerFactory
         };
     }
@@ -51,8 +51,9 @@ public PolylineEncodingOptions Build() {
     /// The current builder instance.
     /// </returns>
     /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="bufferSize"/> is less than or equal to 11.</exception>
-    public PolylineEncodingOptionsBuilder WithMaxBufferSize(int bufferSize) {
-        _bufferSize = bufferSize > 11 ? bufferSize : throw new ArgumentOutOfRangeException(nameof(bufferSize), string.Format(ExceptionMessageResource.BufferSizeMustBeGreaterThanMessageFormat, 11));
+    public PolylineEncodingOptionsBuilder WithStackAllocLimit(int stackAllocLimit) {
+        const int minStackAllocLimit = 1;
+        _stackAllocLimit = stackAllocLimit >= minStackAllocLimit ? stackAllocLimit : throw new ArgumentOutOfRangeException(nameof(stackAllocLimit), string.Format(ExceptionMessageResource.StackAllocLimitMustBeEqualOrGreaterThanMessageFormat, minStackAllocLimit));
 
         return this;
     }