Array.Copy vs Buffer.BlockCopy

Array.Copy e Buffer.BlockCopy fanno entrambi la stessa cosa, ma BlockCopysono finalizzati alla copia veloce di array primitivi a livello di byte, mentre Copyè l'implementazione generica. La mia domanda è: in quali circostanze dovresti usare BlockCopy? Dovresti usarlo in qualsiasi momento quando copi array di tipi primitivi o dovresti usarlo solo se stai codificando per le prestazioni? C'è qualcosa di intrinsecamente pericoloso nell'usare Buffer.BlockCopyover Array.Copy?

Poiché i parametri Buffer.BlockCopysono basati su byte piuttosto che su indice, è più probabile che si rovini il codice rispetto a se lo si utilizza Array.Copy, quindi lo userei solo Buffer.BlockCopyin una sezione critica per le prestazioni del mio codice.

Preludio

Mi unisco alla festa tardi, ma con 32k visualizzazioni, vale la pena farlo bene. La maggior parte del codice di microbenchmarking nelle risposte pubblicate finora soffre di uno o più gravi difetti tecnici, incluso il mancato spostamento delle allocazioni di memoria fuori dai loop di test (che introduce gravi artefatti GC), il mancato test di flussi di esecuzione variabili rispetto a deterministici, riscaldamento JIT, e non tenere traccia della variabilità intra-test. Inoltre, la maggior parte delle risposte non ha testato gli effetti delle diverse dimensioni del buffer e dei diversi tipi primitivi (rispetto ai sistemi a 32 bit o 64 bit). Per rispondere a questa domanda in modo più completo, l'ho collegato a un framework di microbenchmarking personalizzato che ho sviluppato che riduce la maggior parte dei comuni "trucchi" per quanto possibile. I test sono stati eseguiti in modalità di rilascio .NET 4.0 sia su una macchina a 32 bit che su una macchina a 64 bit. I risultati sono stati calcolati in media su 20 sessioni di test, in cui ciascuna corsa aveva 1 milione di prove per metodo. I tipi primitivi testati eranobyte(1 byte), int(4 byte) e double(8 byte). Tre metodi sono stati testati: Array.Copy(), Buffer.BlockCopy()e semplice assegnazione per-index in un ciclo. I dati sono troppo voluminosi per essere pubblicati qui, quindi riassumerò i punti importanti.

I Takeaway

• Se la lunghezza del buffer è di circa 75-100 o inferiore, una routine di copia del ciclo esplicita è solitamente più veloce (di circa il 5%) di uno Array.Copy()o Buffer.BlockCopy()di tutti e 3 i tipi primitivi testati su macchine a 32 e 64 bit. Inoltre, la routine di copia del ciclo esplicito ha una variabilità notevolmente inferiore nelle prestazioni rispetto alle due alternative. Le buone prestazioni sono quasi sicuramente dovute alla località di riferimento sfruttata dal caching della memoria CPU L1 / L2 / L3 in combinazione con nessun overhead di chiamata al metodo.
  • Solo per i doublebuffer su macchine a 32 bit : la routine di copia del ciclo esplicita è migliore di entrambe le alternative per tutte le dimensioni del buffer testate fino a 100k. Il miglioramento è del 3-5% migliore rispetto agli altri metodi. Questo perché le prestazioni di Array.Copy()e si Buffer.BlockCopy()riducono completamente al passaggio della larghezza nativa di 32 bit. Quindi presumo che lo stesso effetto si applicherebbe anche ai longbuffer.
• Per dimensioni del buffer superiori a ~ 100, la copia esplicita del ciclo diventa rapidamente molto più lenta rispetto agli altri 2 metodi (con l'unica eccezione appena annotata). La differenza è più evidente con byte[], dove la copia esplicita del loop può diventare 7 volte o più lenta con buffer di grandi dimensioni.
• In generale, per tutti e 3 i tipi primitivi testati e per tutte le dimensioni del buffer, Array.Copy()ed Buffer.BlockCopy()eseguiti in modo quasi identico. In media, Array.Copy()sembra avere un leggero margine di circa il 2% o meno del tempo impiegato (ma 0,2% - 0,5% migliore è tipico), anche Buffer.BlockCopy()se occasionalmente lo ha battuto. Per ragioni sconosciute, Buffer.BlockCopy()ha una variabilità intra-test notevolmente maggiore rispetto a Array.Copy(). Questo effetto non può essere eliminato nonostante io abbia provato più mitigazioni e non avessi una teoria utilizzabile sul perché.
• Poiché Array.Copy()è un metodo "più intelligente", più generale e molto più sicuro, oltre ad essere leggermente più veloce e avere mediamente meno variabilità, dovrebbe essere preferito Buffer.BlockCopy()in quasi tutti i casi comuni. L'unico caso d'uso in cui Buffer.BlockCopy()sarà significativamente migliore è quando i tipi di valore dell'array di origine e di destinazione sono diversi (come sottolineato nella risposta di Ken Smith). Anche se questo scenario non è comune, Array.Copy()può funzionare molto male qui a causa del continuo casting "sicuro" del tipo di valore, rispetto al casting diretto di Buffer.BlockCopy().
• Ulteriori prove dall'esterno di StackOverflow che Array.Copy()è più veloce rispetto Buffer.BlockCopy()alla copia di array dello stesso tipo possono essere trovate qui .

Un altro esempio di quando ha senso usare Buffer.BlockCopy()è quando ti viene fornito un array di primitive (ad esempio, short) e devi convertirlo in un array di byte (ad esempio, per la trasmissione su una rete). Uso spesso questo metodo quando si tratta di audio da Silverlight AudioSink. Fornisce il campione come un short[]array, ma è necessario convertirlo in un byte[]array quando si crea il pacchetto a cui si invia Socket.SendAsync(). Potresti usare BitConvertere iterare attraverso l'array uno per uno, ma è molto più veloce (circa 20 volte nei miei test) solo per fare questo:

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

E lo stesso trucco funziona anche al contrario:

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

Questo è quanto di più vicino si arriva in C # sicuro al (void *)tipo di gestione della memoria così comune in C e C ++.

Sulla base dei miei test, le prestazioni non sono un motivo per preferire Buffer.BlockCopy su Array.Copy. Dal mio test Array.Copy è effettivamente più veloce di 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));

Output di esempio:

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 è più intelligente di BlockCopy. Capisce come copiare gli elementi se l'origine e la destinazione sono lo stesso array.

Se popoliamo un array int con 0,1,2,3,4 e applichiamo:

Array.Copy (array, 0, array, 1, array.Length - 1);

finiamo con 0,0,1,2,3 come previsto.

Prova questo con BlockCopy e otteniamo: 0,0,2,3,4. Se assegno array[0]=-1dopo, diventa -1,0,2,3,4 come previsto, ma se la lunghezza dell'array è pari, come 6, otteniamo -1,256,2,3,4,5. Roba pericolosa. Non utilizzare BlockCopy se non per copiare un array di byte in un altro.

C'è un altro caso in cui puoi usare solo Array.Copy: se la dimensione dell'array è maggiore di 2 ^ 31. Array.Copy ha un overload con un longparametro size. BlockCopy non ce l'ha.

Per pesare su questo argomento, se non si sta attenti a come hanno creato questo benchmark, potrebbero essere facilmente fuorviati. Ho scritto un test molto semplice per illustrare questo. Nel mio test di seguito se cambio l'ordine dei miei test tra l'avvio Buffer.BlockCopy prima o Array.Copy quello che va per primo è quasi sempre il più lento (anche se è uno vicino). Ciò significa che per una serie di motivi che non andrò semplicemente a eseguire i test più volte, specialmente uno dopo l'altro, non darà risultati accurati.

Ho fatto ricorso a mantenere il test così com'è con 1000000 tentativi ciascuno per un array di 1000000 doppi sequenziali. Tuttavia, allora ignoro i primi 900000 cicli e faccio la media del resto. In tal caso il Buffer è superiore.

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

Voglio solo aggiungere il mio caso di test che mostra ancora una volta BlockCopy non ha alcun vantaggio "PERFORMANCE" su Array.Copy. Sembrano avere le stesse prestazioni in modalità di rilascio sulla mia macchina (entrambi impiegano circa 66 ms per copiare 50 milioni di numeri interi). In modalità debug, BlockCopy è solo leggermente più veloce.

    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);
    }