我试图通过利用 System.Numerics 对float[]
数组执行SIMD操作来提高.NET Core库的性能。 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()
可能是导致性能下降的很大一部分,但是似乎没有简便的方法来使填充/对齐方式和数据集与{{1 }}的规范。
我对SIMD相当陌生,并且我了解C#实现仍处于早期阶段。但是,我看不出有一种从中受益的明确方法,尤其是考虑到将其扩展到更大的数据集时,它是最有益的。
有更好的方法吗?
答案 0 :(得分:3)
我不确定您所说的“笨拙”是什么意思,但是它现在可以完美使用(尽管它可能会表现得更好)。 使用您的案例(总计浮点数),使用Haswell较旧的CPU可以获得10003项以下结果:
BenchmarkDotNet=v0.11.5, OS=Windows 10.0.17134.706 (1803/April2018Update/Redstone4)
Intel Core i7-4500U CPU 1.80GHz (Haswell), 1 CPU, 4 logical and 2 physical cores
Frequency=1753753 Hz, Resolution=570.2057 ns, Timer=TSC
.NET Core SDK=2.1.602
[Host] : .NET Core 2.1.9 (CoreCLR 4.6.27414.06, CoreFX 4.6.27415.01), 64bit RyuJIT
DefaultJob : .NET Core 2.1.9 (CoreCLR 4.6.27414.06, CoreFX 4.6.27415.01), 64bit RyuJIT
| Method | Mean | Error | StdDev |
|--------- |----------:|----------:|----------:|
| ScalarOp | 12.974 us | 0.2579 us | 0.2533 us |
| VectorOp | 3.956 us | 0.0570 us | 0.0505 us |
| CopyData | 1.455 us | 0.0273 us | 0.0228 us |
将数据从矢量复制回数组的速度相对较慢,因为它几乎消耗了一半的时间。但仍然:矢量化运算的总时间不到标量运算的三分之一...
看一下反汇编(BenchmarkDotNet会生成它),似乎内存复制操作使用了(较慢的)未对齐的op。可能会在将来的.Net Core版本中对此进行研究。
通过使用Span<T>
和MemoryMarshal.Cast
将结果向量直接放入Span,可以完全避免复制操作。它将求和时间减少了大约。与复制相比,三分之一(以下未显示)。
作为参考,基准代码为(floatSlots = Vector<float>.Count
;在基准运行之前创建数组并填充数据),并且不一定是最佳解决方案:
[Benchmark]
public void ScalarOp()
{
for (int i = 0; i < data1.Length; i++)
{
sums[i] = data1[i] + data2[i];
}
}
[Benchmark]
public void VectorOp()
{
int ceiling = data1.Length / floatSlots * floatSlots;
int leftOver = data1.Length % floatSlots;
for (int i = 0; i < ceiling; i += floatSlots)
{
Vector<float> v1 = new Vector<float>(data1, i);
Vector<float> v2 = new Vector<float>(data2, i);
(v1 + v2).CopyTo(sums, i);
}
for (int i = ceiling; i < data1.Length; i++)
{
sums[i] = data1[i] + data2[i];
}
}
[Benchmark]
public void CopyData()
{
Vector<float> v1 = new Vector<float>(8);
int ceiling = data1.Length / floatSlots * floatSlots;
int leftOver = data1.Length % floatSlots;
for (int i = 0; i < ceiling; i += floatSlots)
{
(v1).CopyTo(sums, i);
}
for(int i = ceiling; i < data1.Length; i++)
{
sums[i] = 8;
}
}
编辑:已修正标量基准,因为它与矢量相同,并增加了对Span
和MemoryMarshal.Cast
的提及。