Array.Copy vs Buffer.BlockCopy

І Array.Copy, і Buffer.BlockCopy роблять те ж саме, але BlockCopyспрямовано на швидке копіювання примітивного масиву на рівні байтів, тоді як Copyце реалізація загального призначення. Моє запитання - за яких обставин слід використовувати BlockCopy? Чи слід використовувати його в будь-який час, коли ви копіюєте масиви примітивного типу, або використовувати його потрібно лише в тому випадку, якщо ви кодуєте продуктивність? Чи є щось вроджене небезпечне у використанні Buffer.BlockCopyнад Array.Copy?

Оскільки параметри до Buffer.BlockCopy базуються на байтах, а не на індексах, ви, швидше за все, накрутите ваш код, ніж якщо ви використовуєте Array.Copy, тому я використовував би лише Buffer.BlockCopyв критичному для роботи розділі свого коду.

Прелюдія

Я приєднуюся до партії пізно, але з 32-кратним переглядом варто це правильно зробити. Більшість кодів мікробного маркування у розміщених відповідях поки що страждають від одного або декількох суворих технічних недоліків, включаючи не переміщення виділень пам'яті з тестових циклів (що вводить суворі артефакти GC), не тестування змінних та детермінованих потоків виконання, розминка JIT, і не відслідковувати мінливість тесту. Крім того, більшість відповідей не перевіряли впливу різних розмірів буфера та різних примітивних типів (стосовно 32-бітної або 64-бітної систем). Щоб вирішити це питання більш всебічно, я підключив його до розробленої нами спеціальної рамки мікробенчмаркінгу, яка скорочує більшість поширених "gotchas" настільки, наскільки це можливо. Тести проводилися в режимі випуску .NET 4.0 як для 32-бітної машини, так і для 64-розрядної машини. Результати були усереднені протягом 20 тестових циклів, в яких кожен цикл мав 1 мільйон випробувань на метод. Тестували примітивні типиbyte(1 байт), int(4 байта) і double(8 байт). Були протестовані три методи: Array.Copy(), Buffer.BlockCopy(), і просто за індексом присвоювання в циклі. Дані тут занадто об'ємні, щоб розміщувати тут, тому я підсумую важливі моменти.

Винос

• Якщо довжина буфера становить приблизно 75-100 або менше, явна процедура копіювання циклу зазвичай швидша (приблизно на 5%), ніж будь-який Array.Copy()або Buffer.BlockCopy()для всіх 3 примітивних типів, перевірених як на 32-бітних, так і на 64-бітних машинах. Крім того, програма явного копіювання циклу має помітно меншу мінливість у порівнянні з двома альтернативами. Хороші показники майже напевно пояснюються локальністю опор, керованою кешуванням пам’яті процесора L1 / L2 / L3 у поєднанні з накладними викликами методу.
  • Тільки для doubleбуферів на 32-бітних машинах : Явна програма копіювання циклу краща, ніж обидві альтернативи для всіх перевірених розмірів буфера до 100 Кб. Поліпшення на 3-5% краще, ніж інші методи. Це пояснюється тим, що продуктивність Array.Copy()і Buffer.BlockCopy()повністю знижується при проходженні нативного 32-бітової ширини. Тому я припускаю, що такий же ефект буде застосований і до longбуферів.
• Для розмірів буфера, що перевищують ~ 100, явне копіювання циклу швидко стає набагато повільніше, ніж для інших 2-х методів (за одним лише певним винятком). Відмінність найбільш помітна в тому випадку byte[], коли явне копіювання циклу може ставати 7x або більше повільніше при великих розмірах буфера.
• Загалом, для всіх 3 -х примітивних типів випробувані і в усіх розмірах буфера, Array.Copy()і Buffer.BlockCopy()виконуються майже однаково. В середньому, Array.Copy()здається, дуже незначний край становить приблизно 2% або менше часу (але 0,2% - 0,5% краще, як правило, типово), хоча Buffer.BlockCopy()іноді його обіграв. З невідомих причин Buffer.BlockCopy()має помітно більшу мінливість внутрішнього тесту, ніж Array.Copy(). Цей ефект не вдалося усунути, незважаючи на те, що я намагався здійснити численні пом'якшення та не маючи діючої теорії про те, чому.
• Оскільки Array.Copy()це "розумніший", більш загальний та набагато безпечніший метод, окрім того, що він є дещо швидшим та має меншу мінливість в середньому, його слід віддавати перевагу Buffer.BlockCopy()майже у всіх поширених випадках. Єдиний випадок використання, коли Buffer.BlockCopy()буде значно краще, це коли типи значень масиву джерела та призначення відрізняються (як зазначено у відповіді Кен Сміта). Незважаючи на те, що цей сценарій не є загальним, він Array.Copy()може працювати дуже погано через постійне "безпечне" значення виливання типів порівняно з прямим кастингом Buffer.BlockCopy().
• Додаткові дані від зовнішнього StackOverflow , що Array.Copy()це швидше , ніж Buffer.BlockCopy()для масиву копіювання ж типу можна знайти тут .

Інший приклад, коли це має сенс використовувати, Buffer.BlockCopy()- коли вам забезпечений масив примітивів (скажімо, шорти), і вам потрібно перетворити його в масив байтів (скажімо, для передачі по мережі). Цей метод я часто використовую при роботі зі звуком із Silverlight AudioSink. Він надає зразок як short[]масив, але вам потрібно перетворити його в byte[]масив, коли ви будуєте пакет, який ви подаєте Socket.SendAsync(). Ви можете використовувати BitConverterі повторювати масив по одному, але це набагато швидше (приблизно 20 разів в моєму тестуванні), щоб зробити це:

Buffer.BlockCopy(shortSamples, 0, packetBytes, 0, shortSamples.Length * sizeof(short)).  

І ця ж хитрість працює і в зворотному напрямку:

Buffer.BlockCopy(packetBytes, readPosition, shortSamples, 0, payloadLength);

Це приблизно так близько, як ви наближаєтесь до безпечного C # до такого (void *)типу управління пам'яттю, яке так часто зустрічається у C та C ++.

На основі мого тестування, продуктивність не є причиною віддавати перевагу Buffer.BlockCopy над Array.Copy. З мого тестування Array.Copy насправді швидше, ніж Buffer.BlockCopy.

var buffer = File.ReadAllBytes(...);

var length = buffer.Length;
var copy = new byte[length];

var stopwatch = new Stopwatch();

TimeSpan blockCopyTotal = TimeSpan.Zero, arrayCopyTotal = TimeSpan.Zero;

const int times = 20;

for (int i = 0; i < times; ++i)
{
    stopwatch.Start();
    Buffer.BlockCopy(buffer, 0, copy, 0, length);
    stopwatch.Stop();

    blockCopyTotal += stopwatch.Elapsed;

    stopwatch.Reset();

    stopwatch.Start();
    Array.Copy(buffer, 0, copy, 0, length);
    stopwatch.Stop();

    arrayCopyTotal += stopwatch.Elapsed;

    stopwatch.Reset();
}

Console.WriteLine("bufferLength: {0}", length);
Console.WriteLine("BlockCopy: {0}", blockCopyTotal);
Console.WriteLine("ArrayCopy: {0}", arrayCopyTotal);
Console.WriteLine("BlockCopy (average): {0}", TimeSpan.FromMilliseconds(blockCopyTotal.TotalMilliseconds / times));
Console.WriteLine("ArrayCopy (average): {0}", TimeSpan.FromMilliseconds(arrayCopyTotal.TotalMilliseconds / times));

Приклад Вихід:

bufferLength: 396011520
BlockCopy: 00:00:02.0441855
ArrayCopy: 00:00:01.8876299
BlockCopy (average): 00:00:00.1020000
ArrayCopy (average): 00:00:00.0940000

ArrayCopy розумніший за BlockCopy. Він з'ясовує, як скопіювати елементи, якщо джерело та пункт призначення однакові.

Якщо ми заповнимо масив int з 0,1,2,3,4 і застосуємо:

Array.Copy (масив, 0, масив, 1, array.Length - 1);

ми закінчуємо 0,0,1,2,3, як очікувалося.

Спробуйте це з BlockCopy і ми отримаємо: 0,0,2,3,4. Якщо я призначуarray[0]=-1 після цього, він стає -1,0,2,3,4, як очікувалося, але якщо довжина масиву рівна, як 6, ми отримаємо -1,256,2,3,4,5. Небезпечні речі. Не використовуйте BlockCopy, окрім як для копіювання одного байтового масиву в інший.

Є ще один випадок, коли ви можете використовувати тільки Array.Copy: якщо розмір масиву перевищує 2 ^ 31. Array.Copy має перевантаження з longпараметром розміру. У BlockCopy цього немає.

Якщо зважити на цей аргумент, якщо не бути обережним, як вони складають цей показник, їх можна було б легко ввести в оману. Я написав дуже простий тест, щоб проілюструвати це. У моєму тесті нижче, якщо я поміняю порядок моїх тестів між початковим Buffer.BlockCopy першим або Array.Копіюйте те, що йде першим, майже завжди є найповільнішим (хоча воно є близьким). Це означає, що з безлічі причин, з якими я не збираюся просто запускати тести, кілька разів один за одним не дасть точних результатів.

Я вдався до підтримки тесту, як у 1000000 спроб кожна для масиву з 1000000 послідовних подвійних. Однак у цьому випадку я нехтую першими 900000 циклами і в середньому решту. У цьому випадку буфер є вищим.

private static void BenchmarkArrayCopies()
        {
            long[] bufferRes = new long[1000000];
            long[] arrayCopyRes = new long[1000000];
            long[] manualCopyRes = new long[1000000];

            double[] src = Enumerable.Range(0, 1000000).Select(x => (double)x).ToArray();

            for (int i = 0; i < 1000000; i++)
            {
                bufferRes[i] = ArrayCopyTests.ArrayBufferBlockCopy(src).Ticks;
            }

            for (int i = 0; i < 1000000; i++)
            {
                arrayCopyRes[i] = ArrayCopyTests.ArrayCopy(src).Ticks;
            }

            for (int i = 0; i < 1000000; i++)
            {
                manualCopyRes[i] = ArrayCopyTests.ArrayManualCopy(src).Ticks;
            }

            Console.WriteLine("Loop Copy: {0}", manualCopyRes.Average());
            Console.WriteLine("Array.Copy Copy: {0}", arrayCopyRes.Average());
            Console.WriteLine("Buffer.BlockCopy Copy: {0}", bufferRes.Average());

            //more accurate results - average last 1000

            Console.WriteLine();
            Console.WriteLine("----More accurate comparisons----");

            Console.WriteLine("Loop Copy: {0}", manualCopyRes.Where((l, i) => i > 900000).ToList().Average());
            Console.WriteLine("Array.Copy Copy: {0}", arrayCopyRes.Where((l, i) => i > 900000).ToList().Average());
            Console.WriteLine("Buffer.BlockCopy Copy: {0}", bufferRes.Where((l, i) => i > 900000).ToList().Average());
            Console.ReadLine();
        }

public class ArrayCopyTests
    {
        private const int byteSize = sizeof(double);

        public static TimeSpan ArrayBufferBlockCopy(double[] original)
        {
            Stopwatch watch = new Stopwatch();
            double[] copy = new double[original.Length];
            watch.Start();
            Buffer.BlockCopy(original, 0 * byteSize, copy, 0 * byteSize, original.Length * byteSize);
            watch.Stop();
            return watch.Elapsed;
        }

        public static TimeSpan ArrayCopy(double[] original)
        {
            Stopwatch watch = new Stopwatch();
            double[] copy = new double[original.Length];
            watch.Start();
            Array.Copy(original, 0, copy, 0, original.Length);
            watch.Stop();
            return watch.Elapsed;
        }

        public static TimeSpan ArrayManualCopy(double[] original)
        {
            Stopwatch watch = new Stopwatch();
            double[] copy = new double[original.Length];
            watch.Start();
            for (int i = 0; i < original.Length; i++)
            {
                copy[i] = original[i];
            }
            watch.Stop();
            return watch.Elapsed;
        }
    }

https://github.com/chivandikwa/Random-Benchmarks

Просто хочу додати мій тестовий випадок, який знову показує, що BlockCopy не має переваги "PERFORMANCE" над Array.Copy. Вони, схоже, мають однакову продуктивність у режимі випуску на моїй машині (обоє займають близько 66 мс для копіювання 50 мільйонів цілих чисел). У режимі налагодження BlockCopy просто незначно швидше.

    private static T[] CopyArray<T>(T[] a) where T:struct 
    {
        T[] res = new T[a.Length];
        int size = Marshal.SizeOf(typeof(T));
        DateTime time1 = DateTime.Now;
        Buffer.BlockCopy(a,0,res,0, size*a.Length);
        Console.WriteLine("Using Buffer blockcopy: {0}", (DateTime.Now - time1).Milliseconds);
        return res;
    }

    static void Main(string[] args)
    {
        int simulation_number = 50000000;
        int[] testarray1 = new int[simulation_number];

        int begin = 0;
        Random r = new Random();
        while (begin != simulation_number)
        {
            testarray1[begin++] = r.Next(0, 10000);
        }

        var copiedarray = CopyArray(testarray1);

        var testarray2 = new int[testarray1.Length];
        DateTime time2 = DateTime.Now;
        Array.Copy(testarray1, testarray2, testarray1.Length);
        Console.WriteLine("Using Array.Copy(): {0}", (DateTime.Now - time2).Milliseconds);
    }