ArrayPool(Segmented)BufferWriter

Author: andanteyk

ArrayPoolCollection.Benchmark/ArrayPoolCollection.Benchmark.csproj

@@ -9,6 +9,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.14.1-nightly.20250107.205" />
+    <PackageReference Include="MemoryPack" Version="1.21.4" />
   </ItemGroup>
 
   <ItemGroup>

ArrayPoolCollection.Benchmark/Experiment/BufferWriter.cs

@@ -0,0 +1,65 @@
+using System.Buffers;
+using System.IO.Pipelines;
+using ArrayPoolCollection.Buffers;
+using BenchmarkDotNet.Attributes;
+using MemoryPack;
+
+namespace ArrayPoolCollection.Benchmark.Experiment;
+
+[MemoryDiagnoser]
+public class BufferWriter
+{
+    private readonly TestClass Source = new TestClass(123, "Alice", "GDD", Enumerable.Range(0, 1000000).Select(i => i.ToString()).ToArray());
+
+    [Benchmark]
+    public TestClass ByteArray()
+    {
+        var bytes = MemoryPackSerializer.Serialize(Source);
+        return MemoryPackSerializer.Deserialize<TestClass>(bytes)!;
+    }
+
+    [Benchmark]
+    public async ValueTask<TestClass> Pipe()
+    {
+        var pipe = new Pipe();
+        MemoryPackSerializer.Serialize(pipe.Writer, Source);
+        await pipe.Writer.CompleteAsync();
+        var readResult = await pipe.Reader.ReadAsync();
+        return MemoryPackSerializer.Deserialize<TestClass>(readResult.Buffer)!;
+    }
+
+    [Benchmark]
+    public TestClass ArrayBufferWriter()
+    {
+        var writer = new ArrayBufferWriter<byte>();
+        MemoryPackSerializer.Serialize(writer, Source);
+        return MemoryPackSerializer.Deserialize<TestClass>(writer.WrittenSpan)!;
+    }
+
+    [Benchmark]
+    public TestClass ArrayPoolBufferWriter()
+    {
+        using var writer = new ArrayPoolBufferWriter<byte>(1024);
+        MemoryPackSerializer.Serialize(writer, Source);
+        return MemoryPackSerializer.Deserialize<TestClass>(writer.WrittenSpan)!;
+    }
+
+    [Benchmark]
+    public TestClass ArrayPoolSegmentedBufferWriter()
+    {
+        using var writer = new ArrayPoolSegmentedBufferWriter<byte>(1024);
+        MemoryPackSerializer.Serialize(writer, Source);
+        return MemoryPackSerializer.Deserialize<TestClass>(writer.GetWrittenSequence())!;
+    }
+
+    [Benchmark]
+    public TestClass With()
+    {
+        return Source with { Name = new string(Source.Name), Address = new string(Source.Address), Status = Source.Status.Select(i => new string(i)).ToArray() };
+    }
+}
+
+[MemoryPackable]
+public partial record class TestClass(int Id, string Name, string Address, string[] Status)
+{
+}

ArrayPoolCollection.Benchmark/Program.cs

@@ -1,5 +1,6 @@
 // See https://aka.ms/new-console-template for more information
 using ArrayPoolCollection.Benchmark;
+using ArrayPoolCollection.Benchmark.Experiment;
 using BenchmarkDotNet.Running;
 
 BenchmarkRunner.Run<ArrayPoolWrapperBenchmark>(args: Environment.GetCommandLineArgs());
@@ -10,3 +11,4 @@
 BenchmarkRunner.Run<ArrayPoolQueueBenchmark>(args: Environment.GetCommandLineArgs());
 BenchmarkRunner.Run<ArrayPoolPriorityQueueBenchmark>(args: Environment.GetCommandLineArgs());
 BenchmarkRunner.Run<ArrayPoolBitsBenchmark>(args: Environment.GetCommandLineArgs());
+BenchmarkRunner.Run<BufferWriter>(args: Environment.GetCommandLineArgs());

ArrayPoolCollection.Tests/ArrayPoolBufferWriterTests.cs

@@ -0,0 +1,265 @@
+namespace ArrayPoolCollection.Buffers.Tests;
+
+public class ArrayPoolBufferWriterTests
+{
+    [Fact]
+    public void Capacity()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        Assert.Equal(64, writer.Capacity);
+        writer.Advance(16);
+        Assert.Equal(64, writer.Capacity);
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.Capacity);
+    }
+
+    [Fact]
+    public void FreeCapacity()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        Assert.Equal(64, writer.FreeCapacity);
+        writer.Advance(16);
+        Assert.Equal(48, writer.FreeCapacity);
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.FreeCapacity);
+    }
+
+    [Fact]
+    public void WrittenCount()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        Assert.Equal(0, writer.WrittenCount);
+        writer.Advance(16);
+        Assert.Equal(16, writer.WrittenCount);
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.WrittenCount);
+    }
+
+    [Fact]
+    public void WrittenMemory()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        Assert.Equal(0, writer.WrittenMemory.Length);
+
+        var memory = writer.GetMemory(16);
+        for (int i = 0; i < memory.Length; i++)
+        {
+            memory.Span[i] = (byte)i;
+        }
+        writer.Advance(16);
+
+        var written = writer.WrittenMemory;
+        Assert.Equal(16, written.Length);
+        for (int i = 0; i < written.Length; i++)
+        {
+            Assert.Equal((byte)i, written.Span[i]);
+        }
+
+
+        memory = writer.GetMemory(64);
+        for (int i = 0; i < memory.Length; i++)
+        {
+            memory.Span[i] = (byte)(i + 16);
+        }
+        writer.Advance(64);
+
+        written = writer.WrittenMemory;
+        Assert.Equal(80, written.Length);
+        for (int i = 0; i < written.Length; i++)
+        {
+            Assert.Equal((byte)i, written.Span[i]);
+        }
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.WrittenMemory);
+    }
+
+    [Fact]
+    public void WrittenSpan()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        Assert.Equal(0, writer.WrittenSpan.Length);
+
+        var span = writer.GetSpan(16);
+        for (int i = 0; i < span.Length; i++)
+        {
+            span[i] = (byte)i;
+        }
+        writer.Advance(16);
+
+        var written = writer.WrittenSpan;
+        Assert.Equal(16, written.Length);
+        for (int i = 0; i < written.Length; i++)
+        {
+            Assert.Equal((byte)i, written[i]);
+        }
+
+
+        span = writer.GetSpan(64);
+        for (int i = 0; i < span.Length; i++)
+        {
+            span[i] = (byte)(i + 16);
+        }
+        writer.Advance(64);
+
+        written = writer.WrittenSpan;
+        Assert.Equal(80, written.Length);
+        for (int i = 0; i < written.Length; i++)
+        {
+            Assert.Equal((byte)i, written[i]);
+        }
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.WrittenSpan.Length);
+    }
+
+    [Fact]
+    public void Ctor()
+    {
+        using var defaultCtor = new ArrayPoolBufferWriter<byte>();
+
+        using var zero = new ArrayPoolBufferWriter<byte>(0);
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => new ArrayPoolBufferWriter<byte>(-1));
+    }
+
+    [Fact]
+    public void Advance()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => writer.Advance(-1));
+        writer.Advance(0);
+        writer.Advance(64);
+        Assert.Throws<ArgumentOutOfRangeException>(() => writer.Advance(1));
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.Advance(1));
+    }
+
+    [Fact]
+    public void Clear()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        writer.Clear();
+        Assert.Equal(0, writer.WrittenCount);
+
+        var span = writer.GetSpan(16);
+        for (int i = 0; i < span.Length; i++)
+        {
+            span[i] = (byte)i;
+        }
+        writer.Advance(16);
+
+        writer.Clear();
+        Assert.Equal(0, writer.WrittenCount);
+        writer.Advance(16);
+        var written = writer.WrittenSpan;
+        for (int i = 0; i < written.Length; i++)
+        {
+            Assert.Equal(0, written[i]);
+        }
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.Clear());
+    }
+
+    [Fact]
+    public void Dispose()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>();
+
+
+        writer.Dispose();
+        writer.Dispose();
+    }
+
+    [Fact]
+    public void GetMemory()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        Assert.True(writer.GetMemory(16).Length >= 16);
+        Assert.True(writer.GetMemory(128).Length >= 128);
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => writer.GetMemory(-1));
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.GetMemory(1));
+    }
+
+    [Fact]
+    public void GetSpan()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        var span = writer.GetSpan(16);
+        Assert.True(span.Length >= 16);
+
+        for (int i = 0; i < span.Length; i++)
+        {
+            span[i] = (byte)i;
+        }
+        writer.Advance(16);
+
+        span = writer.GetSpan(128);
+        Assert.True(span.Length >= 128);
+        for (int i = 0; i < span.Length; i++)
+        {
+            span[i] = (byte)i;
+        }
+
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => writer.GetSpan(-1));
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.GetSpan(1));
+    }
+
+    [Fact]
+    public void ResetWrittenCount()
+    {
+        var writer = new ArrayPoolBufferWriter<byte>(64);
+
+        writer.ResetWrittenCount();
+        Assert.Equal(0, writer.WrittenCount);
+
+        var span = writer.GetSpan(16);
+        for (int i = 0; i < span.Length; i++)
+        {
+            span[i] = (byte)i;
+        }
+        writer.Advance(16);
+
+        writer.ResetWrittenCount();
+        Assert.Equal(0, writer.WrittenCount);
+        writer.Advance(16);
+        var written = writer.WrittenSpan;
+        for (int i = 0; i < written.Length; i++)
+        {
+            Assert.Equal((byte)i, written[i]);
+        }
+
+
+        writer.Dispose();
+        Assert.Throws<ObjectDisposedException>(() => writer.ResetWrittenCount());
+    }
+}