logo标签列表

为什么通过指针转换结构体很慢，而使用Unsafe.As就很快？

c#performancestructunsafec#-7.2
13

背景

我想要创建一些整数大小的struct（即32位和64位），方便地可转换为/从相同大小的原始不受管控类型（例如对于特定的32位结构体，为Int32和UInt32）。

然后这些结构体将公开其他用于位操作/索引的功能，这些功能不能直接在整数类型上使用。基本上，这是一种语法糖，提高了可读性和易用性。

但是，重要的部分是性能，这样额外的抽象应该没有任何成本（最终，CPU 应该“看到”与处理原始 int 类型相同的位）。

示例结构体

下面只是我想到的非常基本的struct。它并没有所有功能，但足以说明我的问题：

[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 4)]
public struct Mask32 {
  [FieldOffset(3)]
  public byte Byte1;
  [FieldOffset(2)]
  public ushort UShort1;
  [FieldOffset(2)]
  public byte Byte2;
  [FieldOffset(1)]
  public byte Byte3;
  [FieldOffset(0)]
  public ushort UShort2;
  [FieldOffset(0)]
  public byte Byte4;

  [DebuggerStepThrough, MethodImpl(MethodImplOptions.AggressiveInlining)]
  public static unsafe implicit operator Mask32(int i) => *(Mask32*)&i;
  [DebuggerStepThrough, MethodImpl(MethodImplOptions.AggressiveInlining)]
  public static unsafe implicit operator Mask32(uint i) => *(Mask32*)&i;
}

测试

我想测试这个结构体的性能。特别是，我想看看它是否能让我像使用常规的位运算一样快速地获取单个字节：(i >> 8) & 0xFF（例如获取第三个字节）。

下面是我设计的基准测试：

public unsafe class MyBenchmark {

  const int count = 50000;

  [Benchmark(Baseline = true)]
  public static void Direct() {
    var j = 0;
    for (int i = 0; i < count; i++) {
      //var b1 = i.Byte1();
      //var b2 = i.Byte2();
      var b3 = i.Byte3();
      //var b4 = i.Byte4();
      j += b3;
    }
  }


  [Benchmark]
  public static void ViaStructPointer() {
    var j = 0;
    int i = 0;
    var s = (Mask32*)&i;
    for (; i < count; i++) {
      //var b1 = s->Byte1;
      //var b2 = s->Byte2;
      var b3 = s->Byte3;
      //var b4 = s->Byte4;
      j += b3;
    }
  }

  [Benchmark]
  public static void ViaStructPointer2() {
    var j = 0;
    int i = 0;
    for (; i < count; i++) {
      var s = *(Mask32*)&i;
      //var b1 = s.Byte1;
      //var b2 = s.Byte2;
      var b3 = s.Byte3;
      //var b4 = s.Byte4;
      j += b3;
    }
  }

  [Benchmark]
  public static void ViaStructCast() {
    var j = 0;
    for (int i = 0; i < count; i++) {
      Mask32 m = i;
      //var b1 = m.Byte1;
      //var b2 = m.Byte2;
      var b3 = m.Byte3;
      //var b4 = m.Byte4;
      j += b3;
    }
  }

  [Benchmark]
  public static void ViaUnsafeAs() {
    var j = 0;
    for (int i = 0; i < count; i++) {
      var m = Unsafe.As<int, Mask32>(ref i);
      //var b1 = m.Byte1;
      //var b2 = m.Byte2;
      var b3 = m.Byte3;
      //var b4 = m.Byte4;
      j += b3;
    }
  }

}

Byte1(), Byte2(), Byte3(), 和 Byte4() 都是扩展方法，它们会被 内联 调用并且通过位运算和类型转换来获取第n个字节：

[DebuggerStepThrough, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static byte Byte1(this int it) => (byte)(it >> 24);
[DebuggerStepThrough, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static byte Byte2(this int it) => (byte)((it >> 16) & 0xFF);
[DebuggerStepThrough, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static byte Byte3(this int it) => (byte)((it >> 8) & 0xFF);
[DebuggerStepThrough, MethodImpl(MethodImplOptions.AggressiveInlining)]
public static byte Byte4(this int it) => (byte)it;

编辑：修复了代码，确保变量实际上被使用。同时注释掉4个变量中的3个以真正测试结构体转换/成员访问而不是实际使用变量。

结果

我在启用优化的x64 Release版本中运行了这些代码。

Intel Core i7-3770K CPU 3.50GHz (Ivy Bridge), 1 CPU, 8 logical cores and 4 physical cores
Frequency=3410223 Hz, Resolution=293.2360 ns, Timer=TSC
  [Host]     : .NET Framework 4.6.1 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.6.1086.0
  DefaultJob : .NET Framework 4.6.1 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.6.1086.0


            Method |      Mean |     Error |    StdDev | Scaled | ScaledSD |
------------------ |----------:|----------:|----------:|-------:|---------:|
            Direct |  14.47 us | 0.3314 us | 0.2938 us |   1.00 |     0.00 |
  ViaStructPointer | 111.32 us | 0.6481 us | 0.6062 us |   7.70 |     0.15 |
 ViaStructPointer2 | 102.31 us | 0.7632 us | 0.7139 us |   7.07 |     0.14 |
     ViaStructCast |  29.00 us | 0.3159 us | 0.2800 us |   2.01 |     0.04 |
       ViaUnsafeAs |  14.32 us | 0.0955 us | 0.0894 us |   0.99 |     0.02 |

编辑：修复代码后的新结果：

            Method |      Mean |     Error |    StdDev | Scaled | ScaledSD |
------------------ |----------:|----------:|----------:|-------:|---------:|
            Direct |  57.51 us | 1.1070 us | 1.0355 us |   1.00 |     0.00 |
  ViaStructPointer | 203.20 us | 3.9830 us | 3.5308 us |   3.53 |     0.08 |
 ViaStructPointer2 | 198.08 us | 1.8411 us | 1.6321 us |   3.45 |     0.06 |
     ViaStructCast |  79.68 us | 1.5478 us | 1.7824 us |   1.39 |     0.04 |
       ViaUnsafeAs |  57.01 us | 0.8266 us | 0.6902 us |   0.99 |     0.02 |

问题

对我来说，基准测试结果令人惊讶，因此我有一些问题：

编辑：在修改代码以实际使用变量后，剩下的问题更少了。

  1. 为什么指针操作如此缓慢？
  2. 为什么强制类型转换需要比基准情况慢两倍？难道隐式/显式运算符没有被内联吗？
  3. 为什么新的 System.Runtime.CompilerServices.Unsafe 包（v. 4.5.0）如此快？我原以为它至少会涉及一个方法调用...
  4. 更一般地说，我如何创建基本上是零成本结构的东西，简单地作为"窗口"进入某些内存或一个类似于UInt64这样的大型原始类型，以便我可以更有效地操作/读取该内存？这里有什么最佳实践？
1
如果您能发布一个可编译的控制台应用程序，那就太好了。目前这些内容无法编译，我想大多数人都不会花时间来修复它... - Matthew Watson
1
我尝试了你的几个测试方法，编译器会删除循环中的代码，因为循环中的变量没有被使用。因此我怀疑你的测试是没有意义的。 - Matthew Watson
2
@Claies C# 在这方面非常高效 - 能够以与未管理程序相同的速度完成任务非常好。这也是新的 Memory<T>、Span<T> 等语言功能被添加的全部原因。 - Matthew Watson
1
@FitDev 你还在进行没有副作用的操作。仅仅修改一个本地变量并不会引起副作用。一个聪明的编译器可以将其全部删除。它的运作方式是：如果一个本地变量被写入但没有被读取，那么它就是无用的，可以被删除。你需要进行带有副作用的 if 操作（比如 throw），或者将值添加到一个 static 变量或类似的东西中。 - xanatos
1
@FitDev 另一个解决方案是像Matthew Watson在他的代码中所做的那样：返回具有值的局部变量。然后，代码就不能被简单地删除（但从技术上讲，JIT可以进行激进的内联并删除所有内容，因为即使他不使用返回值）。static变量是最好的方法。编译器或JIT没有简单的方法来删除对静态变量的写入（显示没有人使用它非常非常困难）。 - xanatos
显示剩余11条评论
2个回答
15
答案似乎是，当您使用Unsafe.As()时，JIT编译器可以进行某些优化。 Unsafe.As()的实现非常简单，像这样：
public static ref TTo As<TFrom, TTo>(ref TFrom source)
{
    return ref source;
}

就是这样！

以下是我编写的一个测试程序，用于与强制转换进行比较：

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace Demo
{
    [StructLayout(LayoutKind.Explicit, Pack = 1, Size = 4)]
    public struct Mask32
    {
        [FieldOffset(3)]
        public byte Byte1;
        [FieldOffset(2)]
        public ushort UShort1;
        [FieldOffset(2)]
        public byte Byte2;
        [FieldOffset(1)]
        public byte Byte3;
        [FieldOffset(0)]
        public ushort UShort2;
        [FieldOffset(0)]
        public byte Byte4;
    }

    public static unsafe class Program
    {
        static int count = 50000000;

        public static int ViaStructPointer()
        {
            int total = 0;

            for (int i = 0; i < count; i++)
            {
                var s = (Mask32*)&i;
                total += s->Byte1;
            }

            return total;
        }

        public static int ViaUnsafeAs()
        {
            int total = 0;

            for (int i = 0; i < count; i++)
            {
                var m = Unsafe.As<int, Mask32>(ref i);
                total += m.Byte1;
            }

            return total;
        }

        public static void Main(string[] args)
        {
            var sw = new Stopwatch();

            sw.Restart();
            ViaStructPointer();
            Console.WriteLine("ViaStructPointer took " + sw.Elapsed);

            sw.Restart();
            ViaUnsafeAs();
            Console.WriteLine("ViaUnsafeAs took " + sw.Elapsed);
        }
    }
}

我在我的电脑上（x64 发布版本）得到的结果如下：

ViaStructPointer took 00:00:00.1314279
ViaUnsafeAs took 00:00:00.0249446

正如您所看到的，ViaUnsafeAs确实更快。

那么让我们来看看编译器生成了什么：

public static unsafe int ViaStructPointer()
{
    int total = 0;
    for (int i = 0; i < Program.count; i++)
    {
        total += (*(Mask32*)(&i)).Byte1;
    }
    return total;
}

public static int ViaUnsafeAs()
{
    int total = 0;
    for (int i = 0; i < Program.count; i++)
    {
        total += (Unsafe.As<int, Mask32>(ref i)).Byte1;
    }
    return total;
}

好的，这里没有明显的问题。但是关于IL呢？

.method public hidebysig static int32 ViaStructPointer () cil managed 
{
    .locals init (
        [0] int32 total,
        [1] int32 i,
        [2] valuetype Demo.Mask32* s
    )

    IL_0000: ldc.i4.0
    IL_0001: stloc.0
    IL_0002: ldc.i4.0
    IL_0003: stloc.1
    IL_0004: br.s IL_0017
    .loop
    {
        IL_0006: ldloca.s i
        IL_0008: conv.u
        IL_0009: stloc.2
        IL_000a: ldloc.0
        IL_000b: ldloc.2
        IL_000c: ldfld uint8 Demo.Mask32::Byte1
        IL_0011: add
        IL_0012: stloc.0
        IL_0013: ldloc.1
        IL_0014: ldc.i4.1
        IL_0015: add
        IL_0016: stloc.1

        IL_0017: ldloc.1
        IL_0018: ldsfld int32 Demo.Program::count
        IL_001d: blt.s IL_0006
    }

    IL_001f: ldloc.0
    IL_0020: ret
}

.method public hidebysig static int32 ViaUnsafeAs () cil managed 
{
    .locals init (
        [0] int32 total,
        [1] int32 i,
        [2] valuetype Demo.Mask32 m
    )

    IL_0000: ldc.i4.0
    IL_0001: stloc.0
    IL_0002: ldc.i4.0
    IL_0003: stloc.1
    IL_0004: br.s IL_0020
    .loop
    {
        IL_0006: ldloca.s i
        IL_0008: call valuetype Demo.Mask32& [System.Runtime.CompilerServices.Unsafe]System.Runtime.CompilerServices.Unsafe::As<int32, valuetype Demo.Mask32>(!!0&)
        IL_000d: ldobj Demo.Mask32
        IL_0012: stloc.2
        IL_0013: ldloc.0
        IL_0014: ldloc.2
        IL_0015: ldfld uint8 Demo.Mask32::Byte1
        IL_001a: add
        IL_001b: stloc.0
        IL_001c: ldloc.1
        IL_001d: ldc.i4.1
        IL_001e: add
        IL_001f: stloc.1

        IL_0020: ldloc.1
        IL_0021: ldsfld int32 Demo.Program::count
        IL_0026: blt.s IL_0006
    }

    IL_0028: ldloc.0
    IL_0029: ret
}

啊哈！这里唯一的区别就是：

ViaStructPointer: conv.u
ViaUnsafeAs:      call valuetype Demo.Mask32& [System.Runtime.CompilerServices.Unsafe]System.Runtime.CompilerServices.Unsafe::As<int32, valuetype Demo.Mask32>(!!0&)
                  ldobj Demo.Mask32

乍一看，您会期望conv.u比用于Unsafe.As的两个指令更快。然而，JIT编译器似乎能够比单个conv.u更好地优化这两个指令。
询问“为什么”是合理的-不幸的是我还没有答案！我几乎可以肯定，JITTER内联了对Unsafe::As<>()的调用，并且JIT进一步优化了它。 这里有一些关于Unsafe类优化的信息。 请注意，Unsafe.As<>生成的IL仅为：
.method public hidebysig static !!TTo& As<TFrom, TTo> (
        !!TFrom& source
    ) cil managed aggressiveinlining 
{
    .custom instance void System.Runtime.Versioning.NonVersionableAttribute::.ctor() = (
        01 00 00 00
    )
    IL_0000: ldarg.0
    IL_0001: ret
}

现在我认为，这就更清楚了，为什么JITTER可以进行如此优化。
非常感谢您详尽的回答和建议！那么，您是否认为依赖于 Unsafe.As<> 以提高性能并通常避免使用指针进行转换，这是一个安全的选择（关于 .NET Framework 4.6.1+ 和 .NET Core 2+）？ - Fit Dev
@FitDev 是的，我也这么认为；他们正是为了那种目的而设计它的！ - Matthew Watson
@MatthewWatson 我查看了源代码并发现了这个：Unsafe.cs,88。为什么他们抛出异常而不是返回值呢？ - aloisdg
@aloisdg 因为该平台不支持此功能。 - Matthew Watson
2
@MatthewWatson，这难道不是因为它们是内置函数（请参见每个方法上的属性）吗？方法的主体将被JIT /执行环境替换（或者至少我是这样理解的）。请参见该链接顶部的注释。 - pinkfloydx33
函数 public static ref TTo As<TFrom, TTo>(ref TFrom source) 是内置的，不能像您建议的那样实现。返回类型是错误的。该函数在CLR中实现。 - Jens Munk
14

当你获取本地变量的地址时，JIT 通常需要将该本地变量保留在堆栈上。这里就是这种情况。在 ViaPointer 版本中，i 保留在堆栈上。在 ViaUnsafe 版本中，i 被复制到一个临时变量中，并将临时变量保留在堆栈上。前者比较慢，因为 i 还用于控制循环的迭代。

您可以通过以下代码来显式地进行复制，从而接近于 ViaUnsafe 的性能：

    public static int ViaStructPointer2()
    {
        int total = 0;

        for (int i = 0; i < count; i++)
        {
            int j = i;
            var s = (Mask32*)&j;
            total += s->Byte1;
        }

        return total;
    }

ViaStructPointer  took 00:00:00.1147793
ViaUnsafeAs       took 00:00:00.0282828
ViaStructPointer2 took 00:00:00.0257589
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接