C# 使用SIMD向量类型加速浮点数组求和运算（4）：用引用代替指针, 摆脱unsa
作者： zyl910目录
[*]一、引言
[*]二、办法说明
[*]2.1 历史
[*]2.2 局部引用变量与引用所指的值（类似指针的 地址运算符&、间接运算符*）
[*]2.3 重新分配局部引用变量（类似指针直接赋值）
[*]2.4 引用地址调整（类似指针加减法）
[*]2.5 引用地址比较（类似指针比较）
[*]2.6 重新解释（类似C++的 reinterpret_cast）
[*]2.7 引用取消只读（类似C++的 const_cast）
[*]三、将指针代码改写为引用代码
[*]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;
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;
*element = 1;
Display(xs);
element = &xs[(sizeof(xs)/sizeof(xs))-1];
*element = 3;
Display(xs);规律是——
[*]=的右边若有“ref”关键字：更改引用的指向。类似指针直接赋值。
[*]=的右边若没有“ref”关键字：设置其指向的值。类似指针的 间接运算符*。
上述示例中，演示了引用对数组的访问。C#中的指针若想访问数组，一般得使用fixed关键字，而引用不用。
注：上述示例还用到了C# 8.0 的一个特性—— 从末尾开始索引运算符^。^1 就是指末尾的最后1个元素，于是在C语言中是 (sizeof(xs)/sizeof(xs))-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; // 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;
// 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) {
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;
p += nBlockWidth;
}
// Remainder processs.
for (i = 0; i < cntRem; ++i) {
rt += p;
}
}
}
// 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); // Pointer for src data.
// Vector processs.
for (i = 0; i < cntBlock; ++i) {
vrt = Avx.Add(vrt, p0); // Add. vrt += vsrc;
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 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: 2.1990233E+12 # msUsed=531, MFLOPS/s=7713.747645951035, scale=9.210922787193974
SumVectorAvxPtrUX: 4.3980465E+12 # msUsed=500, MFLOPS/s=8192, scale=9.782
SumVectorAvxPtrUX: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 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》. https://www.cnblogs.com/zyl910/p/dotnet_simd_BenchmarkVector1.html
[*]zyl910《C# 使用SIMD向量类型加速浮点数组求和运算（2）：C#通过Intrinsic直接使用AVX指令集操作 Vector256，及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
出处：http://www.cnblogs.com/zyl910/ 版权声明：自由转载-非商用-非衍生-保持署名 | Creative Commons BY-NC-ND 3.0.
来源:https://www.cnblogs.com/zyl910/archive/2023/07/30/dotnet_simd_BenchmarkVector4.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！
页:
[1]