Array.Copy so với Buffer.BlockCopy

Array.Copy và Buffer.BlockCopy đều làm điều tương tự, nhưng BlockCopynhằm mục đích sao chép mảng nguyên thủy cấp byte nhanh, trong khi đó Copylà việc triển khai mục đích chung. Câu hỏi của tôi là - bạn nên sử dụng trong những trường hợp BlockCopynào? Bạn có nên sử dụng nó bất cứ lúc nào khi bạn đang sao chép các mảng kiểu nguyên thủy hay chỉ nên sử dụng nó nếu bạn đang viết mã cho hiệu suất? Có điều gì nguy hiểm về việc sử dụng Buffer.BlockCopyquá mức Array.Copykhông?

Vì các tham số Buffer.BlockCopydựa trên byte thay vì dựa trên chỉ mục, bạn có nhiều khả năng làm hỏng mã của mình hơn là nếu bạn sử dụng Array.Copy, vì vậy tôi sẽ chỉ sử dụng Buffer.BlockCopytrong phần quan trọng về hiệu suất của mã của mình.

Khúc dạo đầu

Tôi tham gia bữa tiệc muộn, nhưng với 32 nghìn lượt xem, điều này đáng để làm đúng. Hầu hết mã microbenchmarking trong các câu trả lời đã đăng cho đến nay đều mắc phải một hoặc nhiều lỗi kỹ thuật nghiêm trọng, bao gồm cả việc không di chuyển phân bổ bộ nhớ ra khỏi các vòng kiểm tra (giới thiệu các tạo tác GC nghiêm trọng), không kiểm tra biến so với luồng thực thi xác định, khởi động JIT, và không theo dõi sự thay đổi trong thử nghiệm. Ngoài ra, hầu hết các câu trả lời không kiểm tra tác động của các kích thước bộ đệm khác nhau và các kiểu nguyên thủy khác nhau (đối với hệ thống 32 bit hoặc 64 bit). Để giải quyết câu hỏi này một cách toàn diện hơn, tôi đã kết nối nó với một khuôn khổ đánh dấu microbenchmarking tùy chỉnh mà tôi đã phát triển để giảm hầu hết các "lỗi" phổ biến đến mức có thể. Các thử nghiệm đã được chạy ở chế độ Phát hành .NET 4.0 trên cả máy 32 bit và máy 64 bit. Kết quả được tính trung bình trên 20 lần chạy thử nghiệm, trong đó mỗi lần chạy có 1 triệu lần thử nghiệm cho mỗi phương pháp. Các loại ban đầu được kiểm tra làbyte(1 byte), int(4 byte) và double(8 byte). Ba phương pháp đã được thử nghiệm: Array.Copy(), Buffer.BlockCopy(), và đơn giản chuyển nhượng cho mỗi chỉ số trong một vòng lặp. Dữ liệu quá nhiều để đăng ở đây, vì vậy tôi sẽ tóm tắt những điểm quan trọng.

Những điều rút ra

• Nếu độ dài bộ đệm của bạn khoảng 75-100 hoặc ít hơn, quy trình sao chép vòng lặp rõ ràng thường nhanh hơn (khoảng 5%) so với Array.Copy()hoặc Buffer.BlockCopy()đối với cả 3 kiểu nguyên thủy được thử nghiệm trên cả máy 32 bit và 64 bit. Ngoài ra, quy trình sao chép vòng lặp rõ ràng có sự thay đổi hiệu suất thấp hơn đáng kể so với hai lựa chọn thay thế. Hiệu suất tốt gần như chắc chắn là do vị trí của tham chiếu được bộ nhớ đệm CPU L1 / L2 / L3 khai thác kết hợp với không có phí gọi phương thức.
  • Đối với doublebộ đệm chỉ trên máy 32-bit : Quy trình sao chép vòng lặp rõ ràng tốt hơn cả hai lựa chọn thay thế cho tất cả các kích thước bộ đệm được thử nghiệm lên đến 100k. Cải thiện tốt hơn 3-5% so với các phương pháp khác. Điều này là do hiệu suất của Array.Copy()vàBuffer.BlockCopy() trở nên suy giảm hoàn toàn khi vượt qua chiều rộng 32 bit gốc. Vì vậy, tôi cho rằng hiệu ứng tương tự sẽ áp dụng cholong bộ đệm.
• Đối với kích thước bộ đệm vượt quá ~ 100, việc sao chép vòng lặp rõ ràng nhanh chóng trở nên chậm hơn nhiều so với 2 phương pháp còn lại (với một ngoại lệ cụ thể vừa được lưu ý). Sự khác biệt đáng chú ý nhất vớibyte[] , khi sao chép vòng lặp rõ ràng có thể trở nên chậm hơn 7 lần hoặc hơn ở kích thước bộ đệm lớn.
• Nói chung, đối với cả 3 kiểu nguyên thủy đã được thử nghiệm và trên tất cả các kích thước bộ đệm, Array.Copy()và Buffer.BlockCopy()hoạt động gần như giống nhau. Trung bình, Array.Copy()có vẻ như có một lợi thế rất nhỏ khoảng 2% hoặc ít hơn thời gian thực hiện (nhưng 0,2% - 0,5% tốt hơn là điển hình), mặc dùBuffer.BlockCopy() đôi khi đã đánh bại nó. Vì những lý do không xác định, Buffer.BlockCopy()có sự thay đổi trong thử nghiệm cao hơn đáng kể so với Array.Copy(). Hiệu ứng này không thể bị loại bỏ mặc dù tôi đã thử nhiều biện pháp giảm nhẹ và không có một lý thuyết có thể hoạt động về lý do tại sao.
• Bởi vì Array.Copy()là một phương pháp "thông minh hơn", tổng quát hơn và an toàn hơn nhiều, ngoài việc nhanh hơn một chút và ít thay đổi trung bình, nó nên được ưa thích Buffer.BlockCopy()trong hầu hết các trường hợp phổ biến. Trường hợp sử dụng duy nhất Buffer.BlockCopy()sẽ tốt hơn đáng kể là khi kiểu giá trị mảng nguồn và đích khác nhau (như đã chỉ ra trong câu trả lời của Ken Smith). Mặc dù kịch bản này không phổ biến, nhưng Array.Copy()có thể hoạt động rất kém ở đây do liên tục truyền loại giá trị "an toàn", so với truyền trực tiếp Buffer.BlockCopy().
• Bạn có thể tìm thấy bằng chứng bổ sung từ bên ngoài StackOverflow Array.Copy()nhanh hơn so Buffer.BlockCopy()với sao chép mảng cùng loại tại đây .

Một ví dụ khác về thời điểm hợp lý để sử dụng Buffer.BlockCopy()là khi bạn được cung cấp một mảng nguyên thủy (ví dụ, quần short) và cần chuyển đổi nó thành một mảng byte (ví dụ, để truyền qua mạng). Tôi sử dụng phương pháp này thường xuyên khi xử lý âm thanh từ Silverlight AudioSink. Nó cung cấp mẫu dưới dạng một short[]mảng, nhưng bạn cần chuyển nó thành một byte[]mảng khi bạn đang xây dựng gói mà bạn gửi đến Socket.SendAsync(). Bạn có thể sử dụng BitConvertervà lặp lại từng mảng một, nhưng nhanh hơn rất nhiều (khoảng 20 lần trong thử nghiệm của tôi) chỉ để làm điều này:

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

Và thủ thuật tương tự cũng hoạt động ngược lại:

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

Điều này gần giống như bạn nhận được trong C # an toàn với (void *)kiểu quản lý bộ nhớ rất phổ biến trong C và C ++.

Dựa trên thử nghiệm của tôi, hiệu suất không phải là lý do để thích Buffer.BlockCopy hơn Array.Copy. Từ thử nghiệm của tôi, Array.Copy thực sự nhanh hơn 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));

Đầu ra mẫu:

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 thông minh hơn BlockCopy. Nó tìm ra cách sao chép các phần tử nếu nguồn và đích là cùng một mảng.

Nếu chúng ta điền một mảng int với 0,1,2,3,4 và áp dụng:

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

chúng tôi kết thúc với 0,0,1,2,3 như mong đợi.

Hãy thử điều này với BlockCopy và chúng tôi nhận được: 0,0,2,3,4. Nếu tôi chỉ địnharray[0]=-1 sau đó, nó sẽ trở thành -1,0,2,3,4 như mong đợi, nhưng nếu độ dài mảng là chẵn, như 6, chúng tôi nhận được -1,256,2,3,4,5. Những thứ nguy hiểm. Không sử dụng BlockCopy ngoài việc sao chép một mảng byte sang một mảng khác.

Có một trường hợp khác mà bạn chỉ có thể sử dụng Array.Copy: nếu kích thước mảng dài hơn 2 ^ 31. Array.Copy bị quá tải với một longtham số kích thước. BlockCopy không có điều đó.

Để cân nhắc về lập luận này, nếu một người không cẩn thận về cách họ tạo ra điểm chuẩn này, họ có thể dễ dàng bị nhầm lẫn. Tôi đã viết một bài kiểm tra rất đơn giản để minh họa điều này. Trong thử nghiệm của tôi dưới đây, nếu tôi hoán đổi thứ tự các thử nghiệm của mình giữa việc khởi động Buffer.BlockCopy trước hoặc Array. Sao chép cái đi trước hầu như luôn là chậm nhất (mặc dù nó là một bản đóng). Điều này có nghĩa là vì một loạt lý do mà tôi sẽ không đi vào chỉ đơn giản là chạy thử nghiệm nhiều lần, đặc biệt là lần này đến lần khác sẽ không cho kết quả chính xác.

Tôi đã sử dụng để duy trì thử nghiệm như hiện tại với 1000000 lần thử cho mỗi dãy 1000000 lần nhân đôi liên tiếp. Tuy nhiên, sau đó tôi bỏ qua 900000 chu kỳ đầu tiên và lấy trung bình phần còn lại. Trong trường hợp đó, Buffer là ưu việt hơn.

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

Chỉ muốn thêm trường hợp thử nghiệm của tôi để hiển thị lại BlockCopy không có lợi ích 'PERFORMANCE' so với Array.Copy. Chúng dường như có cùng hiệu suất trong chế độ phát hành trên máy của tôi (cả hai đều mất khoảng 66ms để sao chép 50 triệu số nguyên). Trong chế độ gỡ lỗi, BlockCopy chỉ nhanh hơn một chút.

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