Array.Copy ve Buffer.BlockCopy

Array.Copy ve Buffer.BlockCopy aynı şeyi yapar, ancak BlockCopyhızlı bayt düzeyinde ilkel dizi kopyalamayı Copyhedeflerken, genel amaçlı uygulama. Sorum şu - hangi durumlarda kullanmalısınız BlockCopy? İlkel tür dizileri kopyalarken herhangi bir zamanda mı kullanmalısınız yoksa yalnızca performans için kodlama yapıyorsanız mı kullanmalısınız? Buffer.BlockCopyOver kullanmanın doğası gereği tehlikeli bir şey var mı Array.Copy?

Parametreler Buffer.BlockCopyindeks tabanlı değil bayt tabanlı olduğundan, kodunuzu kullanmaktan çok bozma olasılığınız daha yüksektir Array.Copy, bu nedenle kodumun yalnızca Buffer.BlockCopyperformans açısından kritik bir bölümünde kullanırım.

başlangıç

Partiye geç katılıyorum, ancak 32 bin görüşle bunu doğru yapmaya değer. Şimdiye kadar gönderilen yanıtlardaki mikro kıyaslama kodlarının çoğu, bellek ayırmalarını test döngülerinden çıkarmamak (ciddi GC yapaylıkları ortaya çıkarır), değişkene karşı deterministik yürütme akışlarını test etmemek, JIT ısınması dahil olmak üzere bir veya daha fazla ciddi teknik kusurdan muzdariptir. ve test içi değişkenliği izlemiyor. Ek olarak, çoğu yanıt, değişen tampon boyutlarının ve değişen ilkel türlerin (32 bit veya 64 bit sistemlere göre) etkilerini test etmedi. Bu soruyu daha kapsamlı bir şekilde ele almak için, bunu, yaygın "sorunların" çoğunu mümkün olduğu kadar azaltan, geliştirdiğim özel bir mikro kıyaslama çerçevesine bağladım. Testler, hem 32 bit makinede hem de 64 bit makinede .NET 4.0 Sürüm modunda çalıştırıldı. Sonuçların ortalaması, her çalıştırmada yöntem başına 1 milyon deneme içeren 20 test çalışmasının ortalaması alınmıştır. Test edilen ilkel türlerbyte(1 bayt), int(4 bayt) ve double(8 bayt). Üç yöntem test edildi: Array.Copy(), Buffer.BlockCopy()bir döngü içinde, ve basit başına endeksi atama. Veriler buraya gönderilemeyecek kadar büyük, bu yüzden önemli noktaları özetleyeceğim.

Çıkarımlar

• Arabellek uzunluğunuz yaklaşık 75-100 veya daha azsa, açık bir döngü kopyalama yordamı genellikle hem 32 bit hem de 64 bit makinelerde test edilen 3 ilkel türden biri Array.Copy()veya Buffer.BlockCopy()hepsinden daha hızlıdır (yaklaşık% 5 oranında) . Ek olarak, açık döngü kopya rutini, iki alternatife kıyasla performansta önemli ölçüde daha düşük değişkenliğe sahiptir. İyi performans, neredeyse kesin olarak , CPU L1 / L2 / L3 bellek önbelleği tarafından hiçbir yöntem çağrısı ek yükü olmadan kullanılan referans yerelliğinden kaynaklanmaktadır .
  • İçin doubletampon 32 bit makinelerde yalnızca : açık döngü kopya rutin tüm tampon için her iki alternatifleri 100k kadar test boyutları daha iyidir. İyileşme diğer yöntemlere göre% 3-5 daha iyidir. Bunun nedeni, yerel 32 bit genişliğini geçtikten sonra performansının tamamen düşmesi Array.Copy()ve Buffer.BlockCopy()azalmasıdır. Bu nedenle, aynı etkinin longtamponlar için de geçerli olacağını varsayıyorum .
• ~ 100'ü aşan arabellek boyutları için, açık döngü kopyalama diğer 2 yöntemden çok daha yavaş hale gelir (az önce belirtilen özel bir istisna dışında). Fark en çok byte[], açık döngü kopyalamanın büyük arabellek boyutlarında 7x veya daha yavaş olabileceği durumlarda belirgindir.
• Genel olarak, test edilen 3 ilkel türün tümü için ve tüm tampon boyutlarında Array.Copy()ve Buffer.BlockCopy()neredeyse aynı şekilde gerçekleştirildi. Ortalama olarak, Array.Copy()yaklaşık% 2 veya daha az zaman gibi çok hafif bir kenar var gibi görünmektedir (ancak% 0,2 -% 0,5 daha iyi tipiktir), ancak Buffer.BlockCopy()ara sıra onu geçmiştir. Bilinmeyen nedenlerden dolayı, Buffer.BlockCopy()test içi değişkenliğe göre belirgin şekilde daha yüksek Array.Copy(). Birden fazla hafifletme denememe ve neden olduğuna dair uygulanabilir bir teoriye sahip olmama rağmen bu etki ortadan kaldırılamadı.
• Çünkü Array.Copy()çok biraz daha hızlı olması ve ortalama olarak daha az değişkenliği sahip olmanın yanı sıra bir "akıllı" daha genel ve daha güvenli bir yöntem olduğunu, bu tercih edilmelidir Buffer.BlockCopy()hemen hemen tüm yaygın vakalarda. Önemli Buffer.BlockCopy()ölçüde daha iyi olacağı tek kullanım durumu , kaynak ve hedef dizi değer türlerinin farklı olduğu zamandır (Ken Smith'in cevabında belirtildiği gibi). Bu senaryo yaygın olmamakla Array.Copy()birlikte, doğrudan yayınlamaya kıyasla sürekli "güvenli" değer türü atama nedeniyle burada çok kötü performans gösterebilir Buffer.BlockCopy().
• Aynı tür dizi kopyalamadan Array.Copy()daha hızlı olan StackOverflow dışından ek kanıtlar buradaBuffer.BlockCopy() bulunabilir .

Kullanmanın mantıklı olduğu başka bir örnek, Buffer.BlockCopy()bir dizi ilkel (örneğin, şortlar) sağlandığında ve bunu bir bayt dizisine dönüştürmeniz gerektiğidir (örneğin, bir ağ üzerinden iletim için). Silverlight AudioSink'ten gelen sesle uğraşırken bu yöntemi sıklıkla kullanıyorum. Örneği bir short[]dizi olarak sağlar, ancak byte[]gönderdiğiniz paketi oluştururken onu bir diziye dönüştürmeniz gerekir Socket.SendAsync(). Kullanabilir BitConverterve diziyi tek tek yineleyebilirsiniz, ancak bunu yapmak için çok daha hızlı (testlerimde yaklaşık 20x):

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

Ve aynı numara ters yönde de çalışır:

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

Bu, güvenli C # ' (void *)da C ve C ++' da çok yaygın olan bellek yönetimine ne kadar yakın olursanız olun .

Testlerime göre, performans Array.Copy yerine Buffer.BlockCopy'yi tercih etmek için bir neden değil . Array.Copy testime göre, aslında Buffer.BlockCopy'den daha hızlı .

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

Örnek Çıktı:

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, BlockCopy'den daha akıllıdır. Kaynak ve hedef aynı dizi ise öğelerin nasıl kopyalanacağını anlar.

Bir int dizisini 0,1,2,3,4 ile doldurup uygularsak:

Array.Copy (dizi, 0, dizi, 1, dizi.Uzunluğu - 1);

Beklendiği gibi 0,0,1,2,3 ile sonuçlanırız.

Bunu BlockCopy ile deneyin ve şunu elde ederiz: 0,0,2,3,4. Bundan array[0]=-1sonra atarsam, beklendiği gibi -1,0,2,3,4 olur, ancak dizi uzunluğu çift ise, 6 gibi, -1,256,2,3,4,5 elde ederiz. Tehlikeli şeyler. Bir bayt dizisini diğerine kopyalamak dışında BlockCopy kullanmayın.

Yalnızca Array.Copy'yi kullanabileceğiniz başka bir durum daha vardır: dizi boyutu 2 ^ 31'den uzunsa. Array.Copy, longboyut parametresine sahip bir aşırı yüklemeye sahip . BlockCopy buna sahip değil.

Bu argümana ağırlık verecek olursak, bu kıyaslamayı nasıl yazdıklarına dikkat edilmezse, kolaylıkla yanıltılabilirler. Bunu göstermek için çok basit bir test yazdım. Aşağıdaki testimde, testlerimin sırasını önce Buffer.BlockCopy veya Array.Copy arasında değiştirirsem, ilk giden neredeyse her zaman en yavaş olanıdır (yakın olmasına rağmen). Bu, basitçe testleri birden çok kez çalıştırmaya girmeyeceğim bir dizi nedenden dolayı, özellikle birbiri ardına doğru sonuçlar vermeyeceği anlamına gelir.

Testi, 1000000 ardışık çift dizisi için 1000000 denemede olduğu gibi sürdürmeye başvurdum. Bununla birlikte, daha sonra ilk 900000 döngüyü göz ardı edip geri kalanın ortalamasını alıyorum. Bu durumda Tampon üstündür.

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

BlockCopy'nin Array.Copy'ye göre 'PERFORMANS' avantajı olmadığını tekrar gösteren test durumumu eklemek istiyorum. Makinemde yayın modunda aynı performansa sahip görünüyorlar (her ikisi de 50 milyon tamsayıyı kopyalamak için yaklaşık 66 ms sürüyor). Hata ayıklama modunda, BlockCopy marjinal olarak daha hızlıdır.

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