Merge pull request MessagePack-CSharp#27 from AArnott/fix9

Add support for IBufferWriter<byte>

Author: AArnott

sandbox/DynamicCodeDumper/DynamicCodeDumper.csproj

@@ -10,6 +10,9 @@
  <Compile Include="..\..\src\MessagePack\FloatBits.cs">
  <Link>Code\FloatBits.cs</Link>
  </Compile>
+ <Compile Include="..\..\src\MessagePack\BufferWriter.cs">
+ <Link>Code\BufferWriter.cs</Link>
+ </Compile>
  <Compile Include="..\..\src\MessagePack\Formatters\IMessagePackFormatter.cs">
  <Link>Code\IMessagePackFormatter.cs</Link>
  </Compile>
@@ -58,9 +61,6 @@
  <Compile Include="..\..\src\MessagePack\Internal\UnsafeMemory.Low.cs">
  <Link>Code\UnsafeMemory.Low.cs</Link>
  </Compile>
- <Compile Include="..\..\src\MessagePack\MessagePackBinary.cs">
- <Link>Code\MessagePackBinary.cs</Link>
- </Compile>
  <Compile Include="..\..\src\MessagePack\ExtensionHeader.cs">
  <Link>Code\ExtensionHeader.cs</Link>
  </Compile>

sandbox/DynamicCodeDumper/Program.cs

@@ -60,9 +60,12 @@ static void Main(string[] args)
 
  //DynamicContractlessObjectResolver.Instance.GetFormatter<EntityBase>();
 
- var sequenceWriter = new MessagePackWriter();
- f.Serialize(ref sequenceWriter, new MyClass { MyProperty1 = 100, MyProperty2 = "foo" }, null);
- sequenceWriter.Flush();
+ using (var sequence = new Sequence<byte>())
+ {
+ var sequenceWriter = new MessagePackWriter(sequence);
+ f.Serialize(ref sequenceWriter, new MyClass { MyProperty1 = 100, MyProperty2 = "foo" }, null);
+ sequenceWriter.Flush();
+ }
  }
  catch (Exception ex)
  {

sandbox/PerfBenchmarkDotNet/MessagePackWriterBenchmark.cs

@@ -12,6 +12,7 @@ namespace PerfBenchmarkDotNet
  public class MessagePackWriterBenchmark
  {
  private const int RepsOverArray = 300 * 1024;
+ private readonly Sequence<byte> sequence = new Sequence<byte>();
 
  private readonly int[] values = new int[newmsgpack::MessagePack.MessagePackCode.MaxFixInt];
  private readonly byte[] byteValues = new byte[newmsgpack::MessagePack.MessagePackCode.MaxFixInt];
@@ -34,11 +35,17 @@ public void GlobalSetup()
  }
  }
 
+ [IterationSetup]
+ public void IterationSetup() => this.sequence.GetSpan(bytes.Length);
+
+ [IterationCleanup]
+ public void IterationCleanup() => this.sequence.Reset();
+
  [Benchmark(OperationsPerInvoke = RepsOverArray * newmsgpack::MessagePack.MessagePackCode.MaxFixInt)]
  [BenchmarkCategory("2.0")]
  public void Write_Byte()
  {
- var writer = new newmsgpack::MessagePack.MessagePackWriter(this.bytes);
+ var writer = new newmsgpack::MessagePack.MessagePackWriter(this.sequence);
  for (int j = 0; j < RepsOverArray; j++)
  {
  for (int i = 0; i < byteValues.Length; i++)
@@ -66,7 +73,7 @@ public void WriteByte()
  [BenchmarkCategory("2.0")]
  public void Write_UInt32()
  {
- var writer = new newmsgpack::MessagePack.MessagePackWriter(this.bytes);
+ var writer = new newmsgpack::MessagePack.MessagePackWriter(this.sequence);
  for (int j = 0; j < RepsOverArray; j++)
  {
  for (int i = 0; i < values.Length; i++)
@@ -80,7 +87,7 @@ public void Write_UInt32()
  [BenchmarkCategory("2.0")]
  public void Write_Int32()
  {
- var writer = new newmsgpack::MessagePack.MessagePackWriter(this.bytes);
+ var writer = new newmsgpack::MessagePack.MessagePackWriter(this.sequence);
  for (int j = 0; j < RepsOverArray; j++)
  {
  for (int i = 0; i < values.Length; i++)
@@ -110,12 +117,14 @@ public void Write_String()
  {
  for (int j = 0; j < 5; j++)
  {
- var writer = new newmsgpack::MessagePack.MessagePackWriter(this.bytes);
+ var writer = new newmsgpack::MessagePack.MessagePackWriter(this.sequence);
  for (int i = 0; i < 1000000; i++)
  {
  writer.Write("Hello!");
  }
  writer.Flush();
+ this.sequence.Reset();
+ this.sequence.GetSpan(bytes.Length);
  }
  }
 

sandbox/PerfBenchmarkDotNet/PerfBenchmarkDotNet.csproj

@@ -2,6 +2,7 @@
  <PropertyGroup>
  <OutputType>Exe</OutputType>
  <TargetFrameworks>net47;netcoreapp2.0</TargetFrameworks>
+ <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
  </PropertyGroup>
  <ItemGroup>

sandbox/PerfBenchmarkDotNet/Program.cs

@@ -53,6 +53,7 @@ static void Main(string[] args)
  typeof(ImproveStringKeySerializeBenchmark),
  typeof(MessagePackReaderBenchmark),
  typeof(MessagePackWriterBenchmark),
+ typeof(SpanBenchmarks),
  });
 
  // args = new[] { "0" };

sandbox/PerfBenchmarkDotNet/SpanBenchmarks.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Runtime.InteropServices;
+using BenchmarkDotNet.Attributes;
+
+namespace PerfBenchmarkDotNet
+{
+ public class SpanBenchmarks
+ {
+ private const string SomeString = "Hi there";
+ private static readonly byte[] byteArray = new byte[1];
+
+ [Benchmark]
+ public unsafe void PinString()
+ {
+ fixed (char* pChars = SomeString)
+ {
+ char ch = pChars[0];
+ }
+ }
+
+ [Benchmark]
+ public unsafe void GetSpanFromString()
+ {
+ char ch = SomeString.AsSpan()[0];
+ }
+
+ [Benchmark]
+ public unsafe void PinArray()
+ {
+ fixed (byte* pBytes = byteArray)
+ {
+ pBytes[0] = 7;
+ }
+ }
+
+ [Benchmark]
+ public unsafe void PinArray_Indexer()
+ {
+ fixed (byte* pBytes = &byteArray[0])
+ {
+ pBytes[0] = 7;
+ }
+ }
+
+ [Benchmark]
+ public unsafe void PinSpan_GetReference()
+ {
+ Span<byte> span = byteArray;
+ fixed (byte* pBytes = &MemoryMarshal.GetReference(span))
+ {
+ pBytes[0] = 7;
+ }
+ }
+
+ [Benchmark]
+ public void PinSpan()
+ {
+ PinSpan_Helper(byteArray);
+ }
+
+ private static unsafe void PinSpan_Helper(Span<byte> bytes)
+ {
+ fixed (byte* pBytes = bytes)
+ {
+ pBytes[0] = 7;
+ }
+ }
+
+ [Benchmark]
+ public void PinSpan_Indexer()
+ {
+ PinSpan_Indexer_Helper(byteArray);
+ }
+
+ private static unsafe void PinSpan_Indexer_Helper(Span<byte> bytes)
+ {
+ fixed (byte* pBytes = &bytes[0])
+ {
+ pBytes[0] = 8;
+ }
+ }
+ }
+}

src/MessagePack/BufferWriter.cs

@@ -0,0 +1,192 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) Andrew Arnott. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace MessagePack
+{
+ /// <summary>
+ /// A fast access struct that wraps <see cref="IBufferWriter{T}"/>.
+ /// </summary>
+ internal ref struct BufferWriter
+ {
+ /// <summary>
+ /// The underlying <see cref="IBufferWriter{T}"/>.
+ /// </summary>
+ private IBufferWriter<byte> _output;
+
+ /// <summary>
+ /// The result of the last call to <see cref="IBufferWriter{T}.GetSpan(int)"/>, less any bytes already "consumed" with <see cref="Advance(int)"/>.
+ /// Backing field for the <see cref="Span"/> property.
+ /// </summary>
+ private Span<byte> _span;
+
+ /// <summary>
+ /// The result of the last call to <see cref="IBufferWriter{T}.GetMemory(int)"/>, less any bytes already "consumed" with <see cref="Advance(int)"/>.
+ /// </summary>
+ private ArraySegment<byte> _segment;
+
+ /// <summary>
+ /// The number of uncommitted bytes (all the calls to <see cref="Advance(int)"/> since the last call to <see cref="Commit"/>).
+ /// </summary>
+ private int _buffered;
+
+ /// <summary>
+ /// The total number of bytes written with this writer.
+ /// Backing field for the <see cref="BytesCommitted"/> property.
+ /// </summary>
+ private long _bytesCommitted;
+
+ /// <summary>
+ /// Initializes a new instance of the <see cref="BufferWriter"/> struct.
+ /// </summary>
+ /// <param name="output">The <see cref="IBufferWriter{T}"/> to be wrapped.</param>
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public BufferWriter(IBufferWriter<byte> output)
+ {
+ _buffered = 0;
+ _bytesCommitted = 0;
+ _output = output;
+
+ var memory = _output.GetMemory();
+ MemoryMarshal.TryGetArray(memory, out _segment);
+ _span = memory.Span;
+ }
+
+ /// <summary>
+ /// Gets the result of the last call to <see cref="IBufferWriter{T}.GetSpan(int)"/>.
+ /// </summary>
+ public Span<byte> Span => _span;
+
+ /// <summary>
+ /// Gets the total number of bytes written with this writer.
+ /// </summary>
+ public long BytesCommitted => _bytesCommitted;
+
+ /// <summary>
+ /// Gets the <see cref="IBufferWriter{T}"/> underlying this instance.
+ /// </summary>
+ internal IBufferWriter<byte> UnderlyingWriter => _output;
+
+ public Span<byte> GetSpan(int sizeHint)
+ {
+ Ensure(sizeHint);
+ return this.Span;
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public ref byte GetPointer(int sizeHint)
+ {
+ Ensure(sizeHint);
+
+ if (_segment.Array != null)
+ {
+ return ref _segment.Array[_segment.Offset + _buffered];
+ }
+ else
+ {
+ return ref _span.GetPinnableReference();
+ }
+ }
+
+ /// <summary>
+ /// Calls <see cref="IBufferWriter{T}.Advance(int)"/> on the underlying writer
+ /// with the number of uncommitted bytes.
+ /// </summary>
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public void Commit()
+ {
+ var buffered = _buffered;
+ if (buffered > 0)
+ {
+ _bytesCommitted += buffered;
+ _buffered = 0;
+ _output.Advance(buffered);
+ _span = default;
+ }
+ }
+
+ /// <summary>
+ /// Used to indicate that part of the buffer has been written to.
+ /// </summary>
+ /// <param name="count">The number of bytes written to.</param>
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public void Advance(int count)
+ {
+ _buffered += count;
+ _span = _span.Slice(count);
+ }
+
+ /// <summary>
+ /// Copies the caller's buffer into this writer and calls <see cref="Advance(int)"/> with the length of the source buffer.
+ /// </summary>
+ /// <param name="source">The buffer to copy in.</param>
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public void Write(ReadOnlySpan<byte> source)
+ {
+ if (_span.Length >= source.Length)
+ {
+ source.CopyTo(_span);
+ Advance(source.Length);
+ }
+ else
+ {
+ WriteMultiBuffer(source);
+ }
+ }
+
+ /// <summary>
+ /// Acquires a new buffer if necessary to ensure that some given number of bytes can be written to a single buffer.
+ /// </summary>
+ /// <param name="count">The number of bytes that must be allocated in a single buffer.</param>
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public void Ensure(int count = 1)
+ {
+ if (_span.Length < count)
+ {
+ EnsureMore(count);
+ }
+ }
+
+ /// <summary>
+ /// Gets a fresh span to write to, with an optional minimum size.
+ /// </summary>
+ /// <param name="count">The minimum size for the next requested buffer.</param>
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private void EnsureMore(int count = 0)
+ {
+ if (_buffered > 0)
+ {
+ Commit();
+ }
+
+ var memory = _output.GetMemory(count);
+ MemoryMarshal.TryGetArray(memory, out _segment);
+ _span = memory.Span;
+ }
+
+ /// <summary>
+ /// Copies the caller's buffer into this writer, potentially across multiple buffers from the underlying writer.
+ /// </summary>
+ /// <param name="source">The buffer to copy into this writer.</param>
+ private void WriteMultiBuffer(ReadOnlySpan<byte> source)
+ {
+ while (source.Length > 0)
+ {
+ if (_span.Length == 0)
+ {
+ EnsureMore();
+ }
+
+ var writable = Math.Min(source.Length, _span.Length);
+ source.Slice(0, writable).CopyTo(_span);
+ source = source.Slice(writable);
+ Advance(writable);
+ }
+ }
+ }
+}