Array.Copy เทียบกับ Buffer.BlockCopy

Array.CopyและBuffer.BlockCopyทั้งคู่ทำสิ่งเดียวกัน แต่BlockCopyมุ่งเป้าไปที่การคัดลอกอาร์เรย์ดั้งเดิมระดับไบต์อย่างรวดเร็วในขณะที่Copyการใช้งานทั่วไป คำถามของฉันคือ - คุณควรใช้ภายใต้สถานการณ์ใดBlockCopy? คุณควรใช้เมื่อใดก็ได้เมื่อคุณกำลังคัดลอกอาร์เรย์ประเภทดั้งเดิมหรือคุณควรใช้เฉพาะเมื่อคุณกำลังเข้ารหัสเพื่อประสิทธิภาพเท่านั้น? มีอันตรายจากการใช้Buffer.BlockCopyเกินArray.Copyหรือไม่

เนื่องจากพารามิเตอร์Buffer.BlockCopyเป็นแบบไบต์แทนที่จะเป็นแบบดัชนีคุณจึงมีแนวโน้มที่จะทำให้โค้ดเสียหายมากกว่าที่คุณใช้Array.Copyดังนั้นฉันจะใช้เฉพาะBuffer.BlockCopyในส่วนที่มีความสำคัญต่อประสิทธิภาพของโค้ดของฉัน

โหมโรง

ฉันเข้าปาร์ตี้ช้า แต่มียอดดู 32,000 ครั้งจึงคุ้มค่าที่จะได้รับสิทธิ์นี้ โค้ด microbenchmarking ส่วนใหญ่ในคำตอบที่โพสต์นั้นประสบกับข้อบกพร่องทางเทคนิคที่รุนแรงอย่างน้อยหนึ่งข้อซึ่งรวมถึงการไม่ย้ายการจัดสรรหน่วยความจำออกจากลูปทดสอบ (ซึ่งแนะนำสิ่งประดิษฐ์ GC ที่รุนแรง) ไม่ทดสอบตัวแปรเทียบกับโฟลว์การดำเนินการที่กำหนด, การวอร์มอัพ JIT, และไม่ติดตามความแปรปรวนของการทดสอบภายใน นอกจากนี้คำตอบส่วนใหญ่ไม่ได้ทดสอบผลกระทบของขนาดบัฟเฟอร์ที่แตกต่างกันและประเภทดั้งเดิมที่แตกต่างกัน (เกี่ยวกับระบบ 32 บิตหรือ 64 บิต) เพื่อตอบคำถามนี้ให้ครอบคลุมมากขึ้นฉันได้เชื่อมต่อกับกรอบงานไมโครเบนช์มาร์กที่กำหนดเองที่ฉันพัฒนาขึ้นเพื่อลด "gotchas" ที่พบบ่อยที่สุดเท่าที่จะทำได้ การทดสอบรันในโหมดรีลีส. NET 4.0 ทั้งบนเครื่อง 32 บิตและเครื่อง 64 บิต ผลลัพธ์ถูกเฉลี่ยจากการทดสอบ 20 ครั้งซึ่งแต่ละครั้งมีการทดลอง 1 ล้านครั้งต่อวิธี ประเภทดั้งเดิมที่ทดสอบคือbyte(1 ไบต์), int(4 ไบต์) และdouble(8 ไบต์) มีการทดสอบสามวิธี: Array.Copy(), Buffer.BlockCopy()และการกำหนดต่อดัชนีอย่างง่ายในลูป ข้อมูลมีมากเกินไปที่จะโพสต์ที่นี่ดังนั้นฉันจะสรุปประเด็นสำคัญ

ประเด็นสำคัญ

• หากความยาวบัฟเฟอร์ของคุณอยู่ที่ประมาณ 75-100 หรือน้อยกว่ารูทีนการคัดลอกลูปแบบชัดแจ้งมักจะเร็วกว่า (ประมาณ 5%) เมื่อเทียบกับประเภทดั้งเดิมทั้ง 3 ประเภทArray.Copy()หรือBuffer.BlockCopy()ทั้ง 3 ประเภทที่ทดสอบบนเครื่อง 32 บิตและ 64 บิต นอกจากนี้รูทีนการคัดลอกแบบลูปอย่างชัดเจนยังมีความแปรปรวนในประสิทธิภาพที่ลดลงอย่างเห็นได้ชัดเมื่อเทียบกับสองทางเลือกอื่น ประสิทธิภาพที่ดีนั้นเกือบจะแน่นอนเนื่องจากตำแหน่งของการอ้างอิงที่ใช้ประโยชน์จากการแคชหน่วยความจำ CPU L1 / L2 / L3 ร่วมกับไม่มีค่าใช้จ่ายในการเรียกเมธอด
  • สำหรับdoubleบัฟเฟอร์บนเครื่อง 32 บิตเท่านั้น :รูทีนการคัดลอกลูปแบบชัดแจ้งดีกว่าทั้งสองทางเลือกสำหรับขนาดบัฟเฟอร์ทั้งหมดที่ทดสอบสูงสุด 100k การปรับปรุงจะดีกว่าวิธีอื่น ๆ 3-5% นี่เป็นเพราะประสิทธิภาพของArray.Copy()และBuffer.BlockCopy()ลดลงโดยสิ้นเชิงเมื่อส่งผ่านความกว้าง 32 บิตดั้งเดิม ดังนั้นฉันจึงถือว่าเอฟเฟกต์เดียวกันนี้จะนำไปใช้กับlongบัฟเฟอร์เช่นกัน
• สำหรับขนาดบัฟเฟอร์ที่เกิน ~ 100 การคัดลอกแบบลูปอย่างชัดเจนจะช้ากว่าอีก 2 วิธีอย่างรวดเร็ว (โดยมีข้อยกเว้นเพียงข้อเดียวที่ระบุไว้) ความแตกต่างที่เห็นได้ชัดเจนที่สุดคือโดยbyte[]ที่การคัดลอกแบบลูปอย่างชัดเจนอาจช้าลง 7 เท่าหรือมากกว่าในขนาดบัฟเฟอร์ขนาดใหญ่
• โดยทั่วไปสำหรับทั้ง 3 ประเภทดั้งเดิมที่ทดสอบและในขนาดบัฟเฟอร์ทั้งหมดArray.Copy()และBuffer.BlockCopy()ดำเนินการเกือบจะเหมือนกัน โดยเฉลี่ยแล้วArray.Copy()ดูเหมือนว่าจะมีความได้เปรียบเล็กน้อยประมาณ 2% หรือน้อยกว่าเวลาที่ใช้ (แต่ปกติดีกว่า 0.2% - 0.5%) แม้ว่าจะBuffer.BlockCopy()เอาชนะได้ในบางครั้ง สำหรับเหตุผลที่ไม่รู้จักมีความแปรปรวนระหว่างการทดสอบอย่างเห็นได้ชัดที่สูงกว่าBuffer.BlockCopy() Array.Copy()ผลกระทบนี้ไม่สามารถกำจัดได้แม้ว่าฉันจะพยายามบรรเทาหลายครั้งและไม่มีทฤษฎีที่ใช้งานได้ว่าทำไม
• เนื่องจากArray.Copy()เป็นวิธีที่ "ฉลาดกว่า" ทั่วไปกว่าและปลอดภัยกว่ามากนอกจากจะเร็วกว่าเล็กน้อยและมีความแปรปรวนน้อยกว่าโดยเฉลี่ยแล้วจึงควรเลือกใช้Buffer.BlockCopy()ในเกือบทุกกรณี กรณีการใช้งานเดียวที่Buffer.BlockCopy()จะดีกว่าอย่างมีนัยสำคัญคือเมื่อประเภทค่าอาร์เรย์ต้นทางและปลายทางแตกต่างกัน (ดังที่ระบุไว้ในคำตอบของ Ken Smith) ในขณะที่สถานการณ์นี้ไม่ได้เป็นเรื่องธรรมดาArray.Copy()สามารถดำเนินการได้ไม่ดีมากที่นี่เนื่องจากการอย่างต่อเนื่อง "ปลอดภัย" Buffer.BlockCopy()ประเภทค่าหล่อเมื่อเทียบกับการหล่อโดยตรงของ
• หลักฐานเพิ่มเติมจาก StackOverflow ภายนอกที่Array.Copy()จะเร็วกว่าBuffer.BlockCopy()เดียวกันชนิดอาร์เรย์คัดลอกสามารถพบได้ที่นี่

อีกตัวอย่างหนึ่งของเวลาที่เหมาะสมในการใช้Buffer.BlockCopy()คือเมื่อคุณได้รับอาร์เรย์ของดั้งเดิม (เช่นกางเกงขาสั้น) และจำเป็นต้องแปลงเป็นอาร์เรย์ของไบต์ (เช่นสำหรับการส่งผ่านเครือข่าย) ฉันใช้วิธีนี้บ่อยเมื่อจัดการกับเสียงจาก Silverlight AudioSink มันมีตัวอย่างเป็นshort[]อาร์เรย์ แต่คุณจำเป็นต้องแปลงเป็นอาร์เรย์เมื่อคุณกำลังสร้างแพ็คเก็ตที่คุณส่งไปbyte[] Socket.SendAsync()คุณสามารถใช้BitConverterและวนซ้ำผ่านอาร์เรย์ทีละรายการ แต่เร็วกว่ามาก (ประมาณ 20x ในการทดสอบของฉัน) เพียงแค่ทำสิ่งนี้:

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

และเคล็ดลับเดียวกันก็ทำงานในสิ่งที่ตรงกันข้ามเช่นกัน:

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

สิ่งนี้ใกล้เคียงกับที่คุณได้รับใน C # ที่ปลอดภัยไปจนถึงการ(void *)จัดการหน่วยความจำที่พบได้ทั่วไปใน C และ C ++

จากการทดสอบของฉันประสิทธิภาพไม่ใช่เหตุผลที่จะชอบ Buffer.BlockCopy มากกว่า Array.Copy จากการทดสอบ Array.Copy ของฉันเร็วกว่า 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));

ตัวอย่างผลลัพธ์:

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 จะหาวิธีคัดลอกองค์ประกอบหากต้นทางและปลายทางเป็นอาร์เรย์เดียวกัน

หากเราเติมอาร์เรย์ int ด้วย 0,1,2,3,4 และใช้:

Array.Copy (อาร์เรย์ 0 อาร์เรย์ 1 อาร์เรย์ความยาว - 1);

เราจบลงด้วย 0,0,1,2,3 ตามที่คาดไว้

ลองใช้ BlockCopy และเราจะได้รับ: 0,0,2,3,4 ถ้าฉันกำหนดarray[0]=-1หลังจากนั้นมันจะกลายเป็น -1,0,2,3,4 ตามที่คาดไว้ แต่ถ้าความยาวอาร์เรย์เท่ากันเช่น 6 เราจะได้ -1,256,2,3,4,5 สิ่งที่เป็นอันตราย อย่าใช้ BlockCopy นอกเหนือจากการคัดลอกอาร์เรย์หนึ่งไบต์ไปยังอาร์เรย์อื่น

มีอีกกรณีหนึ่งที่คุณสามารถใช้ได้เฉพาะ Array เท่านั้น Copy: ถ้าขนาดอาร์เรย์ยาวกว่า 2 ^ 31 Array.Copy มีโอเวอร์โหลดพร้อมlongพารามิเตอร์ขนาด BlockCopy ไม่มีสิ่งนั้น

ในการพิจารณาข้อโต้แย้งนี้หากไม่มีใครระมัดระวังว่าพวกเขาเขียนเกณฑ์มาตรฐานนี้อย่างไรพวกเขาอาจเข้าใจผิดได้ง่าย ฉันเขียนแบบทดสอบง่ายๆเพื่ออธิบายสิ่งนี้ ในการทดสอบของฉันด้านล่างหากฉันสลับลำดับการทดสอบของฉันระหว่างการเริ่ม Buffer.BlockCopy ก่อนหรือ Array การคัดลอกสิ่งที่ไปก่อนมักจะช้าที่สุด (แม้ว่าจะใกล้เคียงก็ตาม) ซึ่งหมายความว่าด้วยเหตุผลหลายประการที่ฉันจะไม่เข้าไปเพียงแค่เรียกใช้การทดสอบหลาย ๆ ครั้งโดยเฉพาะอย่างใดอย่างหนึ่งหลังจากที่อื่น ๆ จะไม่ให้ผลลัพธ์ที่ถูกต้อง

ฉันใช้วิธีรักษาการทดสอบเหมือนเดิม 1000000 ครั้งสำหรับอาร์เรย์ 1000000 คู่ตามลำดับ อย่างไรก็ตามในตอนนั้นฉันไม่สนใจ 900000 รอบแรกและเฉลี่ยส่วนที่เหลือ ในกรณีนั้นบัฟเฟอร์จะดีกว่า

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 ไม่มีประโยชน์ 'PERFORMANCE' เหนือ Array.Copy ดูเหมือนว่าจะมีประสิทธิภาพเหมือนกันภายใต้โหมดรีลีสบนเครื่องของฉัน (ทั้งคู่ใช้เวลาประมาณ 66ms ในการคัดลอกจำนวนเต็ม 50 ล้านตัว) ภายใต้โหมดดีบัก BlockCopy จะเร็วขึ้นเพียงเล็กน้อย

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