.net 使用BinaryPrimitives填充字节缓冲区的首选方法？

kiayqfof  于 2023-01-22  发布在  .NET
关注(0)|答案(2)|浏览(214)

我正在使用System.Buffers.Binary.BinaryPrimitives以精确的方式将值写入字节数组。没有来自MS的示例，我可以看到几种方法来完成它，但我不确定其中一种是否比另一种更好。原则上，创建大量Span<byte>对象的需要似乎不太理想？
考虑这个简单的例子：

  1. //writes these values in this order to a new 16-byte buffer
  2. byte[] PopulateBuffer(int i1,int i2,Int16 s1,Int16 s2)
  3. {
  4.  var buffer = new byte[16]; //padded based on external protocol
  5.  var span = new Span<byte>(buffer);
  6.  BinaryPrimitives.WriteInt32LittleEndian(span.Slice(0,4),i1);
  7.  BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4,4),i2);
  8.  BinaryPrimitives.WriteInt16LittleEndian(span.Slice(8,2),s1);
  9.  BinaryPrimitives.WriteInt16LittleEndian(span.Slice(10,2),s2);
  10.  return buffer;
  11. }

我在这里示例化了5个Span对象。与老式的通过位移位手动获取字节的方法相比，这看起来确实很混乱，但实际上开销很大吗？有没有更好的方法来使用这个类？

.net

2条答案

按热度按时间
xqkwcwgp

xqkwcwgp1#

TL;DR：从下面的结果来看，基于Span的方法似乎比替代方法要快得多。
注意，Span<T>是一个值类型，JIT在看穿它方面做得相当不错。
我创建了一个简化测试：

  1. using System;
  2. using System.Buffers.Binary;
  3. public class C
  4. {
  5.     byte[] PopulateBufferSpan(int i1, short s2)
  6.     {
  7.          var buffer = new byte[6];
  8.          var span = new Span<byte>(buffer);
  9.          BinaryPrimitives.WriteInt32LittleEndian(span.Slice(0,4), i1);
  10.          BinaryPrimitives.WriteInt16LittleEndian(span.Slice(4,2), s2);
  11.          return buffer;
  12.     }
  14.     byte[] PopulateBufferExplicit(int i1, short s2)
  15.     {
  16.         var buffer = new byte[6];
  17.         buffer[0] = (byte)(i1 & 0xFF);
  18.         buffer[1] = (byte)((i1 >> 8) & 0xFF);
  19.         buffer[2] = (byte)((i1 >> 16) & 0xFF);
  20.         buffer[3] = (byte)((i1 >> 24) & 0xFF);
  21.         buffer[4] = (byte)(s2 & 0xFF);
  22.         buffer[5] = (byte)((s2 >> 8) & 0xFF);
  23.         return buffer;
  24.     }
  25. }

哪个JIT用于：

  1. C.PopulateBufferSpan(Int32, Int16)
  2.     L0000: push rdi
  3.     L0001: push rsi
  4.     L0002: sub rsp, 0x28
  5.     L0006: mov esi, edx
  6.     L0008: mov edi, r8d
  7.     L000b: mov rcx, 0x7ffec35e2360
  8.     L0015: mov edx, 0x6
  9.     L001a: call 0x7fff230847e0
  10.     L001f: lea rdx, [rax+0x10]
  11.     L0023: mov ecx, 0x6
  12.     L0028: mov r8d, ecx
  13.     L002b: cmp r8, 0x4
  14.     L002f: jb L0051
  15.     L0031: mov r8, rdx
  16.     L0034: mov [r8], esi
  17.     L0037: mov ecx, ecx
  18.     L0039: cmp rcx, 0x6
  19.     L003d: jb L0057
  20.     L003f: add rdx, 0x4
  21.     L0043: movsx rcx, di
  22.     L0047: mov [rdx], cx
  23.     L004a: add rsp, 0x28
  24.     L004e: pop rsi
  25.     L004f: pop rdi
  26.     L0050: ret
  27.     L0051: call System.ThrowHelper.ThrowArgumentOutOfRangeException()
  28.     L0056: int3
  29.     L0057: call System.ThrowHelper.ThrowArgumentOutOfRangeException()
  30.     L005c: int3
  32. C.PopulateBufferExplicit(Int32, Int16)
  33.     L0000: push rdi
  34.     L0001: push rsi
  35.     L0002: sub rsp, 0x28
  36.     L0006: mov esi, edx
  37.     L0008: mov edi, r8d
  38.     L000b: mov rcx, 0x7ffec35e2360
  39.     L0015: mov edx, 0x6
  40.     L001a: call 0x7fff230847e0
  41.     L001f: mov [rax+0x10], sil
  42.     L0023: mov edx, esi
  43.     L0025: sar edx, 0x8
  44.     L0028: mov [rax+0x11], dl
  45.     L002b: mov edx, esi
  46.     L002d: sar edx, 0x10
  47.     L0030: mov [rax+0x12], dl
  48.     L0033: sar esi, 0x18
  49.     L0036: mov [rax+0x13], sil
  50.     L003a: movsx rdx, di
  51.     L003e: mov [rax+0x14], dl
  52.     L0041: sar edx, 0x8
  53.     L0044: mov [rax+0x15], dl
  54.     L0047: add rsp, 0x28
  55.     L004b: pop rsi
  56.     L004c: pop rdi
  57.     L004d: ret

正如您所看到的，这两个版本的复杂性差别很小，只是使用BinaryPrimitives的版本有一些范围检查（这不是坏事）。
请注意，JIT现在是多层的，我认为SharpLab只显示第一层的结果，所以如果它在热路径上，这可能会得到很好的改善。
SharpLab链接
我还使用BenchmarkDotNet运行了一个基准测试：

  1. public class MyBenchmark
  2. {
  3.     private byte[] buffer = new byte[32];
  5.     [Benchmark]
  6.     public void PopulateBufferLESpan()
  7.     {
  8.         PopulateBufferLESpanImpl(1, 2, 3, 4);
  9.     }
  11.     [Benchmark]
  12.     public void PopulateBufferLEExplicit()
  13.     {
  14.         PopulateBufferLEExplicitImpl(1, 2, 3, 4);
  15.     }
  17.     [Benchmark]
  18.     public void PopulateBufferBESpan()
  19.     {
  20.         PopulateBufferBESpanImpl(1, 2, 3, 4);
  21.     }
  23.     [Benchmark]
  24.     public void PopulateBufferBEExplicit()
  25.     {
  26.         PopulateBufferBEExplicitImpl(1, 2, 3, 4);
  27.     }
  29.     private void PopulateBufferLESpanImpl(int i1, int i2, short s1, short s2)
  30.     {
  31.         var span = new Span<byte>(buffer);
  32.         BinaryPrimitives.WriteInt32LittleEndian(span.Slice(0, 4), i1);
  33.         BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4, 4), i2);
  34.         BinaryPrimitives.WriteInt16LittleEndian(span.Slice(8, 2), s1);
  35.         BinaryPrimitives.WriteInt16LittleEndian(span.Slice(10, 2), s2);
  36.     }
  38.     private void PopulateBufferLEExplicitImpl(int i1, int i2, short i3, short i4)
  39.     {
  40.         buffer[0] = (byte)(i1 & 0xFF);
  41.         buffer[1] = (byte)((i1 >> 8) & 0xFF);
  42.         buffer[2] = (byte)((i1 >> 16) & 0xFF);
  43.         buffer[3] = (byte)((i1 >> 24) & 0xFF);
  44.         buffer[4] = (byte)(i2 & 0xFF);
  45.         buffer[5] = (byte)((i2 >> 8) & 0xFF);
  46.         buffer[6] = (byte)((i2 >> 16) & 0xFF);
  47.         buffer[7] = (byte)((i2 >> 24) & 0xFF);
  48.         buffer[8] = (byte)(i3 & 0xFF);
  49.         buffer[9] = (byte)((i3 >> 8) & 0xFF);
  50.         buffer[10] = (byte)(i4 & 0xFF);
  51.         buffer[11] = (byte)((i4 >> 8) & 0xFF);
  52.     }
  54.     private void PopulateBufferBESpanImpl(int i1, int i2, short s1, short s2)
  55.     {
  56.         var span = new Span<byte>(buffer);
  57.         BinaryPrimitives.WriteInt32BigEndian(span.Slice(0, 4), i1);
  58.         BinaryPrimitives.WriteInt32BigEndian(span.Slice(4, 4), i2);
  59.         BinaryPrimitives.WriteInt16BigEndian(span.Slice(8, 2), s1);
  60.         BinaryPrimitives.WriteInt16BigEndian(span.Slice(10, 2), s2);
  61.     }
  63.     private void PopulateBufferBEExplicitImpl(int i1, int i2, short i3, short i4)
  64.     {
  65.         buffer[0] = (byte)((i1 >> 24) & 0xFF);
  66.         buffer[1] = (byte)((i1 >> 16) & 0xFF);
  67.         buffer[2] = (byte)((i1 >> 8) & 0xFF);
  68.         buffer[3] = (byte)(i1 & 0xFF);
  69.         buffer[4] = (byte)((i2 >> 24) & 0xFF);
  70.         buffer[5] = (byte)((i2 >> 16) & 0xFF);
  71.         buffer[6] = (byte)((i2 >> 24) & 0xFF);
  72.         buffer[7] = (byte)(i2 & 0xFF);
  73.         buffer[8] = (byte)((i3 >> 8) & 0xFF);
  74.         buffer[9] = (byte)(i3 & 0xFF);
  75.         buffer[10] = (byte)((i4 >> 8) & 0xFF);
  76.         buffer[11] = (byte)(i4 & 0xFF);
  77.     }

结果如下：

  1. BenchmarkDotNet=v0.11.5, OS=Windows 10.0.16299.1565 (1709/FallCreatorsUpdate/Redstone3)
  2. Intel Core i7-8650U CPU 1.90GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
  3. Frequency=2062501 Hz, Resolution=484.8482 ns, Timer=TSC
  4. .NET Core SDK=3.0.100
  5.   [Host]     : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
  6.   DefaultJob : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), 64bit RyuJIT
  8. |                   Method |     Mean |     Error |    StdDev |   Median |
  9. |------------------------- |---------:|----------:|----------:|---------:|
  10. |     PopulateBufferLESpan | 1.772 ns | 0.0629 ns | 0.0558 ns | 1.745 ns |
  11. | PopulateBufferLEExplicit | 3.698 ns | 0.0689 ns | 0.0576 ns | 3.688 ns |
  12. |     PopulateBufferBESpan | 2.532 ns | 0.0791 ns | 0.0740 ns | 2.531 ns |
  13. | PopulateBufferBEExplicit | 4.003 ns | 0.1106 ns | 0.2951 ns | 3.872 ns |

也许令人惊讶的是，基于Span的方法比位操作快得多，这可能是因为x86是little-endian，BinaryPrimitives意识到它可以直接将值位块传输到数组中，而无需单独提取和分配每个字节，但BE变体也显示出相当大的差异。

展开查看全部
赞(0）分享  回复(0）举报  2023-01-22
byqmnocz

byqmnocz2#

Span s是一个ref struct类型。创建span将创建非常简洁的对象，引用原始数组和您声明的范围的开始到结束位置。
Span、ReadOnlySpan和Memory是专门为更好地处理序列（尤其是内存/字节序列）而引入的。
你可以把Spans看作数组段指针。创建、复制和访问这种指针结构的成本相对较低。当操作它时，你仍然在原始的底层数组上操作。（不使用额外的数组示例。）
你提到了位移位，我想你的意思是作为BinaryPrimitives.WriteInt32LittleEndian的替代品。
如果不使用 * WriteInt 32 * 方法，而是手动提取四个字节，并按索引将它们设置到数组中，则会投入多个位操作，并可能破坏线性向量操作，而这些操作可以通过SIMD指令、分支预测和缓存进行CPU优化。
很难预测哪种方法性能更好，为了确定性能差异，您必须专门测试您的用例。
通常，使用Span不是一个昂贵的操作，使用标准库提供的方法更可取[而不是手动复制它们的行为]。

赞(0）分享  回复(0）举报  2023-01-22
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com