Array.Copy vs Buffer.BlockCopy

Array.Copy e Buffer.BlockCopy fazem a mesma coisa, mas BlockCopytêm como objetivo a cópia rápida da matriz primitiva no nível de bytes, enquanto Copyé a implementação de uso geral. Minha pergunta é - em que circunstâncias você deve usar BlockCopy? Você deve usá-lo a qualquer momento quando estiver copiando matrizes de tipo primitivo ou deve usá-lo apenas se estiver codificando para desempenho? Existe algo inerentemente perigoso sobre o uso Buffer.BlockCopyexcessivo Array.Copy?

Como os parâmetros Buffer.BlockCopysão baseados em bytes e não em índice, é mais provável que você estrague seu código do que se você usar Array.Copy, então eu usaria apenas Buffer.BlockCopyem uma seção crítica do desempenho do meu código.

Prelúdio

Estou entrando na festa tarde, mas com 32 mil visualizações, vale a pena fazer isso direito. A maioria do código de marca de microbench nas respostas postadas até agora sofre de uma ou mais falhas técnicas graves, incluindo não mover alocações de memória para fora dos loops de teste (que introduz artefatos graves de GC), não testar fluxos de execução variáveis ​​versus determinísticos, aquecimento do JIT, e não rastrear a variabilidade intra-teste. Além disso, a maioria das respostas não testou os efeitos de tamanhos variados de buffer e tipos primitivos variados (em relação aos sistemas de 32 ou 64 bits). Para abordar essa questão de maneira mais abrangente, vinculei-a a uma estrutura de microbenchmarking personalizada que desenvolvi que reduz a maior parte das "dicas" comuns na medida do possível. Os testes foram executados no modo de versão .NET 4.0 em máquinas de 32 bits e de 64 bits. A média dos resultados foi de mais de 20 execuções de teste, nas quais cada execução teve 1 milhão de tentativas por método. Os tipos primitivos testados forambyte(1 byte), int(4 bytes) e double(8 bytes). Três métodos foram testados: Array.Copy(), Buffer.BlockCopy(), e simples de atribuição num ciclo per-índice. Os dados são muito volumosos para serem postados aqui, então vou resumir os pontos importantes.

The Takeaways

• Se o comprimento do tampão é de cerca de 75-100 ou menos, uma rotina exemplar circuito explícito é geralmente mais rápida (cerca de 5%) do que qualquer um Array.Copy()ou Buffer.BlockCopy()para todos os 3 tipos de primitivas testadas em ambas as máquinas de 32 bits e de 64 bits. Além disso, a rotina de cópia de loop explícita tem uma variação notavelmente menor no desempenho em comparação com as duas alternativas. O bom desempenho é quase certamente devido à localidade de referência explorada pelo cache de memória CPU L1 / L2 / L3 em conjunto com nenhuma sobrecarga de chamada de método.
  • Somente para doublebuffers em máquinas de 32 bits : A rotina de cópia de loop explícita é melhor que as duas alternativas para todos os tamanhos de buffer testados até 100k. A melhoria é 3-5% melhor que os outros métodos. Isso ocorre porque o desempenho Array.Copy()e Buffer.BlockCopy()fica totalmente degradado ao passar a largura nativa de 32 bits. Portanto, presumo que o mesmo efeito se aplicaria aos longbuffers também.
• Para tamanhos de buffer que excedem ~ 100, a cópia explícita do loop rapidamente se torna muito mais lenta que os outros 2 métodos (com a única exceção específica mencionada). A diferença é mais notável em byte[]que a cópia explícita de loop pode se tornar 7x ou mais lenta em tamanhos de buffer grandes.
• Em geral, para todos os três tipos primitivos testados e em todos os tamanhos de buffer, Array.Copy()e Buffer.BlockCopy()executados quase de forma idêntica. Em média, Array.Copy()parece ter uma margem muito pequena de cerca de 2% ou menos do tempo gasto (mas é típico de 0,2% a 0,5% melhor), embora Buffer.BlockCopy()ocasionalmente o superasse. Por razões desconhecidas, Buffer.BlockCopy()apresenta uma variabilidade intra-teste notavelmente maior que Array.Copy(). Esse efeito não pôde ser eliminado, apesar de eu tentar várias mitigações e não ter uma teoria operacional sobre o porquê.
• Por Array.Copy()ser um método "mais inteligente", mais geral e muito mais seguro, além de ser um pouco mais rápido e com menor variabilidade em média, deve ser preferido Buffer.BlockCopy()em quase todos os casos comuns. O único caso de uso em Buffer.BlockCopy()que será significativamente melhor é quando os tipos de valores da matriz de origem e de destino são diferentes (como apontado na resposta de Ken Smith). Embora esse cenário não seja comum, ele Array.Copy()pode ter um desempenho muito ruim aqui devido à conversão contínua do tipo de valor "seguro", em comparação à conversão direta de Buffer.BlockCopy().
• Evidência adicional externa do StackOverflow, que Array.Copy()é mais rápida do que Buffer.BlockCopy()a cópia de matriz do mesmo tipo, pode ser encontrada aqui .

Outro exemplo de quando faz sentido usar Buffer.BlockCopy()é quando você recebe uma matriz de primitivas (digamos, shorts) e precisa convertê-lo em uma matriz de bytes (digamos, para transmissão em uma rede). Uso esse método frequentemente ao lidar com áudio do Silverlight AudioSink. Ele fornece a amostra como uma short[]matriz, mas você precisa convertê-la em uma byte[]matriz ao criar o pacote ao qual você envia Socket.SendAsync(). Você pode usar BitConvertere percorrer a matriz um por um, mas é muito mais rápido (cerca de 20x nos meus testes) apenas para fazer isso:

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

E o mesmo truque também funciona ao contrário:

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

Isso é o mais próximo que você obtém do C # seguro do (void *)tipo de gerenciamento de memória tão comum em C e C ++.

Com base nos meus testes, o desempenho não é um motivo para preferir Buffer.BlockCopy sobre Array.Copy. Do meu teste Array.Copy é realmente mais rápido que 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));

Saída de exemplo:

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 é mais inteligente que BlockCopy. Ele descobre como copiar elementos se a origem e o destino forem da mesma matriz.

Se preenchermos uma matriz int com 0,1,2,3,4 e aplicamos:

Array.Copy (matriz, 0, matriz, 1, matriz.Comprimento - 1);

terminamos com 0,0,1,2,3 conforme o esperado.

Tente isso com o BlockCopy e obteremos: 0,0,2,3,4. Se eu atribuir array[0]=-1depois disso, ele se tornará -1,0,2,3,4 conforme o esperado, mas se o comprimento da matriz for par, como 6, obteremos -1,256,2,3,4,5. Coisas perigosas. Não use o BlockCopy além de copiar uma matriz de bytes para outra.

Há outro caso em que você só pode usar Array.Copy: se o tamanho da matriz for maior que 2 ^ 31. Array.Copy tem uma sobrecarga com um longparâmetro de tamanho. BlockCopy não tem isso.

Para refletir sobre esse argumento, se alguém não tomar cuidado com a forma como cria esse benchmark, pode ser facilmente enganado. Eu escrevi um teste muito simples para ilustrar isso. No meu teste abaixo, se eu trocar a ordem dos meus testes entre iniciar o Buffer.BlockCopy primeiro ou Array.Copy, o que for primeiro é quase sempre o mais lento (embora seja próximo). Isso significa que, por várias razões em que não vou simplesmente executar os testes várias vezes, um após o outro não fornecerá resultados precisos.

Eu tentei manter o teste como está com 1000000 tentativas cada uma para uma matriz de 1000000 duplas seqüenciais. No entanto, desconsiderei os primeiros 900000 ciclos e calculei a média do restante. Nesse caso, o buffer é superior.

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

Só quero adicionar meu caso de teste, que mostra novamente que o BlockCopy não possui o benefício 'DESEMPENHO' sobre o Array.Copy. Eles parecem ter o mesmo desempenho no modo de liberação na minha máquina (ambos levam cerca de 66ms para copiar 50 milhões de números inteiros). No modo de depuração, o BlockCopy é apenas um pouco mais rápido.

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