有更快的方法在C＃中复制数组吗？

Question

我有三个数组，需要组合成一个三维数组。以下代码显示了Performance Explorer中的性能下降。有更快的解决方案吗？for (int i = 0; i < sortedIndex.Length; i++) {    if (i < num_in_left)    {            // add instance to the left child        leftnode[i, 0] = sortedIndex[i];        leftnode[i, 1] = sortedInstances[i];        leftnode[i, 2] = sortedLabels[i];    }    else    {         // add instance to the right child        rightnode[i-num_in_left, 0] = sortedIndex[i];        rightnode[i-num_in_left, 1] = sortedInstances[i];        rightnode[i-num_in_left, 2] = sortedLabels[i];    }                    }更新：我实际上正在尝试执行以下操作：//given three 1d arraysdouble[] sortedIndex, sortedInstances, sortedLabels;// copy them over to a 3d array (forget about the rightnode for now)double[] leftnode = new double[sortedIndex.Length, 3];// some magic happens here so thatleftnode = {sortedIndex, sortedInstances, sortedLabels};

Answer 1

使用Buffer.BlockCopy。它的全部目的是快速执行（请参见Buffer）：

与System.Array类中的类似方法相比，此类提供了更好的操作原始类型的性能。

诚然，我还没有做过任何基准测试，但这就是文档。它也适用于多维数组。只需确保始终指定要复制的字节数，而不是指定多少个元素，并且确保您正在处理原始数组。

另外，我还没有对此进行测试，但是如果将委托绑定到并直接调用它，则可能会使系统的性能降低System.Buffer.memcpyimpl一点。签名是：

internal static unsafe void memcpyimpl(byte* src, byte* dest, int len)

它确实需要指针，但是我相信它已针对可能的最高速度进行了优化，因此，即使您手头有组装，我也认为没有任何方法可以使速度更快。

更新：

由于要求（并满足我的好奇心），我对此进行了测试：

using System;

using System.Diagnostics;

using System.Reflection;

unsafe delegate void MemCpyImpl(byte* src, byte* dest, int len);

static class Temp

{

    //There really should be a generic CreateDelegate<T>() method... -___-

    static MemCpyImpl memcpyimpl = (MemCpyImpl)Delegate.CreateDelegate(

        typeof(MemCpyImpl), typeof(Buffer).GetMethod("memcpyimpl",

            BindingFlags.Static | BindingFlags.NonPublic));

    const int COUNT = 32, SIZE = 32 << 20;

    //Use different buffers to help avoid CPU cache effects

    static byte[]

        aSource = new byte[SIZE], aTarget = new byte[SIZE],

        bSource = new byte[SIZE], bTarget = new byte[SIZE],

        cSource = new byte[SIZE], cTarget = new byte[SIZE];

    static unsafe void TestUnsafe()

    {

        Stopwatch sw = Stopwatch.StartNew();

        fixed (byte* pSrc = aSource)

        fixed (byte* pDest = aTarget)

            for (int i = 0; i < COUNT; i++)

                memcpyimpl(pSrc, pDest, SIZE);

        sw.Stop();

        Console.WriteLine("Buffer.memcpyimpl: {0:N0} ticks", sw.ElapsedTicks);

    }

    static void TestBlockCopy()

    {

        Stopwatch sw = Stopwatch.StartNew();

        sw.Start();

        for (int i = 0; i < COUNT; i++)

            Buffer.BlockCopy(bSource, 0, bTarget, 0, SIZE);

        sw.Stop();

        Console.WriteLine("Buffer.BlockCopy: {0:N0} ticks",

            sw.ElapsedTicks);

    }

    static void TestArrayCopy()

    {

        Stopwatch sw = Stopwatch.StartNew();

        sw.Start();

        for (int i = 0; i < COUNT; i++)

            Array.Copy(cSource, 0, cTarget, 0, SIZE);

        sw.Stop();

        Console.WriteLine("Array.Copy: {0:N0} ticks", sw.ElapsedTicks);

    }

    static void Main(string[] args)

    {

        for (int i = 0; i < 10; i++)

        {

            TestArrayCopy();

            TestBlockCopy();

            TestUnsafe();

            Console.WriteLine();

        }

    }

}

结果：

Buffer.BlockCopy: 469,151 ticks

Array.Copy: 469,972 ticks

Buffer.memcpyimpl: 496,541 ticks

Buffer.BlockCopy: 421,011 ticks

Array.Copy: 430,694 ticks

Buffer.memcpyimpl: 410,933 ticks

Buffer.BlockCopy: 425,112 ticks

Array.Copy: 420,839 ticks

Buffer.memcpyimpl: 411,520 ticks

Buffer.BlockCopy: 424,329 ticks

Array.Copy: 420,288 ticks

Buffer.memcpyimpl: 405,598 ticks

Buffer.BlockCopy: 422,410 ticks

Array.Copy: 427,826 ticks

Buffer.memcpyimpl: 414,394 ticks

现在更改顺序：

Array.Copy: 419,750 ticks

Buffer.memcpyimpl: 408,919 ticks

Buffer.BlockCopy: 419,774 ticks

Array.Copy: 430,529 ticks

Buffer.memcpyimpl: 412,148 ticks

Buffer.BlockCopy: 424,900 ticks

Array.Copy: 424,706 ticks

Buffer.memcpyimpl: 427,861 ticks

Buffer.BlockCopy: 421,929 ticks

Array.Copy: 420,556 ticks

Buffer.memcpyimpl: 421,541 ticks

Buffer.BlockCopy: 436,430 ticks

Array.Copy: 435,297 ticks

Buffer.memcpyimpl: 432,505 ticks

Buffer.BlockCopy: 441,493 ticks

现在再次更改顺序：

Buffer.memcpyimpl: 430,874 ticks

Buffer.BlockCopy: 429,730 ticks

Array.Copy: 432,746 ticks

Buffer.memcpyimpl: 415,943 ticks

Buffer.BlockCopy: 423,809 ticks

Array.Copy: 428,703 ticks

Buffer.memcpyimpl: 421,270 ticks

Buffer.BlockCopy: 428,262 ticks

Array.Copy: 434,940 ticks

Buffer.memcpyimpl: 423,506 ticks

Buffer.BlockCopy: 427,220 ticks

Array.Copy: 431,606 ticks

Buffer.memcpyimpl: 422,900 ticks

Buffer.BlockCopy: 439,280 ticks

Array.Copy: 432,649 ticks

或者换句话说：他们很有竞争力；一般而言，memcpyimpl速度最快，但不必担心。

Answer 2

对于基本类型的数组（如double），即使对于带有指针的多维数组，也可以快速复制。

在下面的代码中，我初始化一个2D数组A[10,10]，其值是1到100。然后将这些值复制到1D数组中。B[100]

unsafe class Program

{ 

    static void Main(string[] args)

    {

        double[,] A = new double[10, 10];

        for(int i = 0; i < 10; i++)

        {

            for(int j = 0; j < 10; j++)

            {

                A[i, j] = 10 * i + j + 1;

            }

        }

        // A has { { 1 ,2 .. 10}, { 11, 12 .. 20}, .. { .. 99, 100} }

        double[] B = new double[10 * 10];

        if (A.Length == B.Length)

        {

            fixed (double* pA = A, pB = B)

            {

                for(int i = 0; i < B.Length; i++)

                {

                    pB[i] = pA[i];

                }

            }

            // B has {1, 2, 3, 4 .. 100}

        }

    }

}

有多快 我的测试表明，它比本机C＃复制和复制要快很多倍Buffer.BlockCopy()。您可以根据自己的情况尝试一下，并告诉我们。

编辑1 我比较了复制和四种方法。1）两个嵌套循环，2）一个串行循环，3）指针，4）BlockCopy。我测量了各种尺寸阵列的每刻度的副本数。

N =   10x  10 (cpy/tck) Nested = 50,  Serial = 33, Pointer =    100, Buffer =    16

N =   20x  20 (cpy/tck) Nested = 133, Serial = 40, Pointer =    400, Buffer =   400

N =   50x  50 (cpy/tck) Nested = 104, Serial = 40, Pointer =   2500, Buffer =  2500

N =  100x 100 (cpy/tck) Nested = 61,  Serial = 41, Pointer =  10000, Buffer =  3333

N =  200x 200 (cpy/tck) Nested = 84,  Serial = 41, Pointer =  40000, Buffer =  2666

N =  500x 500 (cpy/tck) Nested = 69,  Serial = 41, Pointer = 125000, Buffer =  2840

N = 1000x1000 (cpy/tck) Nested = 33,  Serial = 45, Pointer = 142857, Buffer =  1890

N = 2000x2000 (cpy/tck) Nested = 30,  Serial = 43, Pointer = 266666, Buffer =  1826

N = 5000x5000 (cpy/tck) Nested = 21,  Serial = 42, Pointer = 735294, Buffer =  1712

很明显，谁是赢家。指针复制比任何其他方法好几个数量级。

编辑2 显然，我不公平地利用了编译器/ JIT优化，因为当我将循环移动到代表后面以平衡竞争环境时，数字发生了巨大变化。

N =   10x  10 (cpy/tck) Nested =  0, Serial =  0, Pointer =      0, Buffer =     0

N =   20x  20 (cpy/tck) Nested = 80, Serial = 14, Pointer =    100, Buffer =   133

N =   50x  50 (cpy/tck) Nested =147, Serial = 15, Pointer =    277, Buffer =  2500

N =  100x 100 (cpy/tck) Nested = 98, Serial = 15, Pointer =    285, Buffer =  3333

N =  200x 200 (cpy/tck) Nested =106, Serial = 15, Pointer =    272, Buffer =  3076

N =  500x 500 (cpy/tck) Nested =106, Serial = 15, Pointer =    276, Buffer =  3125

N = 1000x1000 (cpy/tck) Nested =101, Serial = 11, Pointer =    199, Buffer =  1396

N = 2000x2000 (cpy/tck) Nested =105, Serial =  9, Pointer =    186, Buffer =  1804

N = 5000x5000 (cpy/tck) Nested =102, Serial =  8, Pointer =    170, Buffer =  1673

缓冲的副本位于此处的顶部（感谢@Mehrdad），其次是指针副本。现在的问题是，为什么指针复制不如缓冲区方法那么快？

Answer 3

如果在.NET Core上运行，则可以考虑使用source.AsSpan().CopyTo(destination)（但请注意在Mono上）。

          Method |  Job | Runtime |      Mean |     Error |    StdDev | Ratio | RatioSD |

---------------- |----- |-------- |----------:|----------:|----------:|------:|--------:|

       ArrayCopy |  Clr |     Clr |  60.08 ns | 0.8231 ns | 0.7699 ns |  1.00 |    0.00 |

        SpanCopy |  Clr |     Clr |  99.31 ns | 0.4895 ns | 0.4339 ns |  1.65 |    0.02 |

 BufferBlockCopy |  Clr |     Clr |  61.34 ns | 0.5963 ns | 0.5578 ns |  1.02 |    0.01 |

                 |      |         |           |           |           |       |         |

       ArrayCopy | Core |    Core |  63.33 ns | 0.6843 ns | 0.6066 ns |  1.00 |    0.00 |

        SpanCopy | Core |    Core |  47.41 ns | 0.5399 ns | 0.5050 ns |  0.75 |    0.01 |

 BufferBlockCopy | Core |    Core |  59.89 ns | 0.4713 ns | 0.3936 ns |  0.94 |    0.01 |

                 |      |         |           |           |           |       |         |

       ArrayCopy | Mono |    Mono | 149.82 ns | 1.6466 ns | 1.4596 ns |  1.00 |    0.00 |

        SpanCopy | Mono |    Mono | 347.87 ns | 2.0589 ns | 1.9259 ns |  2.32 |    0.02 |

 BufferBlockCopy | Mono |    Mono |  61.52 ns | 1.1691 ns | 1.0364 ns |  0.41 |    0.01 |