becnhmark updates

Author: Petr Sramek

benchmarks/PolylineAlgorithm.Benchmarks/PolylineBenchmark.cs

@@ -17,8 +17,8 @@ namespace PolylineAlgorithm.Benchmarks;
 public class PolylineBenchmark {
     private static readonly Consumer consumer = new();
 
-    [Params(1, 10, 100, 250, 500, 1_000, 2_500, 5_000, 7_500, 10_000, 15_000, 20_000, 25_000, 50_000, 75_000, 100_000, 250_000, 500_000, 750_000, 1_000_000)]
-    public int Length;
+    [Params(1, 25, 50, 100, 250, 500, 1_000, 5_000, 10_000, 25_000, 50_000, 100_000, 500_000, 1_000_000)]
+    public int Count;
 
 #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>
@@ -41,6 +41,13 @@ public class PolylineBenchmark {
     /// </summary>
     public string StringValue { get; private set; }
 
+    /// <summary>
+    /// Gets the read-only memory representing the encoded polyline.
+    /// </summary>
+    public Polyline PolylineNotEqualValue { get; private set; }
+
+    public char[] CopyToDestination { 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.
 
 
@@ -49,10 +56,13 @@ public class PolylineBenchmark {
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
-        PolylineValue = ValueProvider.GetPolyline(Length);
+        PolylineValue = ValueProvider.GetPolyline(Count);
+        PolylineNotEqualValue = ValueProvider.GetPolyline(Count + Random.Shared.Next(1, 101));
         StringValue = PolylineValue.ToString();
-        CharArrayValue = StringValue.ToArray();
+        CharArrayValue = [.. StringValue];
         MemoryValue = CharArrayValue.AsMemory();
+        
+        CopyToDestination = new char[PolylineValue.Length];
     }
 
     /// <summary>
@@ -103,31 +113,17 @@ public string Polyline_ToString() {
         return stringValue;
     }
 
-    ///// <summary>
-    ///// Benchmarks the encoding of an enumeration of coordinates into a polyline.
-    ///// </summary>
-    ///// <returns>The encoded polyline.</returns>
-    //[Benchmark]
-    //public long Polyline_GetCoordinateCount() {
-    //    var coordinateCount = PolylineValue
-    //        .GetCoordinateCount();
-
-    //    return coordinateCount;
-    //}
-
 
     /// <summary>
     /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
     public void Polyline_CopyTo() {
-        var destination = new char[PolylineValue.Length];
-
         PolylineValue
-            .CopyTo(destination);
+            .CopyTo(CopyToDestination);
 
-        destination
+        CopyToDestination
              .Consume(consumer);
     }
 
@@ -136,10 +132,22 @@ public void Polyline_CopyTo() {
     /// </summary>
     /// <returns>The encoded polyline.</returns>
     [Benchmark]
-    public bool Polyline_Equals() {
+    public bool Polyline_Equals_SameValue() {
         var equals = PolylineValue
             .Equals(PolylineValue);
 
         return equals;
     }
+
+    /// <summary>
+    /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
+    /// </summary>
+    /// <returns>The encoded polyline.</returns>
+    [Benchmark]
+    public bool Polyline_Equals_DifferentValue() {
+        var equals = PolylineValue
+            .Equals(PolylineNotEqualValue);
+
+        return equals;
+    }
 }

benchmarks/PolylineAlgorithm.Benchmarks/PolylineBuilderBenchmark.cs

@@ -0,0 +1,78 @@
+//
+// 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 PolylineAlgorithm.Utility;
+
+/// <summary>
+/// Benchmarks for the <see cref="PolylineValue"/> struct.
+/// </summary>
+[RankColumn]
+public class PolylineBuilderBenchmark {
+    [Params(1, 10, 100, 500, 1_000)]
+    public int Count;
+
+    [Params(1, 5, 10, 50, 100)]
+    public int SegmentsCount;
+
+#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 character array representing the encoded polyline.
+    /// </summary>
+    public char[] CharArrayValue { get; private set; }
+
+    /// <summary>
+    /// Gets the read-only memory representing the encoded polyline.
+    /// </summary>
+    public ReadOnlyMemory<char> MemoryValue { get; private set; }
+
+
+    /// <summary>
+    /// Gets the string value representing the encoded polyline.
+    /// </summary>
+    public string StringValue { get; private set; }
+
+    /// <summary>
+    /// Gets the read-only memory representing the encoded polyline.
+    /// </summary>
+    public Polyline PolylineNotEqualValue { get; private set; }
+
+    public char[] CopyToDestination { get; private set; }
+
+    internal Polyline.PolylineBuilder Builder { 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>
+    /// Sets up the data for the benchmarks.
+    /// </summary>
+    [GlobalSetup]
+    public void SetupData() {
+        Builder = new Polyline.PolylineBuilder();
+
+        var polyline = ValueProvider.GetPolyline(Count);
+        StringValue = polyline.ToString();
+        CharArrayValue = [.. StringValue];
+        MemoryValue = CharArrayValue.AsMemory();
+    }
+
+    /// <summary>
+    /// Benchmarks the encoding of a list of coordinates into a polyline.
+    /// </summary>
+    /// <returns>The encoded polyline.</returns>
+    [Benchmark]
+    public Polyline PolylineBuilder_Append_Memory() {
+        for(int i = 0; i < SegmentsCount; i++) {
+            Builder
+                .Append(MemoryValue);
+        }
+
+        return Builder.Build();
+    }
+}

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -18,24 +18,14 @@ namespace PolylineAlgorithm.Benchmarks;
 public class PolylineDecoderBenchmark {
     private readonly Consumer _consumer = new();
 
-    [Params(1, 10, 100, 250, 500, 1_000, 2_500, 5_000, 7_500, 10_000, 15_000, 20_000, 25_000, 50_000, 75_000, 100_000, 250_000, 500_000, 750_000, 1_000_000)]
-    public int N;
+    [Params(1, 25, 50, 100, 250, 500, 1_000, 5_000, 10_000, 25_000, 50_000, 100_000, 500_000, 1_000_000)]
+    public int Count;
 
 #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.
     /// </summary>
-    public string StringValue { get; private set; }
-
-    /// <summary>
-    /// Gets the character array representing the encoded polyline.
-    /// </summary>
-    public char[] CharArray { get; private set; }
-
-    /// <summary>
-    /// Gets the read-only memory representing the encoded polyline.
-    /// </summary>
-    public ReadOnlyMemory<char> Memory { get; private set; }
+    public Polyline Polyline { 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.
 
@@ -49,44 +39,16 @@ public class PolylineDecoderBenchmark {
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
-        StringValue = ValueProvider.GetPolyline(N).ToString();
-        CharArray = StringValue.ToArray();
-        Memory = CharArray.AsMemory();
+        Polyline = ValueProvider.GetPolyline(Count);
     }
 
     /// <summary>
     /// Benchmarks the decoding of a polyline from a string.
     /// </summary>
     [Benchmark]
-    public void PolylineDecoder_Decode_FromString() {
-        Polyline polyline = Polyline.FromString(StringValue);
-
-        Decoder
-            .Decode(StringValue)
-            .Consume(_consumer);
-    }
-
-    /// <summary>
-    /// Benchmarks the decoding of a polyline from a character array.
-    /// </summary>
-    [Benchmark]
-    public void PolylineDecoder_Decode_FromCharArray() {
-        Polyline polyline = Polyline.FromCharArray(CharArray);
-
-        Decoder
-            .Decode(StringValue)
-            .Consume(_consumer);
-    }
-
-    /// <summary>
-    /// Benchmarks the decoding of a polyline from read-only memory.
-    /// </summary>
-    [Benchmark]
-    public void PolylineDecoder_Decode_FromMemory() {
-        Polyline polyline = Polyline.FromMemory(Memory);
-
+    public void PolylineDecoder_Decode() {
         Decoder
-            .Decode(StringValue)
+            .Decode(Polyline)
             .Consume(_consumer);
     }
 }

benchmarks/PolylineAlgorithm.Benchmarks/PolylineEncoderBenchmark.cs

@@ -16,21 +16,19 @@ namespace PolylineAlgorithm.Benchmarks;
 /// </summary>
 [RankColumn]
 public class PolylineEncoderBenchmark {
-    [Params(1, 10, 100, 250, 500, 1_000, 2_500, 5_000, 7_500, 10_000, 15_000, 20_000, 25_000, 50_000, 75_000, 100_000, 250_000, 500_000, 750_000, 1_000_000)]
-    public int N;
+    [Params(1, 25, 50, 100, 250, 500, 1_000, 5_000, 10_000, 25_000, 50_000, 100_000, 500_000, 1_000_000)]
+    public int Count;
 
 #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 enumeration of coordinates to be encoded.
     /// </summary>
-    public static IEnumerable<Coordinate> Enumeration { get; private set; }
+    public IEnumerable<Coordinate> Enumeration { get; private set; }
 
     /// <summary>
     /// Gets the list of coordinates to be encoded.
     /// </summary>
-    public static List<Coordinate> List { get; private set; }
-
-    public static IAsyncEnumerable<Coordinate> AsyncEnumeration { get; private set; }
+    public List<Coordinate> List { 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>
@@ -48,15 +46,8 @@ public class PolylineEncoderBenchmark {
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
-        Enumeration = ValueProvider.GetCoordinates(N);
+        Enumeration = ValueProvider.GetCoordinates(Count);
         List = [.. Enumeration];
-        AsyncEnumeration = GetAsyncEnumeration(Enumeration!);
-    }
-
-    private async IAsyncEnumerable<Coordinate> GetAsyncEnumeration(IEnumerable<Coordinate> enumerable) {
-        foreach (var item in enumerable) {
-            yield return await new ValueTask<Coordinate>(item);
-        }
     }
 
     /// <summary>
@@ -82,17 +73,4 @@ public Polyline PolylineEncoder_Encode_Enumerator() {
 
         return polyline;
     }
-
-    /// <summary>
-    /// Benchmarks the encoding of an enumeration of coordinates into a polyline.
-    /// </summary>
-    /// <returns>The encoded polyline.</returns>
-    //[Benchmark]
-    //public async Task<Polyline> PolylineEncoder_EncodeAsync_String() {
-    //    var polyline = await AsyncEncoder
-    //        .EncodeAsync(AsyncEnumeration!)
-    //        .ConfigureAwait(false);
-
-    //    return polyline;
-    //}
 }

benchmarks/PolylineAlgorithm.Comparison.Benchmarks/PolylineDecoderBenchmark.cs

@@ -53,8 +53,8 @@ public class PolylineDecoderBenchmark {
     /// </summary>
     [GlobalSetup]
     public void SetupData() {
-        StringValue = ValueProvider.GetPolyline(Count).ToString();
         PolylineValue = ValueProvider.GetPolyline(Count);
+        StringValue = PolylineValue.ToString();
     }
 
     /// <summary>

src/PolylineAlgorithm/PolylineAlgorithm.csproj

@@ -70,7 +70,7 @@
 			<_Parameter1>PolylineAlgorithm.Tests</_Parameter1>
 		</AssemblyAttribute>
 		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
-			<_Parameter1>PolylineAlgorithm.IO.Pipelines</_Parameter1>
+			<_Parameter1>PolylineAlgorithm.Benchmarks</_Parameter1>
 		</AssemblyAttribute>
 	</ItemGroup>