remove json serialization benchmark

Author: lucasteles

benchmarks/Backdash.Benchmarks/Cases/SerializationBenchmark.cs

@@ -5,8 +5,6 @@
 using System.Buffers;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using System.Text.Json;
-using System.Text.Json.Serialization;
 using Backdash.Core;
 using Backdash.Data;
 using Backdash.Network;
@@ -15,65 +13,36 @@
 
 namespace Backdash.Benchmarks.Cases;
 
-[RPlotExporter]
-[InProcess, MemoryDiagnoser, RankColumn]
+[InProcess, MemoryDiagnoser]
+[RPlotExporter, RankColumn]
 public class SerializationBenchmark
 {
     TestData data = null!;
     TestData result = null!;
 
     readonly ArrayBufferWriter<byte> buffer = new((int)ByteSize.FromMebiBytes(10).ByteCount);
 
-    Utf8JsonWriter jsonWriter = null!;
-
-    readonly JsonSerializerOptions jsonOptions = new()
-    {
-        PreferredObjectCreationHandling = JsonObjectCreationHandling.Populate,
-        WriteIndented = false,
-        IncludeFields = true,
-    };
-
-    static TestData NewTestData(Random random)
-    {
-        TestData testData = new()
-        {
-            Field1 = random.NextBool(),
-            Field2 = random.Next<ulong>(),
-        };
-
-        for (int i = 0; i < testData.Field3.Length; i++)
-        {
-            ref var entry = ref testData.Field3[i];
-            entry.Field1 = random.Next();
-            entry.Field2 = random.Next<uint>();
-            entry.Field3 = random.Next<ulong>();
-            entry.Field4 = random.Next<long>();
-            entry.Field5 = random.Next<short>();
-            entry.Field6 = random.Next<ushort>();
-            entry.Field7 = random.Next<byte>();
-            entry.Field8 = random.Next<sbyte>();
-            random.Next(entry.Field9.AsSpan());
-        }
-
-        return testData;
-    }
-
     [GlobalSetup]
     public void Setup()
     {
         Random random = new(42);
-        data = NewTestData(random);
-        jsonWriter = new(buffer);
+        data = TestData.Generate(random);
     }
 
     [IterationSetup]
     public void BeforeEach()
     {
         buffer.Clear();
-        jsonWriter.Reset();
         result = new();
     }
 
+    [IterationCleanup]
+    public void AfterEach()
+    {
+        var size = ByteSize.FromBytes(buffer.WrittenCount);
+        Console.WriteLine($"Data Size: {size} ({size.ByteCount} bytes)");
+    }
+
     [Benchmark]
     public void Backdash()
     {
@@ -92,15 +61,6 @@ public void MemoryPack()
         MemoryPackSerializer.Deserialize(buffer.WrittenSpan, ref result!);
         Debug.Assert(data == result);
     }
-
-    [Benchmark]
-    public void SystemJson()
-    {
-        JsonSerializer.Serialize(jsonWriter, data, jsonOptions);
-        Utf8JsonReader reader = new(buffer.WrittenSpan);
-        result = JsonSerializer.Deserialize<TestData>(ref reader, jsonOptions)!;
-        Debug.Assert(data == result);
-    }
 }
 
 [MemoryPackable]
@@ -112,7 +72,7 @@ public sealed partial class TestData : IBinarySerializable, IEquatable<TestData>
 
     public TestData()
     {
-        Field3 = new TestEntryData[1_000];
+        Field3 = new TestEntryData[20_000];
         for (var i = 0; i < Field3.Length; i++)
             Field3[i].Field9 = new int[10_000];
     }
@@ -148,6 +108,31 @@ public static bool Equals(TestData? left, TestData? right)
 
     public static bool operator ==(TestData? left, TestData? right) => Equals(left, right);
     public static bool operator !=(TestData? left, TestData? right) => !Equals(left, right);
+
+    public static TestData Generate(Random random)
+    {
+        TestData testData = new()
+        {
+            Field1 = random.NextBool(),
+            Field2 = random.Next<ulong>(),
+        };
+
+        for (int i = 0; i < testData.Field3.Length; i++)
+        {
+            ref var entry = ref testData.Field3[i];
+            entry.Field1 = random.Next();
+            entry.Field2 = random.Next<uint>();
+            entry.Field3 = random.Next<ulong>();
+            entry.Field4 = random.Next<long>();
+            entry.Field5 = random.Next<short>();
+            entry.Field6 = random.Next<ushort>();
+            entry.Field7 = random.Next<byte>();
+            entry.Field8 = random.Next<sbyte>();
+            random.Next(entry.Field9.AsSpan());
+        }
+
+        return testData;
+    }
 }
 
 [MemoryPackable]

benchmarks/Backdash.Benchmarks/Program.cs

@@ -8,6 +8,4 @@
 switcher.Run(args);
 #endif
 
-// BenchmarkRunner.Run<GetBitStringBenchmark>();
-// BenchmarkRunner.Run<UdpClientBenchmark>();
 // await new UdpClientBenchmark().Start(10, false).ConfigureAwait(false);

src/Backdash/Core/Mem.cs

@@ -138,33 +138,33 @@ public static int PopCount<T>(in ReadOnlySpan<T> values) where T : unmanaged
             switch (remaining.Length)
             {
                 case >= sizeof(ulong):
-                {
-                    var value = MemoryMarshal.Read<ulong>(remaining[..sizeof(ulong)]);
-                    index += sizeof(ulong);
-                    count += BitOperations.PopCount(value);
-                    continue;
-                }
+                    {
+                        var value = MemoryMarshal.Read<ulong>(remaining[..sizeof(ulong)]);
+                        index += sizeof(ulong);
+                        count += BitOperations.PopCount(value);
+                        continue;
+                    }
                 case >= sizeof(uint):
-                {
-                    var value = MemoryMarshal.Read<uint>(remaining[..sizeof(uint)]);
-                    index += sizeof(uint);
-                    count += BitOperations.PopCount(value);
-                    continue;
-                }
+                    {
+                        var value = MemoryMarshal.Read<uint>(remaining[..sizeof(uint)]);
+                        index += sizeof(uint);
+                        count += BitOperations.PopCount(value);
+                        continue;
+                    }
                 case >= sizeof(ushort):
-                {
-                    var value = MemoryMarshal.Read<ushort>(remaining[..sizeof(ushort)]);
-                    index += sizeof(ushort);
-                    count += ushort.PopCount(value);
-                    continue;
-                }
+                    {
+                        var value = MemoryMarshal.Read<ushort>(remaining[..sizeof(ushort)]);
+                        index += sizeof(ushort);
+                        count += ushort.PopCount(value);
+                        continue;
+                    }
                 case >= sizeof(byte):
-                {
-                    var value = remaining[0];
-                    index += sizeof(byte);
-                    count += byte.PopCount(value);
-                    break;
-                }
+                    {
+                        var value = remaining[0];
+                        index += sizeof(byte);
+                        count += byte.PopCount(value);
+                        break;
+                    }
             }
         }