Подтвердить что ты не робот

Любой более быстрый способ копирования массивов в С#?

У меня есть три массива, которые нужно объединить в один трехмерный массив. Следующий код показывает медленную производительность в 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];
    }                    
}

Update:

Я пытаюсь сделать следующее:

//given three 1d arrays
double[] 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 that
leftnode = {sortedIndex, sortedInstances, sortedLabels};
4b9b3361

ОТВЕТЫ

Ответ 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 является самым быстрым, но не обязательно стоит беспокоиться.

Ответ 2

Вы можете использовать Array.Copy.

EDIT

Array.Copy работает для многомерных массивов: см. эту тему.

Ответ 3

Для массивов примитивного типа (например, double) вы можете копировать быстро, даже для многомерного массива с указателями.

В приведенном ниже коде я инициализирую двумерный массив A[10,10] со значениями от 1 до 100. Затем я копирую эти значения в одномерный массив 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}
        }
    }
}

Как быстро это. Мое тестирование показало, что оно во много раз быстрее, чем собственная копия С# и 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) с копией указателя, второй. Теперь возникает вопрос: почему копирование указателей не так быстро, как методы буфера?

Ответ 4

Если вы работаете в .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 |

Ответ 5

Если бы работал неровный массив следующей формы, то его можно было бы избежать:

double[][] leftNode = new double[3][];
leftNode[0] = sortedIndex;
leftNode[1] = sortedInstances;
leftNode[2] = sortedLabels;