用相同的值填充多维数组 C#

Question

是否有使用 C# 执行此操作的更快方法？

double[,] myArray = new double[length1, length2];

for(int i=0;i<length1;i++)
    for(int j=0;j<length2;j++)
        myArray[i,j] = double.PositiveInfinity;

我记得使用 C++，有一些事情memset()需要做这些事情......

Answer 1

多维数组只是一大块内存，因此我们可以将其视为一个，类似于memset()工作原理。这需要不安全的代码。我不会说这值得做，除非它确实对性能至关重要。不过，这是一个有趣的练习，因此以下是使用 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;
                }
            }
        }
    }

结果：

|                               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 时，所有不安全基准测试的结果都非常接近。可能是因为较大的数组有更多的内存获取，因此它往往会均衡在过去三个基准测试中看到的较小的迭代改进。

那里有一个教训，但我主要只是想分享这些结果，因为这是一个非常有趣的实验。

Answer 2

我编写的方法并不快，但它适用于实际的多维数组，而不仅仅是二维数组。

public static class ArrayExtensions
{
    public static void Fill(this Array array, object value)
    {
        var indicies = new int[array.Rank];

        Fill(array, 0, indicies, value);
    }

    public static void Fill(Array array, int dimension, int[] indicies, object value)
    {
        if (dimension < array.Rank)
        {
            for (int i = array.GetLowerBound(dimension); i <= array.GetUpperBound(dimension); i++)
            {
                indicies[dimension] = i;
                Fill(array, dimension + 1, indicies, value);
            }
        }
        else
            array.SetValue(value, indicies);
    }
}