Array.Copy vs Buffer.BlockCopy

Prelude

I'm joining the party late, but with 32k views, it's worth getting this right. Most of the microbenchmarking code in the posted answers thus far suffer from one or more severe technical flaws, including not moving memory allocations out of the test loops (which introduces severe GC artifacts), not testing variable vs. deterministic execution flows, JIT warmup, and not tracking intra-test variability. In addition, most answers did not test the effects of varying buffer sizes and varying primitive types (with respect to either 32-bit or 64-bit systems). To address this question more comprehensively, I hooked it up to a custom microbenchmarking framework I developed that reduces most of the common "gotchas" to the extent possible. Tests were run in .NET 4.0 Release mode on both a 32-bit machine and a 64-bit machine. Results were averaged over 20 testing runs, in which each run had 1 million trials per method. Primitive types tested were byte (1 byte), int (4 bytes), and double (8 bytes). Three methods were tested: Array.Copy(), Buffer.BlockCopy(), and simple per-index assignment in a loop. The data is too voluminous to post here, so I will summarize the important points.

The Takeaways

• If your buffer length is about 75-100 or less, an explicit loop copy routine is usually faster (by about 5%) than either Array.Copy() or Buffer.BlockCopy() for all 3 primitive types tested on both 32-bit and 64-bit machines. Additionly, the explicit loop copy routine has noticeably lower variability in performance compared to the two alternatives. The good performance is almost surely due to locality of reference exploited by CPU L1/L2/L3 memory caching in conjunction with no method call overhead.
  • For double buffers on 32-bit machines only: The explicit loop copy routine is better than both alternatives for all buffer sizes tested up to 100k. The improvement is 3-5% better than the other methods. This is because the performance of Array.Copy() and Buffer.BlockCopy() become totally degraded upon passing the native 32-bit width. Thus I assume the same effect would apply to long buffers as well.
• For buffer sizes exceeding ~100, explicit loop copying quickly becomes much slower than the other 2 methods (with the one particular exception just noted). The difference is most noticeable with byte[], where explicit loop copying can become 7x or more slower at large buffer sizes.
• In general, for all 3 primitive types tested and across all buffer sizes, Array.Copy() and Buffer.BlockCopy() performed almost identically. On average, Array.Copy() seems to have a very slight edge of about 2% or less time taken (but 0.2% - 0.5% better is typical), although Buffer.BlockCopy() did occasionally beat it. For unknown reasons, Buffer.BlockCopy() has noticeably higher intra-test variability than Array.Copy(). This effect could not be eliminated despite me trying multiple mitigations and not having an operable theory on why.
• Because Array.Copy() is a "smarter", more general, and much safer method, in addition to being very slightly faster and having less variability on average, it should be preferred to Buffer.BlockCopy() in almost all common cases. The only use case where Buffer.BlockCopy() will be significantly better is when the source and destination array value types are different (as pointed out in Ken Smith's answer). While this scenario is not common, Array.Copy() can perform very poorly here due to the continual "safe" value type casting, compared to the direct casting of Buffer.BlockCopy().
• Additional evidence from outside StackOverflow that Array.Copy() is faster than Buffer.BlockCopy() for same-type array copying can be found here.

Another example of when it makes sense to use Buffer.BlockCopy() is when you're provided with an array of primitives (say, shorts), and need to convert it to an array of bytes (say, for transmission over a network). I use this method frequently when dealing with audio from the Silverlight AudioSink. It provides the sample as a short[] array, but you need to convert it to a byte[] array when you're building the packet that you submit to Socket.SendAsync(). You could use BitConverter, and iterate through the array one-by-one, but it's a lot faster (about 20x in my testing) just to do this:

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

And the same trick works in reverse as well:

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

This is about as close as you get in safe C# to the (void *) sort of memory management that's so common in C and C++.

Based on my testing, performance is not a reason to prefer Buffer.BlockCopy over Array.Copy. From my testing Array.Copy is actually faster than 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)); 

Example Output:

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 is smarter than BlockCopy. It figures out how to copy elements if the source and destination are the same array.

If we populate an int array with 0,1,2,3,4 and apply:

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

we end up with 0,0,1,2,3 as expected.

Try this with BlockCopy and we get: 0,0,2,3,4. If I assign array[0]=-1 after that, it becomes -1,0,2,3,4 as expected, but if the array length is even, like 6, we get -1,256,2,3,4,5. Dangerous stuff. Don't use BlockCopy other than for copying one byte array into another.

There is another case where you can only use Array.Copy: if the array size is longer than 2^31. Array.Copy has an overload with a long size parameter. BlockCopy does not have that.

On .NET 5.0.6 (x64) - for copying byte array to byte array - Array.Copy seems to be the winner even for short arrays. Interestingly enough Enumumerable.Concat is also relatively fast on longer arrays because it optimizes for ICollection<T> if enumerable implements it (it is not the case for .NET Framework though).

Benchmark results and source code:

public class ArrayConcatBenchmark { [Params(50, 100, 1000, 10000)] public int ArrayLength; [Params(1, 2, 3)] public int NumberOfArrays; private byte[][] data; [GlobalSetup] public void GlobalSetup() { data = new byte[NumberOfArrays][]; var random = new Random(42); for (int i = 0; i < NumberOfArrays; i++) { data[i] = new byte[ArrayLength]; random.NextBytes(data[i]); } } [Benchmark] public byte[] EnumerableConcat() { IEnumerable<byte> enumerable = data[0]; for (int n = 1; n < NumberOfArrays; n++) { enumerable = enumerable.Concat(data[n]); } return enumerable.ToArray(); } [Benchmark] public byte[] ForLoop() { var result = new byte[ArrayLength * NumberOfArrays]; for (int n = 0; n < NumberOfArrays; n++) { for (int i = 0; i < ArrayLength; i++) { result[i + n * ArrayLength] = data[n][i]; } } return result; } [Benchmark] public byte[] ForeachLoop() { var result = new byte[ArrayLength * NumberOfArrays]; for (int n = 0; n < NumberOfArrays; n++) { int i = 0; foreach (var item in data[n]) { result[i + n * ArrayLength] = item; i++; } } return result; } [Benchmark] public byte[] ArrayCopy() { var result = new byte[ArrayLength * NumberOfArrays]; for (int n = 0; n < NumberOfArrays; n++) { Array.Copy(data[n], 0, result, n * ArrayLength, ArrayLength); } return result; } [Benchmark] public byte[] BufferBlockCopy() { var result = new byte[ArrayLength * NumberOfArrays]; for (int n = 0; n < NumberOfArrays; n++) { Buffer.BlockCopy(data[n], 0, result, n * ArrayLength, ArrayLength); } return result; } public static void Main(string[] args) { //Console.WriteLine("Are all results the same: " + AreAllResultsTheSame()); BenchmarkRunner.Run<ArrayConcatBenchmark>(); } private static bool AreAllResultsTheSame() { var ac = new ArrayConcatBenchmark() { NumberOfArrays = 2, ArrayLength = 100, }; ac.GlobalSetup(); var firstResult = ac.EnumerableConcat(); var otherResults = new[] { ac.ForLoop(), ac.ForeachLoop(), ac.ArrayCopy(), ac.BufferBlockCopy(), }; return otherResults.All(x => firstResult.SequenceEqual(x)); } } 

To weigh in on this argument, if one is not careful how they author this benchmark they could be easily misled. I wrote a very simple test to illustrate this. In my test below if I swap the order of my tests between starting Buffer.BlockCopy first or Array.Copy the one that goes first is almost always the slowest (although its a close one). This means for a bunch of reasons which I wont go into simply running the tests multiple times esp one after the other will not give accurate results.

I resorted to maintaining the test as is with 1000000 tries each for an array of 1000000 sequential doubles. However in I then disregard the first 900000 cycles and average the remainder. In that case the Buffer is superior.

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

Just want to add my testing case which shows again BlockCopy has no 'PERFORMANCE' benefit over Array.Copy. They seem to have the same performance under release mode on my machine (both take about 66ms to copy 50 million integers). Under debug mode, BlockCopy is just marginally faster.

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