Array.Copy vs Buffer.BlockCopy

Array.Copy und Buffer.BlockCopy machen beide dasselbe, BlockCopyzielen jedoch auf schnelles primitives Array-Kopieren auf Byte-Ebene ab, während dies Copydie allgemeine Implementierung ist. Meine Frage ist - unter welchen Umständen sollten Sie verwenden BlockCopy? Sollten Sie es zu irgendeinem Zeitpunkt verwenden, wenn Sie Arrays vom primitiven Typ kopieren, oder sollten Sie es nur verwenden, wenn Sie für die Leistung codieren? Ist die Verwendung von Buffer.BlockCopyOver von Natur aus gefährlich Array.Copy?

Da die Parameter Buffer.BlockCopyeher bytebasiert als indexbasiert sind, ist es wahrscheinlicher, dass Sie Ihren Code vermasseln, als wenn Sie ihn verwenden Array.Copy. Daher würde ich ihn nur Buffer.BlockCopyin einem leistungskritischen Abschnitt meines Codes verwenden.

Auftakt

Ich bin spät auf der Party, aber mit 32.000 Views lohnt es sich, das richtig zu machen. Der größte Teil des Mikrobenchmarking-Codes in den bisher veröffentlichten Antworten weist einen oder mehrere schwerwiegende technische Mängel auf, darunter das Nichtverschieben von Speicherzuordnungen aus den Testschleifen (was zu schwerwiegenden GC-Artefakten führt), das Nicht-Testen von variablen vs. deterministischen Ausführungsabläufen, JIT-Aufwärmen, und nicht die Variabilität innerhalb des Tests verfolgen. Darüber hinaus testeten die meisten Antworten nicht die Auswirkungen unterschiedlicher Puffergrößen und unterschiedlicher primitiver Typen (in Bezug auf 32-Bit- oder 64-Bit-Systeme). Um diese Frage umfassender zu beantworten, habe ich sie an ein von mir entwickeltes benutzerdefiniertes Microbenchmarking-Framework angeschlossen, das die meisten gängigen "Fallstricke" so weit wie möglich reduziert. Die Tests wurden im .NET 4.0-Release-Modus sowohl auf einem 32-Bit-Computer als auch auf einem 64-Bit-Computer ausgeführt. Die Ergebnisse wurden über 20 Testläufe gemittelt, in denen jeder Lauf 1 Million Versuche pro Methode aufwies. Die getesteten primitiven Typen warenbyte(1 Byte), int(4 Byte) und double(8 Byte). Drei Methoden wurden getestet: Array.Copy(), Buffer.BlockCopy()und einfach per-Indexzuordnung in einer Schleife. Die Daten sind zu umfangreich, um hier veröffentlicht zu werden, daher werde ich die wichtigen Punkte zusammenfassen.

Die Imbissbuden

• Wenn Ihre Pufferlänge etwa 75-100 oder weniger beträgt, ist eine explizite Schleifenkopierroutine normalerweise schneller (um etwa 5%) als einer Array.Copy()oder Buffer.BlockCopy()alle drei primitiven Typen, die sowohl auf 32-Bit- als auch auf 64-Bit-Computern getestet wurden. Darüber hinaus weist die explizite Schleifenkopierroutine im Vergleich zu den beiden Alternativen eine deutlich geringere Variabilität der Leistung auf. Die gute Leistung ist fast sicher auf die Lokalität der Referenz zurückzuführen, die vom Speicher-Caching der CPU L1 / L2 / L3 in Verbindung mit keinem Overhead für Methodenaufrufe ausgenutzt wird.
  • Nur für doublePuffer auf 32-Bit-Computern : Die explizite Schleifenkopierroutine ist für alle getesteten Puffergrößen bis zu 100.000 besser als beide Alternativen. Die Verbesserung ist 3-5% besser als bei den anderen Methoden. Dies liegt daran, dass die Leistung von Array.Copy()und das Buffer.BlockCopy()Übergeben der nativen 32-Bit-Breite vollständig beeinträchtigt wird. Daher gehe ich davon aus, dass der gleiche Effekt auch für longPuffer gelten würde .
• Bei Puffergrößen über ~ 100 wird das explizite Kopieren von Schleifen schnell viel langsamer als bei den beiden anderen Methoden (mit der einen Ausnahme, die gerade erwähnt wurde). Der Unterschied ist am deutlichsten bei byte[], wo das explizite Kopieren von Schleifen bei großen Puffergrößen 7x oder langsamer werden kann.
• Im Allgemeinen für alle 3 getesteten primitiven Typen und über alle Puffergrößen hinweg Array.Copy()und Buffer.BlockCopy()nahezu identisch durchgeführt. Im Durchschnitt Array.Copy()scheint eine sehr leichte Kante von etwa 2% oder weniger Zeit in Anspruch genommen zu haben (aber 0,2% - 0,5% besser ist typisch), obwohl Buffer.BlockCopy()sie gelegentlich geschlagen wurde. Hat aus unbekannten Gründen Buffer.BlockCopy()eine deutlich höhere Variabilität innerhalb des Tests als Array.Copy(). Dieser Effekt konnte nicht beseitigt werden, obwohl ich mehrere Abschwächungen versuchte und keine funktionsfähige Theorie darüber hatte, warum.
• Da Array.Copy()es sich um eine "intelligentere", allgemeinere und viel sicherere Methode handelt, die nicht nur geringfügig schneller ist und im Durchschnitt eine geringere Variabilität aufweist, sollte sie Buffer.BlockCopy()in fast allen gängigen Fällen vorgezogen werden. Der einzige Anwendungsfall Buffer.BlockCopy(), der wesentlich besser ist, besteht darin, dass die Werttypen des Quell- und Zielarrays unterschiedlich sind (wie in Ken Smiths Antwort ausgeführt). Obwohl dieses Szenario nicht üblich ist, Array.Copy()kann es hier aufgrund des kontinuierlichen "sicheren" Wertgusstyps im Vergleich zum direkten Gießen von sehr schlecht abschneiden Buffer.BlockCopy().
• Weitere Hinweise von außerhalb von StackOverflow, Array.Copy()die schneller sind als Buffer.BlockCopy()beim Kopieren von Arrays gleichen Typs, finden Sie hier .

Ein weiteres Beispiel für die Verwendung Buffer.BlockCopy()ist, wenn Sie ein Array von Grundelementen (z. B. Kurzschlüsse) erhalten und dieses in ein Array von Bytes konvertieren müssen (z. B. für die Übertragung über ein Netzwerk). Ich verwende diese Methode häufig, wenn ich mit Audio vom Silverlight AudioSink arbeite. Das Beispiel wird als short[]Array bereitgestellt, Sie müssen es jedoch in ein byte[]Array konvertieren, wenn Sie das Paket erstellen, an das Sie senden Socket.SendAsync(). Sie können BitConverterdas Array einzeln verwenden und durchlaufen, aber es ist viel schneller (ungefähr 20x in meinen Tests), nur um dies zu tun:

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

Und der gleiche Trick funktioniert auch umgekehrt:

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

Dies ist ungefähr so ​​nah wie in sicherem C # an der (void *)in C und C ++ üblichen Art der Speicherverwaltung.

Aufgrund meiner Tests ist die Leistung kein Grund, Buffer.BlockCopy Array.Copy vorzuziehen. Nach meinem Test ist Array.Copy tatsächlich schneller als 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));

Beispielausgabe:

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 ist schlauer als BlockCopy. Es wird herausgefunden, wie Elemente kopiert werden, wenn Quelle und Ziel dasselbe Array sind.

Wenn wir ein int-Array mit 0,1,2,3,4 füllen und anwenden:

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

Am Ende haben wir erwartungsgemäß 0,0,1,2,3.

Versuchen Sie dies mit BlockCopy und wir erhalten: 0,0,2,3,4. Wenn ich array[0]=-1danach zuweise, wird es wie erwartet -1,0,2,3,4, aber wenn die Array-Länge gerade ist, wie 6, erhalten wir -1,256,2,3,4,5. Gefährliches Zeug. Verwenden Sie BlockCopy nur zum Kopieren eines Byte-Arrays in ein anderes.

Es gibt einen anderen Fall, in dem Sie Array.Copy nur verwenden können: Wenn die Arraygröße länger als 2 ^ 31 ist. Array.Copy hat eine Überladung mit einem Größenparameter long. BlockCopy hat das nicht.

Um dieses Argument abzuwägen: Wenn man nicht aufpasst, wie sie diesen Benchmark erstellen, können sie leicht irregeführt werden. Ich habe einen sehr einfachen Test geschrieben, um dies zu veranschaulichen. Wenn ich in meinem Test unten die Reihenfolge meiner Tests zwischen dem Starten von Buffer.BlockCopy zuerst oder Array.Copy vertausche, ist diejenige, die zuerst geht, fast immer die langsamste (obwohl es eine enge ist). Dies bedeutet, dass ich aus einer Reihe von Gründen, auf die ich nicht eingehen werde, die Tests einfach mehrmals ausführen werde, insbesondere nacheinander, keine genauen Ergebnisse liefert.

Ich habe darauf zurückgegriffen, den Test so beizubehalten, wie er bei jeweils 1000000 Versuchen für ein Array von 1000000 sequentiellen Doppeln ist. Allerdings ignoriere ich dann dann die ersten 900000 Zyklen und mittle den Rest. In diesem Fall ist der Puffer überlegen.

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

Ich möchte nur meinen Testfall hinzufügen, der erneut zeigt, dass BlockCopy keinen 'PERFORMANCE'-Vorteil gegenüber Array.Copy hat. Sie scheinen im Release-Modus auf meinem Computer dieselbe Leistung zu haben (beide benötigen ungefähr 66 ms, um 50 Millionen Ganzzahlen zu kopieren). Im Debug-Modus ist BlockCopy nur geringfügig schneller.

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