笑嘻嘻的老爸 发表于 2023-7-30 14:51:29

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]
查看完整版本: C# 使用SIMD向量类型加速浮点数组求和运算(4):用引用代替指针, 摆脱unsa