C# 使用SIMD向量类型加速浮点数组求和运算（4）：用引用代替指针, 摆脱unsafe关键字，兼谈Unsafe类的使用

  • C# 使用SIMD向量类型加速浮点数组求和运算（4）：用引用代替指针, 摆脱unsafe关键字，兼谈Unsafe类的使用已关闭评论
  • 111 次浏览
  • A+
所属分类：.NET技术
摘要

作者： zyl910C#没有直接提供对数据进行重新解释（C++的 reinterpret_cast）的功能，而在使用向量类型时，经常需要做这种操作。例如 第2篇文章，用了3种办法——
便宜好用的国外VPS推荐

作者： zyl910

一、引言

C#没有直接提供对数据进行重新解释（C++的 reinterpret_cast）的功能，而在使用向量类型时，经常需要做这种操作。例如 第2篇文章，用了3种办法——

  1. 事先将基元类型数组转为了向量类型数组（SumVectorAvx）.
  2. 使用Span改进数据加载（SumVectorAvxSpan）.
  3. 使用指针改进数据加载（SumVectorAvxPtr）.

第1种办法其实是将全部数据搬运了一遍，开销大。不适合生产使用，仅能用于教学演示。
剩下2种办法虽然能用，但还是存在一些缺点的——

  • Span：Span的长度（Length）是32位有符号整数（Int32），且索引一般不能为负数，导致它的地址范围只有31位，难以处理超过2GB的数据。而现在64位平台已经普及了，有时存在“处理超过2GB的数据”的需求。官方说了“我们决定将其保留为 int”（We decided to keep it as an int），Span的位数升级无望。
  • 指针：虽然在C#中能够使用指针语法，但是只能在用unsafe关键字申明的“非安全代码”里使用，且项目配置里需启用“允许非安全代码”（Allow unsafe code），使用比较繁琐。而且对于开发类库等严格审查的场合，有时会规定不启用“允许非安全代码”。其次C#的指针还存在 “不支持泛型”、“有时需要fixed”等缺点。

有没有更好的办法呢？

二、办法说明

最开始毫无头绪，直到我分析了Span的源码后，才发现C#如今能用引用来做重新解释，从而解决上述难题。
而且如今引用的功能非常强大，能完全代替指针操作，且能摆脱unsafe关键字。适合不启用“允许非安全代码”等严格的场合。

2.1 历史

C# 1.0 就支持了“ref”关键字，但仅能用于参数列表，用来表示“引用方式传参”。
C# 7.0 新增了“局部引用和引用返回”（Ref locals and returns）特性。自此C#的引用（ref）与C++的引用（&），功能很接近了.
C# 7.3 新增了“重新分配局部引用变量”（Reassign ref local variables）特性。C#的引用（ref）与C++的引用（&），几乎功能一致了.
再加上Unsafe类提供了 引用地址调整、引用地址比较、重新解释（C++的 reinterpret_cast）、引用取消只读（类似C++的 const_cast） 等功能. 使得C# 引用（ref）非常强大，能够完全代替指针（*）操作，彻底摆脱unsafe关键字。
引用比指针还多了这些优点——

  • 指针不支持泛型，而引用是支持泛型的。
  • 指针有时需要fixed，而引用无需使用fixed。

可以简单理解为这样——如今C#里的引用，比指针的功能更强大。
于是在一些官方文档中，将引用（ref）称呼为“托管指针”（Managed pointer）；并将传统的指针（*），称呼为“非托管指针”（Unmanaged pointer）。

2.2 局部引用变量与引用所指的值（类似指针的 地址运算符&、间接运算符*）

摘自官方文档。

https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/statements/declarations#reference-variables Reference 变量 声明局部变量并在变量类型之前添加 ref 关键字时，声明 reference 变量，或 ref 局部变量： ref int alias = ref variable;  reference 变量是引用另一个变量（称为引用）的变量。 也就是说，reference 变量是其引用的别名。 向 reference 变量赋值时，该值将分配给引用。 读取 reference 变量的值时，将返回引用的值。 以下示例演示了该行为： int a = 1; ref int alias = ref a; Console.WriteLine($"(a, alias) is ({a}, {alias})");  // output: (a, alias) is (1, 1) a = 2; Console.WriteLine($"(a, alias) is ({a}, {alias})");  // output: (a, alias) is (2, 2) alias = 3; Console.WriteLine($"(a, alias) is ({a}, {alias})");  // output: (a, alias) is (3, 3)

上述代码对应的C语言版代码如下。

int a = 1; int* alias = &a; printf("(a, alias) is (%d, %d)", a, *alias);	// output: (a, alias) is (1, 1) a = 2; printf("(a, alias) is (%d, %d)", a, *alias);	// output: (a, alias) is (2, 2) *alias = 3; printf("(a, alias) is (%d, %d)", a, *alias);	// output: (a, alias) is (3, 3)

主要是以下几点的写法不同：

  1. ref int alias与C语言的int* alias: 声明变量时，类型的前面可加上“ref”关键字，表示它是引用类型。类似C语言的变量类型加“*”，表示它是指针类型。
  2. alias = ref a与C语言的alias = &a: 将引用指向某个变量时，需要给右式中变量的前面加上“ref”关键字。类似指针的 地址运算符&。
  3. 赋值时的alias与C语言的*alias: 引用在直接赋值时，都是读取或设置其指向的值（并不是更改引用的指向）。而指针须使用 间接运算符*。

引用可以直接用“.”运算符来访问成员，不像指针那样还需使用“指针成员访问运算符->”。

2.3 重新分配局部引用变量（类似指针直接赋值）

上面提到引用在直接赋值时，都是读取或设置其指向的值。那么怎样才能更改引用的指向呢？
C# 7.3 新增了“重新分配局部引用变量”（Reassign ref local variables）特性，能够实现该功能。
摘自官方文档:

使用 ref 赋值运算符= ref 更改 reference 变量的引用，如以下示例所示：  void Display(int[] s) => Console.WriteLine(string.Join(" ", s));  int[] xs = { 0, 0, 0 }; Display(xs);  ref int element = ref xs[0]; element = 1; Display(xs);  element = ref xs[^1]; element = 3; Display(xs); // Output: // 0 0 0 // 1 0 0 // 1 0 3  在前面的示例中，element reference 变量初始化为第一个数组元素的别名。 然后，ref 将被重新分配，以引用最后一个数组元素。

上述代码对应的C语言版代码如下。

int[] xs = { 0, 0, 0 }; Display(xs);  int* element = &xs[0]; *element = 1; Display(xs);  element = &xs[(sizeof(xs)/sizeof(xs[0]))-1]; *element = 3; Display(xs);

规律是——

  • =的右边若有“ref”关键字：更改引用的指向。类似指针直接赋值。
  • =的右边若没有“ref”关键字：设置其指向的值。类似指针的 间接运算符*。

上述示例中，演示了引用对数组的访问。C#中的指针若想访问数组，一般得使用fixed关键字，而引用不用。
注：上述示例还用到了C# 8.0 的一个特性—— 从末尾开始索引运算符^。^1 就是指末尾的最后1个元素，于是在C语言中是 (sizeof(xs)/sizeof(xs[0]))-1 .

2.4 引用地址调整（类似指针加减法）

指针能通过加减法来调整地址，从而对一片连续的内存进行操作。
C#的引用也能够调整地址，故也能对一片连续的内存进行操作。Unsafe类提供了的Add等方法来调整引用的地址，例如以下方法。

Add<T>(T, Int32)	将偏移量添加到给定的托管指针。 Add<T>(T, IntPtr)	将元素偏移量添加到给定的托管指针。 AddByteOffset<T>(T, IntPtr)	将字节偏移量添加到给定的托管指针。 Subtract<T>(T, Int32)	从给定的托管指针中减去偏移量。 Subtract<T>(T, IntPtr)	从给定的托管指针中减去元素偏移量。 SubtractByteOffset<T>(T, IntPtr)	从给定的托管指针中减去字节偏移量。

带“ByteOffset”后缀的方法，是以字节为单位的。而没有该后缀的方法，是以元素大小为单位的，类似指针加减法。

2.5 引用地址比较（类似指针比较）

指针能够进行比较。
引用也能够进行比较。Unsafe类提供了的AreSame等方法来获得比较结果，例如以下方法。

AreSame<T>(T, T)	确定指定的托管指针是否指向同一位置。 IsAddressGreaterThan<T>(T, T)	返回一个值，该值指示指定的托管指针是否大于另一个指定的托管指针。 IsAddressLessThan<T>(T, T)	返回一个值，该值指示指定的托管指针是否小于另一个指定的托管指针。

2.6 重新解释（类似C++的 reinterpret_cast）

C++的 reinterpret_cast运算符能够对数据进行重新解释。且在C语言（或C#的非安全代码）中，可以通过对指针进行强制类型转换，从而对数据进行重新解释。
对于C#的引用，可以用Unsafe类的As方法对数据进行重新解释。
摘自官方文档。

As<TFrom,TTo>(TFrom) 将给定的托管指针重新解释为指向 TTo类型的新托管指针。  public static ref TTo As<TFrom,TTo> (ref TFrom source);  类型参数 TFrom	要重新解释的托管指针的类型。 TTo	托管指针的所需类型。  参数 source	TFrom	用于重新解释的托管指针。  返回 TTo	指向 TTo类型的新托管指针。  注解 此 API 在概念上类似于 C++ 的 `reinterpret_cast<>`。 调用方有责任确保强制转换是合法的。 不会执行运行时检查。 仅重新解释托管指针。 引用的值本身将保持不变。 请考虑以下示例。   int[] intArray = new int[] { 0x1234_5678 }; // a 1-element array ref int refToInt32 = ref intArray[0]; // managed pointer to first Int32 in array ref short refToInt16 = ref Unsafe.As<int, short>(ref refToInt32); // reinterpret as managed pointer to Int16 Console.WriteLine($"0x{refToInt16:x4}");  此程序的输出取决于当前计算机的端序。 在 big-endian 体系结构中，此代码输出 0x1234。 在 little-endian 体系结构上，此代码输出 0x5678。  将托管指针从较窄的类型转换为较宽的类型时，调用方必须确保取消引用指针不会产生超出边界的访问。 调用方还负责确保生成的指针正确对齐所引用的类型。 当将托管指针从较窄类型强制转换为较宽类型时，调用方必须确保对指针的解引用不会导致越界访问。调用者还负责确保结果指针为引用类型正确对齐。  有关对齐假设的详细信息，请参阅 ECMA-335，第 I.12.6.2 (“对齐”) 。

2.7 引用取消只读（类似C++的 const_cast）

在C#中可以用“ref readonly”定义只读引用。摘自官方文档。

可以定义 ref readonly 局部变量。 不能为 ref readonly 变量赋值。 但是，可以 ref 重新分配这样的 reference 变量，如以下示例所示：  int[] xs = { 1, 2, 3 };  ref readonly int element = ref xs[0]; // element = 100;  error CS0131: The left-hand side of an assignment must be a variable, property or indexer Console.WriteLine(element);  // output: 1  element = ref xs[^1]; Console.WriteLine(element);  // output: 3

可见，在使用“= ref”做引用赋值时，能方便的将“可变引用（ref）”赋值给“只读引用（ref readonly）”。因为将“能读写变量”限制为“只读变量”，是安全的。
但反向该如何做呢，即怎样将“只读引用（ref readonly）”转为“可变引用（ref）”？
虽然这个操作是不安全的，但是有些时候必须使用。类似C++提供const_cast运算法，能够去掉“const”。
Unsafe类的许多方法是仅支持“可变引用（ref）”的，例如“Add”等。当想对“只读引用（ref readonly）”使用Unsafe类的方法前，需要将“只读引用（ref readonly）”转为“可变引用（ref）”。

解决办法就是使用 Unsafe的AsRef方法。摘自官方文档。

AsRef<T>(T) 将给定的只读引用重新解释为可变引用。 public static ref T AsRef<T> (scoped in T source);  类型参数 T	引用的基础类型。  参数 source	T	要重新解释的只读引用。  返回 T	对类型的 T值的可变引用。  注解 此 API 在概念上类似于 C++的`const_cast<>`。调用方负责确保不会将数据写入引用的位置。 运行时包含基于只读引用真正不可变的假设的内部逻辑，违反此固定项的调用方可能会在运行时内触发未定义的行为。  AsRef 通常用于将只读引用传递给方法，例如 Add，接受可变托管指针作为参数。 请看下面的示例。  int ComputeSumOfElements(ref int refToFirstElement, nint numElements) {   int sum = 0;   for (nint i = 0; i < numElements; i++)   {     sum += Unsafe.Add(ref refToFirstElement, i);   } }  如果输入参数不是 `ref int refToFirstElement`, 而是 `ref readonly int refToFirstElement`，则上一个示例不会编译，因为不能将只读引用用作Add的参数。相反，AsRef 可用于删除不可变性约束并允许编译成功，如以下示例所示。  int ComputeSumOfElements(ref readonly int refToFirstElement, nint numElements) {   int sum = 0;   for (nint i = 0; i < numElements; i++)   {     sum += Unsafe.Add(ref Unsafe.AsRef(ref refToFirstElement), i);   } }

三、将指针代码改写为引用代码

3.1 代码编写

我们先来回顾一下指针版的代码。

private static float SumVectorAvxPtr(float[] src, int count, int loops) { #if Allow_Intrinsics && UNSAFE     unsafe {         float rt = 0; // Result.         int VectorWidth = Vector256<float>.Count; // Block width.         int nBlockWidth = VectorWidth; // Block width.         int cntBlock = count / nBlockWidth; // Block count.         int cntRem = count % nBlockWidth; // Remainder count.         Vector256<float> vrt = Vector256<float>.Zero; // Vector result.         Vector256<float> vload;         float* p; // Pointer for src data.         int i;         // Body.         fixed(float* p0 = &src[0]) {             for (int j = 0; j < loops; ++j) {                 p = p0;                 // Vector processs.                 for (i = 0; i < cntBlock; ++i) {                     vload = Avx.LoadVector256(p);    // Load. vload = *(*__m256)p;                     vrt = Avx.Add(vrt, vload);    // Add. vrt += vsrc[i];                     p += nBlockWidth;                 }                 // Remainder processs.                 for (i = 0; i < cntRem; ++i) {                     rt += p[i];                 }             }         }         // Reduce.         for (i = 0; i < VectorWidth; ++i) {             rt += vrt.GetElement(i);         }         return rt;     } #else     throw new NotSupportedException(); #endif }

利用本文上面的知识，可以去掉unsafe关键字，将指针改造为引用。代码如下。

private static float SumVectorAvxRef(float[] src, int count, int loops) { #if Allow_Intrinsics     float rt = 0; // Result.     int VectorWidth = Vector256<float>.Count; // Block width.     int nBlockWidth = VectorWidth; // Block width.     int cntBlock = count / nBlockWidth; // Block count.     int cntRem = count % nBlockWidth; // Remainder count.     Vector256<float> vrt = Vector256<float>.Zero; // Vector result.     int i;     // Body.     for (int j = 0; j < loops; ++j) {         ref Vector256<float> p0 = ref Unsafe.As<float, Vector256<float>> (ref src[0]); // Pointer for src data.         // Vector processs.         for (i = 0; i < cntBlock; ++i) {             vrt = Avx.Add(vrt, p0);    // Add. vrt += vsrc[i];             p0 = ref Unsafe.Add(ref p0, 1);         }         // Remainder processs.         ref float p = ref Unsafe.As<Vector256<float>, float>(ref p0);         for (i = 0; i < cntRem; ++i) {             rt += Unsafe.Add(ref p, i);         }     }     // Reduce.     for (i = 0; i < VectorWidth; ++i) {         rt += vrt.GetElement(i);     }     return rt; #else     throw new NotSupportedException(); #endif }

在向量处理（Vector processs）阶段，需要向量类型的引用，于是定义了 ref Vector256<float> p0。因为C#里访问的引用，会相当于访问所指向的值，类似自动使用了指针的“间接运算符*”。即给Avx.Add传递的p0，是符合参数要求的值。
在余数处理（Remainder processs）阶段，需要基元类型的引用，于是定义了 ref float p。由于向量处理的循环结束时，p0正好移动到首个余数的位置，所以可以用 Unsafe.As 进行重新解释，为p赋值（设置引用的指向）。

3.2 测试结果

在我的电脑（lntel(R) Core(TM) i5-8250U CPU @ 1.60GHz、Windows 10）上运行时，x64、Release版程序的输出信息为：

BenchmarkVectorCore30  IsRelease:      True EnvironmentVariable(PROCESSOR_IDENTIFIER):      Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Environment.ProcessorCount:     8 Environment.Is64BitOperatingSystem:     True Environment.Is64BitProcess:     True Environment.OSVersion:  Microsoft Windows NT 6.2.9200.0 Environment.Version:    3.0.3 RuntimeEnvironment.GetRuntimeDirectory: C:Program FilesdotnetsharedMicrosoft.NETCore.App3.0.3 RuntimeInformation.FrameworkDescription:        .NET Core 3.0.3 BitConverter.IsLittleEndian:    True IntPtr.Size:    8 Vector.IsHardwareAccelerated:   True Vector<byte>.Count:     32      # 256bit Vector<float>.Count:    8       # 256bit Vector<double>.Count:   4       # 256bit Vector4.Assembly.CodeBase:      file:///C:/Program Files/dotnet/shared/Microsoft.NETCore.App/3.0.3/System.Numerics.Vectors.dll Vector<T>.Assembly.CodeBase:    file:///C:/Program Files/dotnet/shared/Microsoft.NETCore.App/3.0.3/System.Private.CoreLib.dll  Benchmark:      count=4096, loops=1000000, countMFlops=4096 SumBase:        6.871948E+10    # msUsed=4891, MFLOPS/s=837.4565528521774 SumBaseU4:      2.748779E+11    # msUsed=1844, MFLOPS/s=2221.2581344902387, scale=2.65238611713666 SumVector4:     2.748779E+11    # msUsed=1219, MFLOPS/s=3360.1312551271535, scale=4.012305168170632 SumVector4U4:   1.0995116E+12   # msUsed=515, MFLOPS/s=7953.398058252427, scale=9.497087378640778 SumVectorT:     5.497558E+11    # msUsed=610, MFLOPS/s=6714.754098360656, scale=8.018032786885247 SumVectorTU4:   2.1990233E+12   # msUsed=187, MFLOPS/s=21903.74331550802, scale=26.155080213903744 SumVectorAvx:   5.497558E+11    # msUsed=609, MFLOPS/s=6725.7799671592775, scale=8.0311986863711 SumVectorAvxSpan:       5.497558E+11    # msUsed=610, MFLOPS/s=6714.754098360656, scale=8.018032786885247 SumVectorAvxRef:        5.497558E+11    # msUsed=609, MFLOPS/s=6725.7799671592775, scale=8.0311986863711 SumVectorAvxPtr:        5.497558E+11    # msUsed=610, MFLOPS/s=6714.754098360656, scale=8.018032786885247 SumVectorAvxU4: 2.1990233E+12   # msUsed=328, MFLOPS/s=12487.80487804878, scale=14.911585365853659 SumVectorAvxSpanU4:     2.1990233E+12   # msUsed=312, MFLOPS/s=13128.205128205129, scale=15.676282051282053 SumVectorAvxPtrU4:      2.1990233E+12   # msUsed=172, MFLOPS/s=23813.95348837209, scale=28.436046511627907 SumVectorAvxPtrU16:     8.386202E+12    # msUsed=188, MFLOPS/s=21787.23404255319, scale=26.01595744680851 SumVectorAvxPtrU16A:    8.3862026E+12   # msUsed=250, MFLOPS/s=16384, scale=19.564 SumVectorAvxPtrUX[4]:   2.1990233E+12   # msUsed=531, MFLOPS/s=7713.747645951035, scale=9.210922787193974 SumVectorAvxPtrUX[8]:   4.3980465E+12   # msUsed=500, MFLOPS/s=8192, scale=9.782 SumVectorAvxPtrUX[16]:  8.3862026E+12   # msUsed=484, MFLOPS/s=8462.809917355371, scale=10.105371900826446

可以看出 SumVectorAvxRef与SumVectorAvxPtr的性能几乎一致。引用版算法有时更快，可能是因为避免了fixed。
而且从“标准库中的Span是靠引用实现的”来看，.NET运行时在执行引用相关算法时，肯定是做了充足的编译优化的。使其能达到与指针版算法相当的性能。

四、小结

如今引用的功能非常强大，能完全代替指针操作，且能摆脱unsafe关键字。适合不启用“允许非安全代码”等严格的场合。

但需注意，引用有这些缺点——

  • 有些场合的编码比指针繁琐。例如用 Unsafe.As 做重新解释时，还需要写上源数据的类型。且不支持指针元素访问运算符 []，只能用Unsafe.Add等方法对地址进行调整。
  • Unsafe的方法一般是没有安全检查的，这样避免了性能损耗，但会留下一些安全隐患需开发者处理。若开发者处理不慎，会像开发指针代码那样易出现 地址越界、悬空指针 等Bug。故需要开发者有指针开发经验，细心避免bug。

源码地址——
https://github.com/zyl910/BenchmarkVector/tree/main/BenchmarkVector

参考文献

便宜好用的国外VPS推荐