いろんなパターンでのmemcpy()の速度

IntPtrバッファからIntPtrバッファへのコピーをもっと楽な方法でやれんのかと
いろいろ探していたら…

いろいろなパターンでのメモリーコピーの速度テストのサンプル@C#を見つけたり

参考にしたのは，こちら

gamedev.net

Marshal.Copy()を利用する方法
unsafeに入って，ポインタ抜き出して，
byte,int,long,構造体を利用した巨大メモリブロック
をループでコピーする方法が記述されており

んで，こっちで，RtlMoveMemory()@Win32APIを利用するパターンを追加してみたり


条件は以下のとおり

CPU : Intel Core2Quad Q6600(2.4GHz)
Memory : 2GB
OS : Windows XP Pro
言語: Visual Studio 2005(C#2.0) + .Net FrameWork2.0


さきに，実行結果を書いちゃうけど…

Performing tests on copying 1024 kilobytes of memory.
Average time for Marshal is 0.29 ms.
Average time for API is 0.14 ms. Average time byte copy is 4.89 ms.
Average time int copy is 1.24 ms.
Average time long copy is 0.7 ms.
Average time copystruct2 copy is 0.36 ms.
Average time copystruct4 copy is 0.5 ms.
Average time copystruct16 copy is 0.23 ms.
Average time copystruct128 copy is 0.15 ms.

APIが一番速いじゃん… 🙄

Marshal.Copy()は，IntPtr->byte配列 byte配列->IntPtrの２回のコピー作業をやっているんで
まぁ，APIと速度は変わらんか

でも，IntPtr->IntPtrはMarshal.Copy()にオーバーロードが準備されて無いしのぉ～

ってことで，RtlMoveMemory()APIをメインで使っていくことに決定！


ソースはこちら

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Runtime.InteropServices;
namespace TestCS
{
class Program
{
#region APIs
[DllImport(“Kernel32.dll”, EntryPoint=”RtlMoveMemory”)]
private static extern void CopyMemory(IntPtr Destination, IntPtr Source, [MarshalAs(UnmanagedType.U4)] int Length);
#endregion

unsafe struct copystruct2
{
fixed long l[2];
}
unsafe struct copystruct4
{
fixed long l[4];
}
unsafe struct copystruct16
{
fixed long l[16];
}
unsafe struct copystruct128
{
fixed long l[128];
}
unsafe static void Main(string[] args)
{
const int size = 1048576;
const int count = 100;

IntPtr ptr = Marshal.AllocHGlobal(size);
IntPtr ptr2 = Marshal.AllocHGlobal(size);
byte[] bytes = new byte[size];

Console.WriteLine(“Performing tests on copying {0} kilobytes of memory.”,
size / (double)1024);

System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
// make sure methods are JIT’d (they probably are, since there
// should be native images of the standard library, but just to be safe..)
watch.Reset();
watch.Start();
watch.Stop();
Marshal.Copy(bytes, 0, ptr, size);
Marshal.Copy(ptr2, bytes, 0, size);

watch.Reset();
watch.Start();

for (int i = 0; i < count; i++)
{
Marshal.Copy(bytes, 0, ptr, size);
Marshal.Copy(ptr2, bytes, 0, size);
}

watch.Stop();
double averageTime = watch.ElapsedMilliseconds / (double)count;
Console.WriteLine("Average time for Marshal is {0} ms.", averageTime);

watch.Reset();
watch.Start();

for (int i = 0; i < count; i++)
{
CopyMemory(ptr2, ptr, size);
}

watch.Stop();
averageTime = watch.ElapsedMilliseconds / (double)count;
Console.WriteLine("Average time for API is {0} ms.", averageTime);

{
watch.Reset();
watch.Start();

byte* src = (byte*)ptr;
byte* dest = (byte*)ptr2;
for (int j = 0; j < count; j++)
{
for (int i = 0; i < size / sizeof(byte); i++)
{
dest[i] = src[i];
}
}

watch.Stop();
averageTime = watch.ElapsedMilliseconds / (double)count;
}
Console.WriteLine("Average time byte copy is {0} ms.", averageTime);
{
watch.Reset();
watch.Start();

int* src = (int*)ptr;
int* dest = (int*)ptr2;
for (int j = 0; j < count; j++)
{
for (int i = 0; i < size / sizeof(int); i++)
{
dest[i] = src[i];
}
}

watch.Stop();
averageTime = watch.ElapsedMilliseconds / (double)count;
}
Console.WriteLine("Average time int copy is {0} ms.", averageTime);
{
watch.Reset();
watch.Start();

long* src = (long*)ptr;
long* dest = (long*)ptr2;
for (int j = 0; j < count; j++)
{
for (int i = 0; i < size / sizeof(long); i++)
{
dest[i] = src[i];
}
}

watch.Stop();
averageTime = watch.ElapsedMilliseconds / (double)count;
}
Console.WriteLine("Average time long copy is {0} ms.", averageTime);

watch.Reset();
watch.Start();
{
copystruct2* src = (copystruct2*)ptr;
copystruct2* dest = (copystruct2*)ptr2;
for (int j = 0; j < count; j++)
{
for (int i = 0; i < size / sizeof(copystruct2); i++)
{
dest[i] = src[i];
}
}

watch.Stop();
averageTime = watch.ElapsedMilliseconds / (double)count;
}
Console.WriteLine("Average time copystruct2 copy is {0} ms.", averageTime);

watch.Reset();
watch.Start();
{
copystruct4* src = (copystruct4*)ptr;
copystruct4* dest = (copystruct4*)ptr2;
for (int j = 0; j < count; j++)
{
for (int i = 0; i < size / sizeof(copystruct4); i++)
{
dest[i] = src[i];
}
}

watch.Stop();
averageTime = watch.ElapsedMilliseconds / (double)count;
}
Console.WriteLine("Average time copystruct4 copy is {0} ms.", averageTime);


watch.Reset();
watch.Start();
{
copystruct16* src = (copystruct16*)ptr;
copystruct16* dest = (copystruct16*)ptr2;
for (int j = 0; j < count; j++)
{
for (int i = 0; i < size / sizeof(copystruct16); i++)
{
dest[i] = src[i];
}
}

watch.Stop();
averageTime = watch.ElapsedMilliseconds / (double)count;
}
Console.WriteLine("Average time copystruct16 copy is {0} ms.", averageTime);


watch.Reset();
watch.Start();
{
copystruct128* src = (copystruct128*)ptr;
copystruct128* dest = (copystruct128*)ptr2;
for (int j = 0; j < count; j++)
{
for (int i = 0; i < size / sizeof(copystruct128); i++)
{
dest[i] = src[i];
}
}

watch.Stop();
averageTime = watch.ElapsedMilliseconds / (double)count;
}
Console.WriteLine("Average time copystruct128 copy is {0} ms.", averageTime);
Marshal.FreeHGlobal(ptr);
Marshal.FreeHGlobal(ptr2);
Console.ReadKey();
}
}
}
[/csharp]