Какой способ наиболее эффективного способа скопировать большой смежный раздел памяти в C#? [дублировать] ⇐ C#

[Anonymous]

Недавно я пытался найти самый быстрый способ скопировать массив байтов, потому что при обработке моделей ИИ мне часто приходится копировать массивы в порядках GB. Это может быть любая структура или obj, как массив , память или даже просто необработанная void*. Я хочу, чтобы это было постоянным, хотя, так что нет стека. Это также должно быть смежным, чтобы в полной мере использовать кэширование и минимизировать шанс утечки памяти. Это означает отсутствие связанных списков или деревьев, но для копирования я не думаю, что это все равно было бы быстро. Тем не менее, я продолжаю получать различные результаты. Вот мой код: < /p>

Код: Выделить всё

[DllImport("msvcrt.dll", EntryPoint = "memcpy", CallingConvention = CallingConvention.Cdecl, SetLastError = false), SuppressUnmanagedCodeSecurity]
static unsafe extern void* memcpy(void* dest, void* src, ulong count);

uint GB = 1024 * 1024 * 1024;
Random random = new Random();
Stopwatch sw = Stopwatch.StartNew();

void printSW(Stopwatch sw, string message)
{
Console.Write(message + " ");
Console.Write(sw.ElapsedTicks);
Console.Write("ticks (");
Console.Write(sw.ElapsedMilliseconds);
Console.WriteLine("ms)");
}

var bs = new byte[GB];
random.NextBytes(bs);
byte[] dest = new byte[GB];
sw.Reset();

sw.Start();
Buffer.BlockCopy(bs, 0, dest, 0, (int)GB);
sw.Stop();
printSW(sw, "bc:");

bs = new byte[GB];
random.NextBytes(bs);
dest = new byte[GB];
sw.Reset();

sw.Start();
unsafe
{
fixed (byte* p = bs)
{
fixed (byte* p2 = dest)
{
Buffer.MemoryCopy(p, p2, GB, GB);
}
}
}
sw.Stop();
printSW(sw, "mc:");

bs = new byte[GB];
random.NextBytes(bs);
dest = new byte[GB];
sw.Reset();

sw.Start();
unsafe
{
fixed (byte* p = bs)
{
fixed (byte* p2 = dest)
{
memcpy(p, p2, GB);
}
}
}
sw.Stop();
printSW(sw, "memcpy:");

bs = new byte[GB];
random.NextBytes(bs);
dest = new byte[GB];
sw.Reset();

sw.Start();
Unsafe.CopyBlock(ref bs[0], ref dest[0], GB);
sw.Stop();
printSW(sw, "uc:");

bs = new byte[GB];
random.NextBytes(bs);
dest = new byte[GB];
sw.Reset();

sw.Start();
unsafe
{
fixed (byte* p = bs)
{
fixed (byte* p2 = dest)
{
Unsafe.CopyBlockUnaligned(p, p2, GB);
}
}
}

sw.Stop();
printSW(sw, "uac:");
< /code>
Я получаю результаты подобные: < /p>
bc: 3054272ticks (305ms)
mc: 3188401ticks (318ms)
memcpy: 3081618ticks (308ms)
uc: 2952603ticks (295ms)
uac: 3205615ticks (320ms)
< /code>
, а затем вскоре после этого: < /p>
bc: 3444094ticks (344ms)
mc: 3260476ticks (326ms)
memcpy: 3110621ticks (311ms)
uc: 3186015ticks (318ms)
uac: 3345815ticks (334ms)

Мой вопрос в том, какой из них быстрее и что я делаю не так при их профилировании?

Подробнее здесь: https://stackoverflow.com/questions/796 ... -memory-in