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

作者： zyl910

一、引言
二、办法说明
三、将指针代码改写为引用代码
- 3.1 代码编写
- 3.2 测试结果
四、小结
参考文献

一、引言

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

事先将基元类型数组转为了向量类型数组（SumVectorAvx）.
使用Span改进数据加载（SumVectorAvxSpan）.
使用指针改进数据加载（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)

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

ref int alias与C语言的int* alias: 声明变量时，类型的前面可加上“ref”关键字，表示它是引用类型。类似C语言的变量类型加“*”，表示它是指针类型。
alias = ref a与C语言的alias = &a: 将引用指向某个变量时，需要给右式中变量的前面加上“ref”关键字。类似指针的地址运算符&。
赋值时的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 Files\dotnet\shared\Microsoft.NETCore.App\3.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

参考文献

《Span<T> needs to be support long length and indices #896》. https://github.com/dotnet/corefxlab/issues/896
Microsoft《unsafe（C# 参考）》. https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/unsafe
Microsoft《C# 发展历史》. https://learn.microsoft.com/zh-cn/dotnet/csharp/whats-new/csharp-version-history
Microsoft《Unsafe 类》. https://learn.microsoft.com/zh-cn/dotnet/api/system.runtime.compilerservices.unsafe?view=netcore-3.0
Microsoft《Span.cs》. https://github.com/dotnet/coreclr/blob/master/src/System.Private.CoreLib/shared/System/Span.cs
zyl910《C# 使用SIMD向量类型加速浮点数组求和运算（1）：使用Vector4、Vector<T>》. https://www.cnblogs.com/zyl910/p/dotnet_simd_BenchmarkVector1.html
zyl910《C# 使用SIMD向量类型加速浮点数组求和运算（2）：C#通过Intrinsic直接使用AVX指令集操作 Vector256<T>，及C++程序对比》. https://www.cnblogs.com/zyl910/p/dotnet_simd_BenchmarkVector2.html
zyl910《C# 使用SIMD向量类型加速浮点数组求和运算（3）：循环展开》. https://www.cnblogs.com/zyl910/p/dotnet_simd_BenchmarkVector3.html

posted on 2023-07-30 15:04 zyl910 阅读(413) 评论(2) 编辑收藏举报

刷新页面返回顶部

zyl910

公告