Array.Copy et Buffer.BlockCopy

Array.Copy et Buffer.BlockCopy font tous deux la même chose, mais BlockCopyvisent à une copie rapide de tableaux primitifs au niveau des octets, alors que Copyc'est l'implémentation à usage général. Ma question est - dans quelles circonstances devriez-vous utiliser BlockCopy? Devez-vous l'utiliser à tout moment lorsque vous copiez des tableaux de types primitifs, ou devriez-vous l'utiliser uniquement si vous codez pour les performances? Y a-t-il quelque chose de intrinsèquement dangereux à utiliser Buffer.BlockCopyover Array.Copy?

Étant donné que les paramètres Buffer.BlockCopysont basés sur des octets plutôt que sur des index, vous êtes plus susceptible de bousiller votre code que si vous les utilisez Array.Copy, donc je ne les utiliserais que Buffer.BlockCopydans une section critique pour les performances de mon code.

Prélude

Je rejoins la fête tardivement, mais avec 32k vues, cela vaut la peine de bien faire les choses. La plupart du code de microbenchmarking dans les réponses publiées jusqu'à présent souffrent d'une ou plusieurs failles techniques graves, notamment le fait de ne pas déplacer les allocations de mémoire hors des boucles de test (ce qui introduit de graves artefacts GC), de ne pas tester les flux d'exécution variables ou déterministes, le préchauffage JIT, et ne pas suivre la variabilité intra-test. En outre, la plupart des réponses ne testaient pas les effets des différentes tailles de tampon et des différents types de primitifs (par rapport aux systèmes 32 bits ou 64 bits). Pour aborder cette question de manière plus complète, je l'ai connectée à un cadre de microbenchmarking personnalisé que j'ai développé et qui réduit la plupart des «pièges» courants dans la mesure du possible. Les tests ont été exécutés en mode de version .NET 4.0 sur une machine 32 bits et une machine 64 bits. Les résultats ont été en moyenne sur 20 séries de tests, dans lesquelles chaque série comportait 1 million d'essais par méthode. Les types primitifs testés étaientbyte(1 octet), int(4 octets) et double(8 octets). Trois méthodes ont été testées: Array.Copy(), Buffer.BlockCopy(), et simple affectation par index dans une boucle. Les données sont trop volumineuses pour être publiées ici, je vais donc résumer les points importants.

Les plats à emporter

• Si la longueur de votre tampon est d'environ 75-100 ou moins, une routine de copie de boucle explicite est généralement plus rapide (d'environ 5%) que l'un Array.Copy()ou l' autre ou Buffer.BlockCopy()pour les 3 types primitifs testés sur les machines 32 bits et 64 bits. De plus, la routine de copie de boucle explicite présente une variabilité de performances nettement inférieure par rapport aux deux alternatives. Les bonnes performances sont presque sûrement dues à la localité de référence exploitée par la mise en cache de la mémoire CPU L1 / L2 / L3 en conjonction avec aucune surcharge d'appel de méthode.
  • Pour les doubletampons sur les machines 32 bits uniquement : la routine de copie en boucle explicite est meilleure que les deux alternatives pour toutes les tailles de tampon testées jusqu'à 100 Ko. L'amélioration est de 3 à 5% meilleure que les autres méthodes. Cela est dû au fait que les performances de Array.Copy()et Buffer.BlockCopy()deviennent totalement dégradées lors du dépassement de la largeur native de 32 bits. Je suppose donc que le même effet s'appliquerait également aux longtampons.
• Pour des tailles de tampon dépassant ~ 100, la copie en boucle explicite devient rapidement beaucoup plus lente que les 2 autres méthodes (avec la seule exception qui vient d'être notée). La différence est la plus notable avec byte[], où la copie en boucle explicite peut devenir 7x ou plus lente avec de grandes tailles de tampon.
• En général, pour les 3 types primitifs testés et dans toutes les tailles de tampon, Array.Copy()et Buffer.BlockCopy()effectué presque de manière identique. En moyenne, Array.Copy()semble avoir un très léger avantage d'environ 2% ou moins de temps (mais 0,2% à 0,5% de mieux est typique), bien qu'il l' Buffer.BlockCopy()ait parfois battu. Pour des raisons inconnues, Buffer.BlockCopy()a une variabilité intra-test sensiblement plus élevée que Array.Copy(). Cet effet n'a pas pu être éliminé bien que j'aie essayé de multiples atténuations et que je n'ai pas de théorie exploitable sur le pourquoi.
• Parce qu'il Array.Copy()s'agit d'une méthode "plus intelligente", plus générale et beaucoup plus sûre, en plus d'être très légèrement plus rapide et d'avoir moins de variabilité en moyenne, elle devrait être préférée Buffer.BlockCopy()dans presque tous les cas courants. Le seul cas d'utilisation où ce Buffer.BlockCopy()sera nettement meilleur est celui où les types de valeurs de tableau source et destination sont différents (comme indiqué dans la réponse de Ken Smith). Bien que ce scénario ne soit pas courant, il Array.Copy()peut fonctionner très mal ici en raison de la conversion continue de type valeur «sûre», par rapport à la distribution directe de Buffer.BlockCopy().
• Des preuves supplémentaires provenant de l'extérieur de StackOverflow qui Array.Copy()sont plus rapides que Buffer.BlockCopy()pour la copie de tableau de même type peuvent être trouvées ici .

Un autre exemple où il est judicieux d'utiliser Buffer.BlockCopy()est lorsque vous êtes fourni avec un tableau de primitives (par exemple, des courts-circuits) et que vous devez le convertir en un tableau d'octets (par exemple, pour une transmission sur un réseau). J'utilise fréquemment cette méthode lorsque je traite l'audio du Silverlight AudioSink. Il fournit l'exemple sous forme de short[]tableau, mais vous devez le convertir en byte[]tableau lorsque vous créez le paquet auquel vous soumettez Socket.SendAsync(). Vous pouvez utiliser BitConverteret parcourir le tableau un par un, mais c'est beaucoup plus rapide (environ 20x dans mes tests) juste pour faire ceci:

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

Et la même astuce fonctionne également en sens inverse:

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

C'est à peu près aussi proche que vous obtenez en C # sécurisé du (void *)type de gestion de la mémoire qui est si courant en C et C ++.

D'après mes tests, les performances ne sont pas une raison pour préférer Buffer.BlockCopy à Array.Copy. D'après mes tests, Array.Copy est en fait plus rapide 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));

Exemple de sortie:

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 est plus intelligent que BlockCopy. Il explique comment copier des éléments si la source et la destination sont le même tableau.

Si nous remplissons un tableau int avec 0,1,2,3,4 et appliquons:

Array.Copy (tableau, 0, tableau, 1, tableau.Longueur - 1);

nous nous retrouvons avec 0,0,1,2,3 comme prévu.

Essayez ceci avec BlockCopy et nous obtenons: 0,0,2,3,4. Si array[0]=-1j'assigne après cela, cela devient -1,0,2,3,4 comme prévu, mais si la longueur du tableau est paire, comme 6, nous obtenons -1,256,2,3,4,5. Des trucs dangereux. N'utilisez BlockCopy que pour copier un tableau d'octets dans un autre.

Il existe un autre cas où vous ne pouvez utiliser Array.Copy: si la taille du tableau est plus longue que 2 ^ 31. Array.Copy a une surcharge avec un longparamètre de taille. BlockCopy n'a pas cela.

Pour peser sur cet argument, si l'on ne fait pas attention à la manière dont ils créent ce repère, ils pourraient facilement être induits en erreur. J'ai écrit un test très simple pour illustrer cela. Dans mon test ci-dessous, si je permute l'ordre de mes tests entre le démarrage de Buffer.BlockCopy en premier ou Array.Copy celui qui commence est presque toujours le plus lent (bien que ce soit un proche). Cela signifie que pour un tas de raisons que je n'entrerai pas dans le simple fait d'exécuter les tests plusieurs fois, les uns après les autres ne donneront pas de résultats précis.

J'ai eu recours au maintien du test tel quel avec 1000000 essais chacun pour un tableau de 1000000 doubles séquentiels. Cependant, je néglige ensuite les 900000 premiers cycles et fait la moyenne du reste. Dans ce cas, le tampon est supérieur.

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

Je veux juste ajouter mon cas de test qui montre à nouveau que BlockCopy n'a aucun avantage 'PERFORMANCE' sur Array.Copy. Ils semblent avoir les mêmes performances en mode release sur ma machine (les deux prennent environ 66 ms pour copier 50 millions d'entiers). En mode débogage, BlockCopy est légèrement plus rapide.

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