ProtoBuf Bytes Serializer Benchmark

1. Code

ProtoBufSerializerSerializeBenchmark.cs:

using BenchmarkDotNet.Attributes;
using ProtoBuf;
using System.Buffers;
using System.Diagnostics;
using System.Runtime.CompilerServices;

namespace BenchmarkTest {
    [MemoryDiagnoser]
    public class ProtoBufSerializerSerializeBenchmark {
        public SmallObject[] SmallObjects { get; set; } = null!;
        public BigObject[] BigObjects { get; set; } = null!;

        [GlobalSetup]
        public void Setup() {
            const int NUMS = 256;

            SmallObjects = new SmallObject[NUMS];
            BigObjects = new BigObject[NUMS];

            for (int i = 0; i < NUMS; i++) {
                SmallObjects[i] = new SmallObject(i);
                BigObjects[i] = new BigObject();
            }
        }

        [Benchmark]
        public void TestSmallObjectToByteArrayUseMemoryStream() {
            for (int i = 0; i < SmallObjects.Length; i++) {
                ToByteArrayUseMemoryStream(SmallObjects[i]);
            }
        }

        [Benchmark]
        public void TestSmallObjectToByteArrayUseArrayPool() {
            for (int i = 0; i < SmallObjects.Length; i++) {
                ToByteArrayUseArrayPool(SmallObjects[i]);
            }
        }

        [Benchmark]
        public void TestSmallObjectToByteArrayUseArray() {
            for (int i = 0; i < SmallObjects.Length; i++) {
                ToByteArrayUseArray(SmallObjects[i]);
            }
        }

        [Benchmark]
        public void TestBigObjectToByteArrayUseMemoryStream() {
            for (int i = 0; i < BigObjects.Length; i++) {
                ToByteArrayUseMemoryStream(BigObjects[i]);
            }
        }

        [Benchmark]
        public void TestBigObjectToByteArrayUseArrayPool() {
            for (int i = 0; i < BigObjects.Length; i++) {
                ToByteArrayUseArrayPool(BigObjects[i]);
            }
        }

        [Benchmark]
        public void TestBigObjectToByteArrayUseArray() {
            for (int i = 0; i < BigObjects.Length; i++) {
                ToByteArrayUseArray(BigObjects[i]);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static byte[] ToByteArrayUseMemoryStream<T>(T value) {
            using var stream = new MemoryStream();
            Serializer.Serialize(stream, value);
            return stream.ToArray();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static byte[] ToByteArrayUseArrayPool<T>(T value) {
            using var pool = new PooledArrayBufferWriter<byte>();
            Serializer.Serialize(pool, value);
            return pool.GetSpan().ToArray();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static byte[] ToByteArrayUseArray<T>(T value) {
            var array = new ArrayBufferWriter<byte>();
            Serializer.Serialize(array, value);
            return array.GetSpan().ToArray();
        }
    }

    [ProtoContract]
    public class SmallObject {
        [ProtoMember(1)]
        public int Data { get; set; }

        public SmallObject(int data) {
            Data = data;
        }
    }

    [ProtoContract]
    public class BigObject {
        [ProtoMember(1)]
        public byte[] Data { get; set; }

        public BigObject() {
            Data = new byte[1024 * 8];
            new Random(42).NextBytes(Data);
        }
    }

    internal sealed class PooledArrayBufferWriter<T> : IBufferWriter<T>, IDisposable {
        private T[] _rentedBuffer;
        private int _index;

        private const int MinimumBufferSize = 256;

        public PooledArrayBufferWriter() {
            _rentedBuffer = ArrayPool<T>.Shared.Rent(MinimumBufferSize);
            _index = 0;
        }

        public PooledArrayBufferWriter(int initialCapacity) {
            if (initialCapacity <= 0) {
                throw new ArgumentOutOfRangeException(nameof(initialCapacity));
            }

            _rentedBuffer = ArrayPool<T>.Shared.Rent(initialCapacity);
            _index = 0;
        }

        public ReadOnlyMemory<T> WrittenMemory {
            get {
                CheckIfDisposed();

                return _rentedBuffer.AsMemory(0, _index);
            }
        }

        public int WrittenCount {
            get {
                CheckIfDisposed();

                return _index;
            }
        }

        public int Capacity {
            get {
                CheckIfDisposed();

                return _rentedBuffer.Length;
            }
        }

        public int FreeCapacity {
            get {
                CheckIfDisposed();

                return _rentedBuffer.Length - _index;
            }
        }

        public void Clear() {
            CheckIfDisposed();

            ClearHelper();
        }

        private void ClearHelper() {
            Debug.Assert(_rentedBuffer != null);

            _rentedBuffer.AsSpan(0, _index).Clear();
            _index = 0;
        }

        // Returns the rented buffer back to the pool
        public void Dispose() {
            if (_rentedBuffer == null) {
                return;
            }

            ClearHelper();
            ArrayPool<T>.Shared.Return(_rentedBuffer);
            _rentedBuffer = null;
        }

        private void CheckIfDisposed() {
            if (_rentedBuffer == null) {
                ThrowObjectDisposedException();
            }
        }

        private static void ThrowObjectDisposedException() {
            throw new ObjectDisposedException(nameof(ArrayBufferWriter<T>));
        }

        public void Advance(int count) {
            CheckIfDisposed();

            if (count < 0) {
                throw new ArgumentOutOfRangeException(nameof(count));
            }

            if (_index > _rentedBuffer.Length - count) {
                ThrowInvalidOperationException(_rentedBuffer.Length);
            }

            _index += count;
        }

        public Memory<T> GetMemory(int sizeHint = 0) {
            CheckIfDisposed();

            CheckAndResizeBuffer(sizeHint);
            return _rentedBuffer.AsMemory(_index);
        }

        public Span<T> GetSpan(int sizeHint = 0) {
            CheckIfDisposed();

            CheckAndResizeBuffer(sizeHint);
            return _rentedBuffer.AsSpan(_index);
        }

        private void CheckAndResizeBuffer(int sizeHint) {
            Debug.Assert(_rentedBuffer != null);

            if (sizeHint < 0) {
                throw new ArgumentOutOfRangeException(nameof(sizeHint));
            }

            if (sizeHint == 0) {
                sizeHint = MinimumBufferSize;
            }

            var availableSpace = _rentedBuffer.Length - _index;

            if (sizeHint > availableSpace) {
                var growBy = Math.Max(sizeHint, _rentedBuffer.Length);

                var newSize = checked(_rentedBuffer.Length + growBy);

                var oldBuffer = _rentedBuffer;

                _rentedBuffer = ArrayPool<T>.Shared.Rent(newSize);

                Debug.Assert(oldBuffer.Length >= _index);
                Debug.Assert(_rentedBuffer.Length >= _index);

                var previousBuffer = oldBuffer.AsSpan(0, _index);
                previousBuffer.CopyTo(_rentedBuffer);
                previousBuffer.Clear();
                ArrayPool<T>.Shared.Return(oldBuffer);
            }

            Debug.Assert(_rentedBuffer.Length - _index > 0);
            Debug.Assert(_rentedBuffer.Length - _index >= sizeHint);
        }

        private static void ThrowInvalidOperationException(int capacity) {
            throw new InvalidOperationException($"Cannot advance past the end of the buffer, which has a size of {capacity}.");
        }
    }
}

Program.cs:

using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Running;
using BenchmarkTest;

var summary = BenchmarkRunner.Run<ProtoBufSerializerSerializeBenchmark>(DefaultConfig.Instance.AddJob(Job.Default.WithGcServer(true).WithGcForce(true)));

Console.ReadKey();

2. Result

BenchmarkDotNet=v0.13.2, OS=Windows 10 (10.0.19045.2193)
Intel Core i7-10700 CPU 2.90GHz, 1 CPU, 16 logical and 8 physical cores
.NET SDK=6.0.301
  [Host]     : .NET 6.0.10 (6.0.1022.47605), X64 RyuJIT AVX2
  Job-SDZEUL : .NET 6.0.10 (6.0.1022.47605), X64 RyuJIT AVX2

Force=True  Server=True

Method	Mean	Error	StdDev	Median	Gen0	Gen1	Allocated
TestSmallObjectToByteArrayUseMemoryStream	46.83 μs	0.147 μs	0.114 μs	46.88 μs	0.6714	-	93.7 KB
TestSmallObjectToByteArrayUseArrayPool	94.70 μs	0.372 μs	0.329 μs	94.73 μs	3.7842	-	524.25 KB
TestSmallObjectToByteArrayUseArray	76.32 μs	1.506 μs	2.061 μs	75.11 μs	3.7842	-	530.5 KB
TestBigObjectToByteArrayUseMemoryStream	463.81 μs	7.856 μs	7.349 μs	458.87 μs	31.7383	-	4198 KB
TestBigObjectToByteArrayUseArrayPool	474.88 μs	8.870 μs	15.300 μs	468.29 μs	15.6250	-	2062 KB
TestBigObjectToByteArrayUseArray	944.26 μs	5.348 μs	4.466 μs	943.41 μs	75.1953	2.9297	10028 KB

3. Summary

• small object:

  MemoryStream > PooledArrayBufferWriter > ArrayBufferWriter

  不论是速度还是内存都是 MemoryStream 最优。

• big object (8KB):

  PooledArrayBufferWriter > MemoryStream > ArrayBufferWriter

  速度上 PooledArrayBufferWriter 与 MemoryStream 差不多，但是在内存使用上 PooledArrayBufferWriter 最优。

通常情况下推荐：MemoryStream，当对象足够大的时候推荐 PooledArrayBufferWriter。ArrayBufferWriter 不推荐。