Hau*_*aus 5 .net c# simd .net-core system.numerics
我试图通过利用System.Numerics在数组上执行 SIMD 操作来提高 .NET Core 库的性能float[]。System.Numerics现在有点时髦，我很难看出它有什么好处。我知道，为了看到 SIMD 的性能提升，必须通过大量计算进行摊销，但考虑到它目前的实现方式，我不知道如何实现这一点。
Vector<float>需要 8 个float值 - 不多也不少。如果我想对一组小于 8 的值执行 SIMD 运算，我必须将这些值复制到一个新数组，并用零填充余数。如果该组值大于 8，我需要复制这些值，用零填充以确保其长度与 8 的倍数对齐，然后循环它们。长度要求是有道理的，但适应这一点似乎是抵消任何性能增益的好方法。
我编写了一个测试包装类来处理填充和对齐：
public readonly struct VectorWrapper<T>
where T : unmanaged
{
#region Data Members
public readonly int Length;
private readonly T[] data_;
#endregion
#region Constructor
public VectorWrapper( T[] data )
{
Length = data.Length;
var stepSize = Vector<T>.Count;
var bufferedLength = data.Length - ( data.Length % stepSize ) + stepSize;
data_ = new T[ bufferedLength ];
data.CopyTo( data_, 0 );
}
#endregion
#region Public Methods
public T[] ToArray()
{
var returnData = new T[ Length ];
data_.AsSpan( 0, Length ).CopyTo( returnData );
return returnData;
}
#endregion
#region Operators
public static VectorWrapper<T> operator +( VectorWrapper<T> l, VectorWrapper<T> r )
{
var resultLength = l.Length;
var result = new VectorWrapper<T>( new T[ l.Length ] );
var lSpan = l.data_.AsSpan();
var rSpan = r.data_.AsSpan();
var stepSize = Vector<T>.Count;
for( var i = 0; i < resultLength; i += stepSize )
{
var lVec = new Vector<T>( lSpan.Slice( i ) );
var rVec = new Vector<T>( rSpan.Slice( i ) );
Vector.Add( lVec, rVec ).CopyTo( result.data_, i );
}
return result;
}
#endregion
}
这个包装器就可以解决这个问题。计算似乎是正确的，并且Vector<T>不会抱怨元素的输入计数。然而，它的速度是简单的基于范围的 for 循环的两倍。
这是基准：
public class VectorWrapperBenchmarks
{
#region Data Members
private static float[] arrayA;
private static float[] arrayB;
private static VectorWrapper<float> vecA;
private static VectorWrapper<float> vecB;
#endregion
#region Constructor
public VectorWrapperBenchmarks()
{
arrayA = new float[ 1024 ];
arrayB = new float[ 1024 ];
for( var i = 0; i < 1024; i++ )
arrayA[ i ] = arrayB[ i ] = i;
vecA = new VectorWrapper<float>( arrayA );
vecB = new VectorWrapper<float>( arrayB );
}
#endregion
[Benchmark]
public void ForLoopSum()
{
var aA = arrayA;
var aB = arrayB;
var result = new float[ 1024 ];
for( var i = 0; i < 1024; i++ )
result[ i ] = aA[ i ] + aB[ i ];
}
[Benchmark]
public void VectorSum()
{
var vA = vecA;
var vB = vecB;
var result = vA + vB;
}
}
结果：
| Method | Mean | Error | StdDev |
|----------- |-----------:|---------:|---------:|
| ForLoopSum | 757.6 ns | 15.67 ns | 17.41 ns |
| VectorSum | 1,335.7 ns | 17.25 ns | 16.13 ns |
我的处理器 (i7-6700k) 确实支持 SIMD 硬件加速，并且它在发布模式下运行，64 位，并在 .NET Core 2.2 (Windows 10) 上启用了优化。
我意识到这Array.CopyTo()可能是影响性能的很大一部分，但似乎没有简单的方法可以同时拥有填充/对齐和不明确符合Vector<T>规范的数据集。
我对 SIMD 相当陌生，并且我知道 C# 实现仍处于早期阶段。但是，我没有看到真正从中受益的明确方法，特别是考虑到扩展到更大的数据集时它是最有益的。
有更好的方法来解决这个问题吗？
小智 3
我\xc2\xb4m 不确定你所说的“时髦”是什么意思，但它\xc2\xb4s 现在完全可以使用（尽管它可能会更高效）。\n使用你的情况（求和浮点数）我得到了超过 10003 的以下结果带有旧 Haswell CPU 的物品：
\n\nBenchmarkDotNet=v0.11.5, OS=Windows 10.0.17134.706 (1803/April2018Update/Redstone4)\nIntel Core i7-4500U CPU 1.80GHz (Haswell), 1 CPU, 4 logical and 2 physical cores\nFrequency=1753753 Hz, Resolution=570.2057 ns, Timer=TSC\n.NET Core SDK=2.1.602\n [Host] : .NET Core 2.1.9 (CoreCLR 4.6.27414.06, CoreFX 4.6.27415.01), 64bit RyuJIT\n DefaultJob : .NET Core 2.1.9 (CoreCLR 4.6.27414.06, CoreFX 4.6.27415.01), 64bit RyuJIT\n\n\n| Method | Mean | Error | StdDev |\n|--------- |----------:|----------:|----------:|\n| ScalarOp | 12.974 us | 0.2579 us | 0.2533 us |\n| VectorOp | 3.956 us | 0.0570 us | 0.0505 us |\n| CopyData | 1.455 us | 0.0273 us | 0.0228 us |\n将数据从向量复制回数组的速度（相对）慢，因为它几乎占用了一半的时间。但仍然：矢量化操作的总时间不到标量操作的 1/3...
\n\n查看反汇编代码（BenchmarkDotNet 将生成它），内存复制操作似乎使用（较慢的）未对齐操作。.Net Core 的未来版本可能会对此进行研究。
\n\nSpan<T>您可以通过使用和MemoryMarshal.Cast将生成的向量直接放入 Span 中来完全避免复制操作。它将求和时间减少了大约。第三个与复制相比（下面未显示）。
作为参考，基准测试代码是（floatSlots = Vector<float>.Count；数组在基准测试运行之前创建并填充数据），并且不一定是最佳解决方案：
[Benchmark]\n public void ScalarOp()\n { \n for (int i = 0; i < data1.Length; i++)\n {\n sums[i] = data1[i] + data2[i];\n } \n }\n\n [Benchmark]\n public void VectorOp()\n { \n int ceiling = data1.Length / floatSlots * floatSlots;\n int leftOver = data1.Length % floatSlots;\n for (int i = 0; i < ceiling; i += floatSlots)\n { \n Vector<float> v1 = new Vector<float>(data1, i); \n Vector<float> v2 = new Vector<float>(data2, i); \n (v1 + v2).CopyTo(sums, i); \n\n }\n for (int i = ceiling; i < data1.Length; i++)\n {\n sums[i] = data1[i] + data2[i];\n }\n }\n\n [Benchmark]\n public void CopyData()\n { \n Vector<float> v1 = new Vector<float>(8);\n int ceiling = data1.Length / floatSlots * floatSlots;\n int leftOver = data1.Length % floatSlots;\n for (int i = 0; i < ceiling; i += floatSlots)\n { \n (v1).CopyTo(sums, i);\n }\n for(int i = ceiling; i < data1.Length; i++)\n {\n sums[i] = 8;\n } \n }\n编辑：更正了标量基准，因为与向量相同，添加了Span和的提及MemoryMarshal.Cast。