背景
我想要创建一些整数大小的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 |
问题
对我来说,基准测试结果令人惊讶,因此我有一些问题:
编辑:在修改代码以实际使用变量后,剩下的问题更少了。
- 为什么指针操作如此缓慢?
- 为什么强制类型转换需要比基准情况慢两倍?难道隐式/显式运算符没有被内联吗?
- 为什么新的
System.Runtime.CompilerServices.Unsafe
包(v. 4.5.0)如此快?我原以为它至少会涉及一个方法调用... - 更一般地说,我如何创建基本上是零成本结构的东西,简单地作为"窗口"进入某些内存或一个类似于
UInt64
这样的大型原始类型,以便我可以更有效地操作/读取该内存?这里有什么最佳实践?
Memory<T>
、Span<T>
等语言功能被添加的全部原因。 - Matthew Watsonif
操作(比如throw
),或者将值添加到一个static
变量或类似的东西中。 - xanatosstatic
变量是最好的方法。编译器或JIT没有简单的方法来删除对静态变量的写入(显示没有人使用它非常非常困难)。 - xanatos