多维数组只是一大块内存,因此我们可以将其视为一个,类似于memset()
作品。这需要不安全的代码。我不会说这值得做,除非really性能至关重要。不过,这是一个有趣的练习,因此以下是使用 BenchmarkDotNet 的一些基准测试:
public class ArrayFillBenchmark
{
const int length1 = 1000;
const int length2 = 1000;
readonly double[,] _myArray = new double[length1, length2];
[Benchmark]
public void MultidimensionalArrayLoop()
{
for (int i = 0; i < length1; i++)
for (int j = 0; j < length2; j++)
_myArray[i, j] = double.PositiveInfinity;
}
[Benchmark]
public unsafe void MultidimensionalArrayNaiveUnsafeLoop()
{
fixed (double* a = &_myArray[0, 0])
{
double* b = a;
for (int i = 0; i < length1; i++)
for (int j = 0; j < length2; j++)
*b++ = double.PositiveInfinity;
}
}
[Benchmark]
public unsafe void MultidimensionalSpanFill()
{
fixed (double* a = &_myArray[0, 0])
{
double* b = a;
var span = new Span<double>(b, length1 * length2);
span.Fill(double.PositiveInfinity);
}
}
[Benchmark]
public unsafe void MultidimensionalSseFill()
{
var vectorPositiveInfinity = Vector128.Create(double.PositiveInfinity);
fixed (double* a = &_myArray[0, 0])
{
double* b = a;
ulong i = 0;
int size = Vector128<double>.Count;
ulong length = length1 * length2;
for (; i < (length & ~(ulong)15); i += 16)
{
Sse2.Store(b+size*0, vectorPositiveInfinity);
Sse2.Store(b+size*1, vectorPositiveInfinity);
Sse2.Store(b+size*2, vectorPositiveInfinity);
Sse2.Store(b+size*3, vectorPositiveInfinity);
Sse2.Store(b+size*4, vectorPositiveInfinity);
Sse2.Store(b+size*5, vectorPositiveInfinity);
Sse2.Store(b+size*6, vectorPositiveInfinity);
Sse2.Store(b+size*7, vectorPositiveInfinity);
b += size*8;
}
for (; i < (length & ~(ulong)7); i += 8)
{
Sse2.Store(b+size*0, vectorPositiveInfinity);
Sse2.Store(b+size*1, vectorPositiveInfinity);
Sse2.Store(b+size*2, vectorPositiveInfinity);
Sse2.Store(b+size*3, vectorPositiveInfinity);
b += size*4;
}
for (; i < (length & ~(ulong)3); i += 4)
{
Sse2.Store(b+size*0, vectorPositiveInfinity);
Sse2.Store(b+size*1, vectorPositiveInfinity);
b += size*2;
}
for (; i < length; i++)
{
*b++ = double.PositiveInfinity;
}
}
}
}
Results:
| Method | Mean | Error | StdDev | Ratio |
|------------------------------------- |-----------:|----------:|----------:|------:|
| MultidimensionalArrayLoop | 1,083.1 us | 11.797 us | 11.035 us | 1.00 |
| MultidimensionalArrayNaiveUnsafeLoop | 436.2 us | 8.567 us | 8.414 us | 0.40 |
| MultidimensionalSpanFill | 321.2 us | 6.404 us | 10.875 us | 0.30 |
| MultidimensionalSseFill | 231.9 us | 4.616 us | 11.323 us | 0.22 |
MultidimensionalArrayLoop
由于边界检查,速度很慢。 JIT 在每个循环中发出代码,以确保[i, j]
位于数组的边界内。 JIT 有时可以省略边界检查,我知道它适用于一维数组。我不确定它是否适用于多维。
MultidimensionalArrayNaiveUnsafeLoop
本质上是相同的代码MultidimensionalArrayLoop
但没有边界检查。它的速度要快得多,只需要 40% 的时间。不过,它被认为是“天真的”,因为仍然可以通过展开循环来改进循环。
MultidimensionalSpanFill
也没有边界检查,并且或多或少与MultidimensionalArrayNaiveUnsafeLoop
, 然而,Span.Fill
在内部进行循环展开,这就是为什么它比我们的天真的不安全循环要快一些。只需要我们原来的30%的时间。
MultidimensionalSseFill
通过做两件事来改进我们的第一个不安全循环:循环展开和矢量化。这需要支持 Sse2 的 CPU,但它允许我们在一条指令中写入 128 位(16 字节)。这给我们带来了额外的速度提升,将其降低至原始速度的 22%。有趣的是,使用 Avx(256 位)的相同循环始终比 Sse2 版本慢,因此此处不包含该基准测试。
但这些数字仅适用于 1000x1000 的数组。当您更改数组的大小时,结果会有所不同。例如,当我们将数组大小更改为 10000x10000 时,所有不安全基准测试的结果都非常接近。可能是因为较大的数组有更多的内存获取,因此它往往会均衡在过去三个基准测试中看到的较小的迭代改进。
那里有一个教训,但我主要只是想分享这些结果,因为这是一个非常有趣的实验。