Array.Copy vs Buffer.BlockCopy

Array.Copy i Buffer.BlockCopy robią to samo, ale BlockCopymają na celu szybkie kopiowanie tablic pierwotnych na poziomie bajtów, podczas gdy Copyjest to implementacja ogólnego przeznaczenia. Moje pytanie brzmi - w jakich okolicznościach należy używać BlockCopy? Czy należy go używać w dowolnym momencie podczas kopiowania tablic typów pierwotnych, czy też należy go używać tylko wtedy, gdy kodujesz pod kątem wydajności? Czy jest coś z natury niebezpiecznego w używaniu Buffer.BlockCopywięcej Array.Copy?

Ponieważ parametry Buffer.BlockCopysą oparte na bajtach, a nie na indeksach, bardziej prawdopodobne jest, że zepsujesz kod, niż gdybyś używał Array.Copy, więc użyłbym tylko Buffer.BlockCopyw sekcji mojego kodu krytycznej dla wydajności.

Preludium

Dołączam do imprezy późno, ale przy 32 tysiącach wyświetleń warto zrobić to dobrze. Większość kodu mikroznakowania w opublikowanych dotychczas odpowiedziach ma jedną lub więcej poważnych błędów technicznych, w tym brak przenoszenia alokacji pamięci poza pętle testowe (co wprowadza poważne artefakty GC), brak testowania zmiennych a deterministyczne przepływy wykonywania, rozgrzewka JIT, a nie śledzenie zmienności wewnątrztestowej. Ponadto w większości odpowiedzi nie testowano skutków różnych rozmiarów buforów i różnych typów pierwotnych (w odniesieniu do systemów 32-bitowych lub 64-bitowych). Aby bardziej kompleksowo odpowiedzieć na to pytanie, podłączyłem go do opracowanego przeze mnie niestandardowego schematu mikroznakowania, który ogranicza większość typowych „pułapek” w możliwie największym stopniu. Testy przeprowadzono w trybie wydania platformy .NET 4.0 zarówno na komputerze 32-bitowym, jak i 64-bitowym. Wyniki uśredniono z 20 serii testowych, z których każdy miał 1 milion prób na metodę. Testowane były typy prymitywnebyte(1 bajt), int(4 bajty) i double(8 bajtów). Badano trzy sposoby: Array.Copy(), Buffer.BlockCopy()i proste zadanie za indeksowanie w pętli. Dane są zbyt obszerne, aby je tutaj opublikować, więc podsumuję najważniejsze punkty.

Na wynos

• Jeśli długość twojego bufora wynosi około 75-100 lub mniej, jawna procedura kopiowania w pętli jest zwykle szybsza (o około 5%) niż jeden Array.Copy()lub Buffer.BlockCopy()wszystkie 3 typy pierwotne testowane na komputerach 32-bitowych i 64-bitowych. Ponadto jawna procedura kopiowania w pętli ma zauważalnie mniejszą zmienność wydajności w porównaniu z dwiema alternatywami. Dobra wydajność jest prawie na pewno spowodowana lokalnością odniesienia wykorzystywaną przez buforowanie pamięci CPU L1 / L2 / L3 w połączeniu z brakiem narzutu wywołania metody.
  • Tylko dla doublebuforów na komputerach 32-bitowych : jawna procedura kopiowania w pętli jest lepsza niż obie alternatywy dla wszystkich testowanych rozmiarów buforów do 100 KB. Poprawa jest o 3-5% lepsza niż w przypadku innych metod. Dzieje się tak, ponieważ wydajność Array.Copy()i Buffer.BlockCopy()zostaje całkowicie obniżona po przejściu natywnej 32-bitowej szerokości. Dlatego zakładam, że ten sam efekt miałby również zastosowanie do longbuforów.
• W przypadku rozmiarów buforów przekraczających ~ 100, jawne kopiowanie w pętli szybko staje się znacznie wolniejsze niż pozostałe 2 metody (z jednym konkretnym wyjątkiem, który właśnie wspomniano). Różnica jest najbardziej zauważalna w byte[]przypadku, gdy jawne kopiowanie w pętli może stać się 7x lub wolniejsze przy dużych rozmiarach buforów.
• Ogólnie rzecz biorąc, dla wszystkich 3 typów pierwotnych przetestowanych i dla wszystkich rozmiarów buforów Array.Copy()i Buffer.BlockCopy()wykonanych prawie identycznie. Średnio Array.Copy()wydaje się mieć bardzo niewielką przewagę wynoszącą około 2% lub mniej czasu potrzebnego (ale 0,2% - 0,5% lepiej jest typowe), chociaż Buffer.BlockCopy()czasami go pokonuje. Z nieznanych powodów Buffer.BlockCopy()ma zauważalnie większą zmienność wewnątrztestową niż Array.Copy(). Tego efektu nie udało się wyeliminować, mimo że próbowałem wielu środków zaradczych i nie miałem działającej teorii, dlaczego.
• Ponieważ Array.Copy()jest to „mądrzejsza”, ogólniejsza i znacznie bezpieczniejsza metoda, oprócz tego, że jest bardzo nieznacznie szybsza i średnio ma mniejszą zmienność, powinna być preferowana Buffer.BlockCopy()w prawie wszystkich typowych przypadkach. Jedynym przypadkiem użycia, w którym Buffer.BlockCopy()będzie znacznie lepszy, jest sytuacja, gdy typy wartości tablicy źródłowej i docelowej są różne (jak wskazano w odpowiedzi Kena Smitha). Chociaż ten scenariusz nie jest powszechny, Array.Copy()może tutaj działać bardzo słabo ze względu na ciągłe rzutowanie typu „bezpiecznego” typu wartości w porównaniu z rzutowaniem bezpośrednim Buffer.BlockCopy().
• Dodatkowe dowody z zewnątrz StackOverflow, które Array.Copy()są szybsze niż w Buffer.BlockCopy()przypadku kopiowania tablic tego samego typu, można znaleźć tutaj .

Innym przykładem sensownego użycia Buffer.BlockCopy()jest sytuacja, w której otrzymujesz tablicę prymitywów (powiedzmy, short) i musisz przekonwertować ją na tablicę bajtów (powiedzmy, do transmisji przez sieć). Często używam tej metody, gdy mam do czynienia z dźwiękiem z Silverlight AudioSink. Dostarcza próbkę jako short[]tablicę, ale musisz ją przekonwertować na byte[]tablicę podczas budowania pakietu, do którego przesyłasz Socket.SendAsync(). Możesz użyć BitConverteri iterować po tablicy jeden po drugim, ale jest to o wiele szybsze (około 20x w moich testach), aby zrobić to:

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

Ta sama sztuczka działa również w odwrotnej kolejności:

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

Jest to tak bliskie, jak w bezpiecznym C #, (void *)rodzaju zarządzania pamięcią, które jest tak powszechne w C i C ++.

Na podstawie moich testów wydajność nie jest powodem do preferowania Buffer.BlockCopy nad Array.Copy. Z mojego testu Array.Copy jest faktycznie szybszy niż 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));

Przykładowe dane wyjściowe:

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 jest inteligentniejszy niż BlockCopy. Dowiaduje się, jak skopiować elementy, jeśli źródło i miejsce docelowe są tą samą tablicą.

Jeśli wypełnimy tablicę int 0,1,2,3,4 i zastosujemy:

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

zgodnie z oczekiwaniami otrzymujemy 0,0,1,2,3.

Spróbuj tego z BlockCopy i otrzymamy: 0,0,2,3,4. Jeśli przypiszę array[0]=-1po tym, otrzymamy -1,0,2,3,4 zgodnie z oczekiwaniami, ale jeśli długość tablicy jest parzysta, np. 6, otrzymamy -1,256,2,3,4,5. Niebezpieczne rzeczy. Nie używaj BlockCopy inaczej niż do kopiowania jednej tablicy bajtów do drugiej.

Istnieje inny przypadek, w którym możesz użyć tylko Array.Copy: jeśli rozmiar tablicy jest dłuższy niż 2 ^ 31. Array.Copy ma przeciążenie z longparametrem rozmiaru. BlockCopy tego nie ma.

Aby rozważyć ten argument, jeśli ktoś nie jest ostrożny, w jaki sposób tworzą ten wzorzec, może łatwo zostać wprowadzony w błąd. Aby to zilustrować, napisałem bardzo prosty test. W moim teście poniżej, jeśli zamienię kolejność moich testów między uruchomieniem Buffer.BlockCopy najpierw lub Array.Copy, ten, który idzie pierwszy, jest prawie zawsze najwolniejszy (chociaż jest bliski). Oznacza to, że z wielu powodów, którym nie będę się zajmować, po prostu wielokrotne przeprowadzanie testów, szczególnie jeden po drugim, nie da dokładnych wyników.

Uciekłem się do utrzymania testu, tak jak w przypadku 1000000 prób dla tablicy 1000000 sekwencyjnych podwójnych. Jednak w tym czasie pomijam pierwsze 900000 cykli, a resztę uśredniam. W takim przypadku bufor jest lepszy.

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

Chcę tylko dodać mój przypadek testowy, który ponownie pokazuje, że BlockCopy nie ma przewagi „PERFORMANCE” w porównaniu z Array.Copy. Wydaje się, że mają taką samą wydajność w trybie wydania na moim komputerze (kopiowanie 50 milionów liczb całkowitych trwa około 66 ms). W trybie debugowania BlockCopy jest tylko nieznacznie szybsze.

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