z memcpy（for MSVC）小内存高速复制

2024-02-26 02:48
文章标签 内存 复制 memcpy msvc 高速

本文主要是介绍z memcpy（for MSVC）小内存高速复制，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！



z memcpy（for MSVC only）小内存高速复制，即使在debug模式下复制的也比memcpy快，release下差距也不大

2016-3-6注意: 由于指令缓存命中、内联深度等方面的原因，此函数性能测试看起来很不错，插入到程序中实际应用时就不一定了，请测试对比后再决定使用

对VC2008及以上均测试通过

Release Mode
All time to memcpy 63 * 100M is 0.042s in 3GHz (zmemcopy template const size)
All time to memcpy 63 * 100M is 0.050s in 3GHz (zmemcopy static  const size)
All time to memcpy 63 * 100M is 0.147s in 3GHz (memcpy const size)
All time to memcpy 63 * 100M is 0.048s in 3GHz (zmemcopy const size)
All time to memcpy 63 * 100M is 0.050s in 3GHz (zmemcopy unknown array direct)
All time to memcpy 63 * 100M is 0.051s in 3GHz (zmemcopy unknown small size)
All time to memcpy 63 * 100M is 0.056s in 3GHz (zmemcopy unknown size)
All time to memcpy 63 * 100M is 0.140s in 3GHz (memcpy unknown size)


Debug Mode
All time to memcpy 63 * 100M is 0.056s in 3GHz (zmemcopy template const size)
All time to memcpy 63 * 100M is 0.055s in 3GHz (zmemcopy static  const size)
All time to memcpy 63 * 100M is 0.171s in 3GHz (memcpy const size)
All time to memcpy 63 * 100M is 0.093s in 3GHz (zmemcopy const size)
All time to memcpy 63 * 100M is 0.060s in 3GHz (zmemcopy unknown array direct)
All time to memcpy 63 * 100M is 0.086s in 3GHz (zmemcopy unknown small size)
All time to memcpy 63 * 100M is 0.100s in 3GHz (zmemcopy unknown size)
All time to memcpy 63 * 100M is 0.172s in 3GHz (memcpy unknown size)

使用方法，一般用zmemcpy(dest,src,size)，在已知目标长度（且是常量表达式时）可以用 ZMemoryCopy::copy<size>(dest,src)

// zmemcpy.cpp : 定义控制台应用程序的入口点。
//#include "stdafx.h"
#include "zmemcpy.h"
//#include <intrin.h>
//#include <nmmintrin.h>
//#include <windows.h>
//#include <utility>
__declspec(noinline) void* GetCurrentAddress()
{return _ReturnAddress();
}
inline void* GetRetAddress()
{return _ReturnAddress();
}
__declspec(noinline) bool IsReleaseMode()
{return _ReturnAddress() == GetRetAddress();
}
bool g_IsReleaseMode = IsReleaseMode();// #pragma runtime_checks( "scu", restore )
//#define pCopyFunc(x) copy<x>
#define pCopyFunc(x) ZMemoryCopy::___copy_##x
void(*const copys[129])(char* dest, const char* src) =
{ZMemoryCopy::___copy_0,pCopyFunc(1), pCopyFunc(2), pCopyFunc(3), pCopyFunc(4), pCopyFunc(5), pCopyFunc(6), pCopyFunc(7), pCopyFunc(8), pCopyFunc(9), pCopyFunc(10),pCopyFunc(11), pCopyFunc(12), pCopyFunc(13), pCopyFunc(14), pCopyFunc(15), pCopyFunc(16), pCopyFunc(17), pCopyFunc(18), pCopyFunc(19), pCopyFunc(20),pCopyFunc(21), pCopyFunc(22), pCopyFunc(23), pCopyFunc(24), pCopyFunc(25), pCopyFunc(26), pCopyFunc(27), pCopyFunc(28), pCopyFunc(29), pCopyFunc(30),pCopyFunc(31), pCopyFunc(32), pCopyFunc(33), pCopyFunc(34), pCopyFunc(35), pCopyFunc(36), pCopyFunc(37), pCopyFunc(38), pCopyFunc(39), pCopyFunc(40),pCopyFunc(41), pCopyFunc(42), pCopyFunc(43), pCopyFunc(44), pCopyFunc(45), pCopyFunc(46), pCopyFunc(47), pCopyFunc(48), pCopyFunc(49), pCopyFunc(50),pCopyFunc(51), pCopyFunc(52), pCopyFunc(53), pCopyFunc(54), pCopyFunc(55), pCopyFunc(56), pCopyFunc(57), pCopyFunc(58), pCopyFunc(59), pCopyFunc(60),pCopyFunc(61), pCopyFunc(62), pCopyFunc(63), pCopyFunc(64), pCopyFunc(65), pCopyFunc(66), pCopyFunc(67), pCopyFunc(68), pCopyFunc(69), pCopyFunc(70),pCopyFunc(71), pCopyFunc(72), pCopyFunc(73), pCopyFunc(74), pCopyFunc(75), pCopyFunc(76), pCopyFunc(77), pCopyFunc(78), pCopyFunc(79), pCopyFunc(80),pCopyFunc(81), pCopyFunc(82), pCopyFunc(83), pCopyFunc(84), pCopyFunc(85), pCopyFunc(86), pCopyFunc(87), pCopyFunc(88), pCopyFunc(89), pCopyFunc(90),pCopyFunc(91), pCopyFunc(92), pCopyFunc(93), pCopyFunc(94), pCopyFunc(95), pCopyFunc(96), pCopyFunc(97), pCopyFunc(98), pCopyFunc(99), pCopyFunc(100),pCopyFunc(101), pCopyFunc(102), pCopyFunc(103), pCopyFunc(104), pCopyFunc(105), pCopyFunc(106), pCopyFunc(107), pCopyFunc(108), pCopyFunc(109), pCopyFunc(110),pCopyFunc(111), pCopyFunc(112), pCopyFunc(113), pCopyFunc(114), pCopyFunc(115), pCopyFunc(116), pCopyFunc(117), pCopyFunc(118), pCopyFunc(119), pCopyFunc(120),pCopyFunc(121), pCopyFunc(122), pCopyFunc(123), pCopyFunc(124), pCopyFunc(125), pCopyFunc(126), pCopyFunc(127), pCopyFunc(128),
};
#undef pCopyFunc#define pCopyFunc(x) ZMemoryCopy::copy<x>
void(*const template_copys[129])(char* dest, const char* src) =
{ZMemoryCopy::___copy_0,pCopyFunc(1), pCopyFunc(2), pCopyFunc(3), pCopyFunc(4), pCopyFunc(5), pCopyFunc(6), pCopyFunc(7), pCopyFunc(8), pCopyFunc(9), pCopyFunc(10),pCopyFunc(11), pCopyFunc(12), pCopyFunc(13), pCopyFunc(14), pCopyFunc(15), pCopyFunc(16), pCopyFunc(17), pCopyFunc(18), pCopyFunc(19), pCopyFunc(20),pCopyFunc(21), pCopyFunc(22), pCopyFunc(23), pCopyFunc(24), pCopyFunc(25), pCopyFunc(26), pCopyFunc(27), pCopyFunc(28), pCopyFunc(29), pCopyFunc(30),pCopyFunc(31), pCopyFunc(32), pCopyFunc(33), pCopyFunc(34), pCopyFunc(35), pCopyFunc(36), pCopyFunc(37), pCopyFunc(38), pCopyFunc(39), pCopyFunc(40),pCopyFunc(41), pCopyFunc(42), pCopyFunc(43), pCopyFunc(44), pCopyFunc(45), pCopyFunc(46), pCopyFunc(47), pCopyFunc(48), pCopyFunc(49), pCopyFunc(50),pCopyFunc(51), pCopyFunc(52), pCopyFunc(53), pCopyFunc(54), pCopyFunc(55), pCopyFunc(56), pCopyFunc(57), pCopyFunc(58), pCopyFunc(59), pCopyFunc(60),pCopyFunc(61), pCopyFunc(62), pCopyFunc(63), pCopyFunc(64), pCopyFunc(65), pCopyFunc(66), pCopyFunc(67), pCopyFunc(68), pCopyFunc(69), pCopyFunc(70),pCopyFunc(71), pCopyFunc(72), pCopyFunc(73), pCopyFunc(74), pCopyFunc(75), pCopyFunc(76), pCopyFunc(77), pCopyFunc(78), pCopyFunc(79), pCopyFunc(80),pCopyFunc(81), pCopyFunc(82), pCopyFunc(83), pCopyFunc(84), pCopyFunc(85), pCopyFunc(86), pCopyFunc(87), pCopyFunc(88), pCopyFunc(89), pCopyFunc(90),pCopyFunc(91), pCopyFunc(92), pCopyFunc(93), pCopyFunc(94), pCopyFunc(95), pCopyFunc(96), pCopyFunc(97), pCopyFunc(98), pCopyFunc(99), pCopyFunc(100),pCopyFunc(101), pCopyFunc(102), pCopyFunc(103), pCopyFunc(104), pCopyFunc(105), pCopyFunc(106), pCopyFunc(107), pCopyFunc(108), pCopyFunc(109), pCopyFunc(110),pCopyFunc(111), pCopyFunc(112), pCopyFunc(113), pCopyFunc(114), pCopyFunc(115), pCopyFunc(116), pCopyFunc(117), pCopyFunc(118), pCopyFunc(119), pCopyFunc(120),pCopyFunc(121), pCopyFunc(122), pCopyFunc(123), pCopyFunc(124), pCopyFunc(125), pCopyFunc(126), pCopyFunc(127), pCopyFunc(128),
};
#undef pCopyFunc#define pCopyFunc(x) ZMemoryCopy::___copy_##x
static void(*const static_copys[129])(char* dest, const char* src) =
{ZMemoryCopy::___copy_0,pCopyFunc(1), pCopyFunc(2), pCopyFunc(3), pCopyFunc(4), pCopyFunc(5), pCopyFunc(6), pCopyFunc(7), pCopyFunc(8), pCopyFunc(9), pCopyFunc(10),pCopyFunc(11), pCopyFunc(12), pCopyFunc(13), pCopyFunc(14), pCopyFunc(15), pCopyFunc(16), pCopyFunc(17), pCopyFunc(18), pCopyFunc(19), pCopyFunc(20),pCopyFunc(21), pCopyFunc(22), pCopyFunc(23), pCopyFunc(24), pCopyFunc(25), pCopyFunc(26), pCopyFunc(27), pCopyFunc(28), pCopyFunc(29), pCopyFunc(30),pCopyFunc(31), pCopyFunc(32), pCopyFunc(33), pCopyFunc(34), pCopyFunc(35), pCopyFunc(36), pCopyFunc(37), pCopyFunc(38), pCopyFunc(39), pCopyFunc(40),pCopyFunc(41), pCopyFunc(42), pCopyFunc(43), pCopyFunc(44), pCopyFunc(45), pCopyFunc(46), pCopyFunc(47), pCopyFunc(48), pCopyFunc(49), pCopyFunc(50),pCopyFunc(51), pCopyFunc(52), pCopyFunc(53), pCopyFunc(54), pCopyFunc(55), pCopyFunc(56), pCopyFunc(57), pCopyFunc(58), pCopyFunc(59), pCopyFunc(60),pCopyFunc(61), pCopyFunc(62), pCopyFunc(63), pCopyFunc(64), pCopyFunc(65), pCopyFunc(66), pCopyFunc(67), pCopyFunc(68), pCopyFunc(69), pCopyFunc(70),pCopyFunc(71), pCopyFunc(72), pCopyFunc(73), pCopyFunc(74), pCopyFunc(75), pCopyFunc(76), pCopyFunc(77), pCopyFunc(78), pCopyFunc(79), pCopyFunc(80),pCopyFunc(81), pCopyFunc(82), pCopyFunc(83), pCopyFunc(84), pCopyFunc(85), pCopyFunc(86), pCopyFunc(87), pCopyFunc(88), pCopyFunc(89), pCopyFunc(90),pCopyFunc(91), pCopyFunc(92), pCopyFunc(93), pCopyFunc(94), pCopyFunc(95), pCopyFunc(96), pCopyFunc(97), pCopyFunc(98), pCopyFunc(99), pCopyFunc(100),pCopyFunc(101), pCopyFunc(102), pCopyFunc(103), pCopyFunc(104), pCopyFunc(105), pCopyFunc(106), pCopyFunc(107), pCopyFunc(108), pCopyFunc(109), pCopyFunc(110),pCopyFunc(111), pCopyFunc(112), pCopyFunc(113), pCopyFunc(114), pCopyFunc(115), pCopyFunc(116), pCopyFunc(117), pCopyFunc(118), pCopyFunc(119), pCopyFunc(120),pCopyFunc(121), pCopyFunc(122), pCopyFunc(123), pCopyFunc(124), pCopyFunc(125), pCopyFunc(126), pCopyFunc(127), pCopyFunc(128),
};
#undef pCopyFuncchar dest[32000000];
char dest2[32000000];
const char pSource_[32000000] = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"123456789012345678901234567-901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890""abcde67890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
const char * volatile pSource = pSource_;// __declspec(noinline) void __fastcall donothing(int v)
// {
//  	__asm nop;
// }
// int _______reserved = (donothing((const volatile int&)(const int&)1), donothing((const volatile int&)(const int&)2), 1);
// __declspec(noinline) void __fastcall donothing_(int v)
// {
// 	donothing(v);
// }
// 
// __declspec(noinline) bool testConstFunction()
// {
// 	unsigned char* ptr;
// 	if (*(unsigned short*)((ptr = (unsigned char*)_ReturnAddress())- 15) == *(unsigned short*)"\xC7\x05")
// 	{
// 		DWORD p;
// 		VirtualProtect(ptr - 15, 15, PAGE_EXECUTE_READWRITE, &p);
// 		p = *(int*)(ptr - 15 + 2 + 4);
// 		memcpy(ptr - 15, "\xB8\x90\x90\x90\x90\xB8\x01\x00\x00\x00\x90\x90\x90\x90\x90", 15);	//mov eax, 1
// 		*(int*)(ptr - 14) = p;
// 		return true;
// 	}
// 	else
// 	{
// 		DWORD p;
// 		VirtualProtect(ptr - 10, 10, PAGE_EXECUTE_READWRITE, &p);
// 		memcpy(ptr - 10, "\xB8\x00\x00\x00\x00\xB8\x00\x00\x00\x00", 10);	//mov eax, 0
// 		return false;
// 	}
// }
// 
// static int g_somewhere;
// #define testConst(v) (_mm_pause(), g_somewhere = v, testConstFunction())void test();#define constsize 63					//每次复制的内存大小
#if 0							//1 开启无缓存测试：通过不断改变地址使cache失效
#define nocache + (i & 0xFFF) * 4096		
#else							//0 开启有缓存测试：源数据和目标数据总在cache中
#define nocache
#endif#if constsize > 128
#define copysize constsize
namespace ZMemoryCopy
{
#include "zmemcpyinc.h"
}
#endif#pragma runtime_checks( "s", restore ) int _tmain(int argc, _TCHAR* argv[])
{if (g_IsReleaseMode)puts("Release Mode");elseputs("Debug Mode");char test[2000];for (int i = 1; i <= 128; ++i){memset(test, 0, 200);template_copys[i](test, pSource);if(memcmp(test, pSource, i) != 0)__debugbreak();if (test[i] != (char)0)__debugbreak();}for (int i = 1; i <= 499; ++i){memset(test, 0, 500);zmemcpy(test, pSource, i);if (memcmp(test, pSource, i) != 0)__debugbreak();if (test[i] != (char)0)__debugbreak();}for (int i = 1; i <= 128; ++i){memset(test, 0, 200);static_copys[i](test, pSource);if (memcmp(test, pSource, i) != 0)__debugbreak();if (test[i] != (char)0)__debugbreak();}memset(dest, 0, sizeof(dest));memset(dest2, 0, sizeof(dest2));memcpy(dest2, pSource, sizeof(dest2));int volatile unknownSize = constsize;for (int j = 0; j < 4; ++j){{__int64 t = __rdtsc();for (int i = 0; i < 10000000; ++i){ZMemoryCopy::copy<constsize>(dest nocache/*+ 1*/, pSource nocache /*+ 1*/);}t = __rdtsc() - t;printf("All time to memcpy %d * %dM is %0.3fs in 3GHz (zmemcopy template const size)\n", constsize, 100000000 / 1000000, t / 3000000000.0);}{__int64 t = __rdtsc();for (int i = 0; i < 10000000; ++i){_COMBINE(ZMemoryCopy::___copy_, constsize)(dest nocache/*+ 1*/, pSource nocache /*+ 1*/);}t = __rdtsc() - t;printf("All time to memcpy %d * %dM is %0.3fs in 3GHz (zmemcopy static  const size)\n", constsize, 100000000 / 1000000, t / 3000000000.0);}{__int64 t = __rdtsc();for (int i = 0; i < 10000000; ++i){memcpy(dest nocache/*+ 1*/, pSource nocache/*+ 1*/, constsize);}t = __rdtsc() - t;printf("All time to memcpy %d * %dM is %0.3fs in 3GHz (memcpy const size)\n", constsize, 100000000 / 1000000, t / 3000000000.0);}{__int64 t = __rdtsc();for (int i = 0; i < 10000000; ++i){zmemcpy(dest nocache/*+ 1*/, pSource nocache /*+ 1*/, constsize);}t = __rdtsc() - t;printf("All time to memcpy %d * %dM is %0.3fs in 3GHz (zmemcopy const size)\n", constsize, 100000000 / 1000000, t / 3000000000.0);}if (unknownSize < 128){__int64 t = __rdtsc();for (int i = 0; i < 10000000; ++i){copys[unknownSize](dest nocache/*+ 1*/, pSource nocache /*+ 1*/);}t = __rdtsc() - t;printf("All time to memcpy %d * %dM is %0.3fs in 3GHz (zmemcopy unknown array direct)\n", constsize, 100000000 / 1000000, t / 3000000000.0);}if (unknownSize < 128){__int64 t = __rdtsc();for (int i = 0; i < 10000000; ++i){zmemcpy_max128(dest nocache/*+ 1*/, pSource nocache /*+ 1*/, unknownSize);}t = __rdtsc() - t;printf("All time to memcpy %d * %dM is %0.3fs in 3GHz (zmemcopy unknown small size)\n", constsize, 100000000 / 1000000, t / 3000000000.0);}{__int64 t = __rdtsc();for (int i = 0; i < 10000000; ++i){zmemcpy(dest nocache/*+ 1*/, pSource nocache /*+ 1*/, unknownSize);}t = __rdtsc() - t;printf("All time to memcpy %d * %dM is %0.3fs in 3GHz (zmemcopy unknown size)\n", constsize, 100000000 / 1000000, t / 3000000000.0);}{__int64 t = __rdtsc();for (int i = 0; i < 10000000; ++i){memcpy(dest nocache/*+ 1*/, pSource nocache /*+ 1*/, unknownSize);}t = __rdtsc() - t;printf("All time to memcpy %d * %dM is %0.3fs in 3GHz (memcpy unknown size)\n", constsize, 100000000 / 1000000, t / 3000000000.0);}puts("");}return 0;
}#pragma runtime_checks( "s", restore )


zmemcpy.h:

#pragma once#include <windows.h>
#include <intrin.h>#ifndef _SAFEBUFFERS
#if _MSC_VER >= 1600
#define _SAFEBUFFERS __declspec(safebuffers)
#else
#define _SAFEBUFFERS
#endif
#endifnamespace z
{
#ifndef _Z_IF_DEFINED
#define _Z_IF_DEFINEDtemplate<bool v>struct If{enum{ True = 1 };};template<>struct If < false >{enum{ False = 1 };};//强制使用z::If<false>和z::If<true>//这样__if_exists有效
#if _MSC_VER >= 1600static_assert(z::If<false>::False, "");static_assert(z::If<true>::True, "");
#elseenum{ ___unknown = z::If<true>::True + z::If<false>::False };
#endif#endif //_Z_IF_DEFINED#pragma runtime_checks( "s", off) //由于#pragma runtime_checks必须在cpp末尾关闭，才能对模板生效，因此这里手工动态修改机器码移除stack check代码//加速Debug模式下的函数执行inline __declspec(noinline) _SAFEBUFFERS void RemoveCodeOf_InitESPBuffer(){__asm pushad;{unsigned char* ptr;if (*(unsigned int*)((ptr = (unsigned char*)_ReturnAddress() - 17) + 5) == *(unsigned int*)"\xB8\xCC\xCC\xCC"){DWORD p;VirtualProtect(ptr, 17, PAGE_EXECUTE_READWRITE, &p);//memset(ptr, 0x90, 17);memcpy(ptr, "\xE9\x0C\x00\x00\x00\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90", 17);}else if (*(unsigned char*)(ptr = (unsigned char*)_ReturnAddress() - 5) == 0xE8u){DWORD p;VirtualProtect(ptr, 5, PAGE_EXECUTE_READWRITE, &p);memset(ptr, 0x90, 5);}}__asm popad;}inline __declspec(noinline) _SAFEBUFFERS void RemoveCodeOf_CheckESP(){unsigned char* ptr;if (*(unsigned char*)(ptr = (unsigned char*)_ReturnAddress() - 5) == 0xE8u){DWORD p;VirtualProtect(ptr, 22, PAGE_EXECUTE_READWRITE, &p);memset(ptr, 0x90, 5);if (*(unsigned int*)(ptr + 5 + 1 + 3 + 5) == *(unsigned int*)"\x00\x3B\xEC\xE8"){memset(ptr + 5 + 1 + 3 + 5 + 1, 0x90, 7);memcpy(ptr + 5 + 1 + 3 + 5 + 1, "\x8B\xE5\x5D\xC3", 4);//   memcpy(ptr + 5, "\x5F\x5E\x5B\x81\xC4\xC0\x00\x00\x00\x8B\xE5\x5D\xC3", 13);}//3B EC cmp         ebp, esp//E8 xxxxxxxx call  __RTC_CheckEsp}else{__debugbreak();}}#pragma runtime_checks( "s", restore ) 
}namespace ZMemoryCopy
{
#pragma runtime_checks( "s", off) //成组地复制128字节inline __declspec(noinline) _SAFEBUFFERS void __copy_group(char* dest, const char* src, int size){__asm{mov esi, dword ptr[src];mov edi, dword ptr[dest];}while ((size -= 0x80) >= 0){__asm{movdqu xmm0, xmmword ptr[esi + 0x00];movdqu xmm1, xmmword ptr[esi + 0x10];movdqu xmm2, xmmword ptr[esi + 0x20];movdqu xmm3, xmmword ptr[esi + 0x30];movdqu xmm4, xmmword ptr[esi + 0x40];movdqu xmm5, xmmword ptr[esi + 0x50];movdqu xmm6, xmmword ptr[esi + 0x60];movdqu xmm7, xmmword ptr[esi + 0x70];prefetchnta[esi + 0x80];prefetchnta[esi + 0xC0];movdqu xmmword ptr[edi + 0x00], xmm0;movdqu xmmword ptr[edi + 0x10], xmm1;movdqu xmmword ptr[edi + 0x20], xmm2;movdqu xmmword ptr[edi + 0x30], xmm3;movdqu xmmword ptr[edi + 0x40], xmm4;movdqu xmmword ptr[edi + 0x50], xmm5;movdqu xmmword ptr[edi + 0x60], xmm6;movdqu xmmword ptr[edi + 0x70], xmm7;add esi, 0x80;add edi, 0x80;}}}//如果已知块大小（且是常量表达式），可以直接使用这个版本template<int copysize>static _SAFEBUFFERS __forceinline void copy(char* dest, const char* src){//由于#pragma runtime_checks必须在cpp末尾关闭，才能对模板生效，因此这里手工动态修改机器码移除stack check代码//加速Debug模式下的函数执行z::RemoveCodeOf_InitESPBuffer();__if_exists(z::If<(copysize >= 4000)>::True){memcpy(dest, src, copysize);}__if_exists(z::If<(copysize >= 4000)>::False){__asm{mov esi, dword ptr[src];mov edi, dword ptr[dest];}__if_exists(z::If<(copysize >= 0x80 * 3)>::True){__asm{prefetchnta[esi + 0x40];}int vsize = copysize;while ((vsize -= 0x80) >= 0x80)}//__if_exists(z::If<(copysize >= 0x80 * 2)>::True){__asm{movdqu xmm0, xmmword ptr[esi + 0x00];movdqu xmm1, xmmword ptr[esi + 0x10];movdqu xmm2, xmmword ptr[esi + 0x20];movdqu xmm3, xmmword ptr[esi + 0x30];movdqu xmm4, xmmword ptr[esi + 0x40];movdqu xmm5, xmmword ptr[esi + 0x50];movdqu xmm6, xmmword ptr[esi + 0x60];movdqu xmm7, xmmword ptr[esi + 0x70];prefetchnta[esi + 0x80];prefetchnta[esi + 0xC0];movdqu xmmword ptr[edi + 0x00], xmm0;movdqu xmmword ptr[edi + 0x10], xmm1;movdqu xmmword ptr[edi + 0x20], xmm2;movdqu xmmword ptr[edi + 0x30], xmm3;movdqu xmmword ptr[edi + 0x40], xmm4;movdqu xmmword ptr[edi + 0x50], xmm5;movdqu xmmword ptr[edi + 0x60], xmm6;movdqu xmmword ptr[edi + 0x70], xmm7;add esi, 0x80;add edi, 0x80;}}enum { offset1 = 0 };//__if_exists(z::If<(copysize >= 0x80)>::True){__asm{movdqu xmm0, xmmword ptr[esi + 0x00];movdqu xmm1, xmmword ptr[esi + 0x10];movdqu xmm2, xmmword ptr[esi + 0x20];movdqu xmm3, xmmword ptr[esi + 0x30];movdqu xmm4, xmmword ptr[esi + 0x40];movdqu xmm5, xmmword ptr[esi + 0x50];movdqu xmm6, xmmword ptr[esi + 0x60];movdqu xmm7, xmmword ptr[esi + 0x70];}__if_exists(z::If<(copysize & 0x60)>::True){__asm{prefetchnta[esi + 0x80];}}__asm{movdqu xmmword ptr[edi + 0x00], xmm0;movdqu xmmword ptr[edi + 0x10], xmm1;movdqu xmmword ptr[edi + 0x20], xmm2;movdqu xmmword ptr[edi + 0x30], xmm3;movdqu xmmword ptr[edi + 0x40], xmm4;movdqu xmmword ptr[edi + 0x50], xmm5;movdqu xmmword ptr[edi + 0x60], xmm6;movdqu xmmword ptr[edi + 0x70], xmm7;//    add esi, 0x80;//    add edi, 0x80;}enum { offset2 = 0x80 };}__if_exists(z::If<(copysize >= 0x80)>::False){enum { offset2 = 0 };}//__if_exists(z::If<(copysize & 0x40)>::True){__asm{movdqu xmm0, xmmword ptr[esi + offset2 + 0x00];movdqu xmm1, xmmword ptr[esi + offset2 + 0x10];movdqu xmm2, xmmword ptr[esi + offset2 + 0x20];movdqu xmm3, xmmword ptr[esi + offset2 + 0x30];movdqu xmmword ptr[edi + offset2 + 0x00], xmm0;movdqu xmmword ptr[edi + offset2 + 0x10], xmm1;movdqu xmmword ptr[edi + offset2 + 0x20], xmm2;movdqu xmmword ptr[edi + offset2 + 0x30], xmm3;}enum { offset3 = offset2 + 0x40 };}__if_exists(z::If<(copysize & 0x40)>::False){enum { offset3 = offset2 };}//__if_exists(z::If<(copysize & 0x20)>::True){__asm{movdqu xmm4, xmmword ptr[esi + offset3 + 0x00];movdqu xmm5, xmmword ptr[esi + offset3 + 0x10];movdqu xmmword ptr[edi + offset3 + 0x00], xmm4;movdqu xmmword ptr[edi + offset3 + 0x10], xmm5;}enum { offset4 = offset3 + 0x20 };}__if_exists(z::If<(copysize & 0x20)>::False){enum { offset4 = offset3 };}//__if_exists(z::If<(copysize & 0x10)>::True){__asm{movdqu xmm6, xmmword ptr[esi + offset4 + 0x00];movdqu xmmword ptr[edi + offset4 + 0x00], xmm6;}enum { offset5 = offset4 + 0x10 };}__if_exists(z::If<(copysize & 0x10)>::False){enum { offset5 = offset4 };}//__if_exists(z::If<(copysize & 0x8)>::True){__asm{movlpd xmm7, qword ptr[esi + offset5];movlpd qword ptr[edi + offset5], xmm7;}enum { offset6 = offset5 + 0x8 };}__if_exists(z::If<(copysize & 0x8)>::False){enum { offset6 = offset5 };}//__if_exists(z::If<(copysize & 0x7)>::True){enum { copydone = false };{__if_exists(z::If < ((copysize & 0x7) > 4) && copysize >= 8 > ::True) // 5 6 7 //8字节移动版{enum{ copy_offset = (copysize & 0x7) - 8 };__asm{movlpd xmm0, qword ptr[esi + offset6 + copy_offset];movlpd qword ptr[edi + offset6 + copy_offset], xmm0;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x7) >= 4)>::True) // 4 5 6 7        //缓冲区不够先移动4字节{__asm{mov eax, dword ptr[esi + offset6];mov dword ptr[edi + offset6], eax;}enum{ offset6 = offset6 + 4 };}__if_exists(z::If <!copydone && ((copysize & 0x3) == 3) && (copysize >= 4)> ::True) //3{__asm{mov eax, dword ptr[esi + offset6 - 1];mov dword ptr[edi + offset6 - 1], eax;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x3) == 3)> ::True) //3{__asm{mov ax, word ptr[esi + offset6];mov word ptr[edi + offset6], ax;mov al, byte ptr[esi + offset6 + 2];mov byte ptr[edi + offset6 + 2], al;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x3) == 2) > ::True) //2{__asm{mov ax, word ptr[esi + offset6];mov word ptr[edi + offset6], ax;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x3) == 1) > ::True) //1{__asm{mov al, byte ptr[esi + offset6];mov byte ptr[edi + offset6], al;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x3) == 0) > ::True) //0{enum { copydone = true };//return;}__if_exists(z::If<!copydone>::True){static_assert(0, "");}}}}z::RemoveCodeOf_CheckESP();__asm nop;}inline void ___copy_0(char* dest, const char* src){}#pragma runtime_checks( "s", restore)#define copysize 1
#include "zmemcpyinc.h"
#define copysize 2
#include "zmemcpyinc.h"
#define copysize 3
#include "zmemcpyinc.h"
#define copysize 4
#include "zmemcpyinc.h"
#define copysize 5
#include "zmemcpyinc.h"
#define copysize 6
#include "zmemcpyinc.h"
#define copysize 7
#include "zmemcpyinc.h"
#define copysize 8
#include "zmemcpyinc.h"
#define copysize 9
#include "zmemcpyinc.h"
#define copysize 10
#include "zmemcpyinc.h"
#define copysize 11
#include "zmemcpyinc.h"
#define copysize 12
#include "zmemcpyinc.h"
#define copysize 13
#include "zmemcpyinc.h"
#define copysize 14
#include "zmemcpyinc.h"
#define copysize 15
#include "zmemcpyinc.h"
#define copysize 16
#include "zmemcpyinc.h"
#define copysize 17
#include "zmemcpyinc.h"
#define copysize 18
#include "zmemcpyinc.h"
#define copysize 19
#include "zmemcpyinc.h"
#define copysize 20
#include "zmemcpyinc.h"
#define copysize 21
#include "zmemcpyinc.h"
#define copysize 22
#include "zmemcpyinc.h"
#define copysize 23
#include "zmemcpyinc.h"
#define copysize 24
#include "zmemcpyinc.h"
#define copysize 25
#include "zmemcpyinc.h"
#define copysize 26
#include "zmemcpyinc.h"
#define copysize 27
#include "zmemcpyinc.h"
#define copysize 28
#include "zmemcpyinc.h"
#define copysize 29
#include "zmemcpyinc.h"
#define copysize 30
#include "zmemcpyinc.h"
#define copysize 31
#include "zmemcpyinc.h"
#define copysize 32
#include "zmemcpyinc.h"
#define copysize 33
#include "zmemcpyinc.h"
#define copysize 34
#include "zmemcpyinc.h"
#define copysize 35
#include "zmemcpyinc.h"
#define copysize 36
#include "zmemcpyinc.h"
#define copysize 37
#include "zmemcpyinc.h"
#define copysize 38
#include "zmemcpyinc.h"
#define copysize 39
#include "zmemcpyinc.h"
#define copysize 40
#include "zmemcpyinc.h"
#define copysize 41
#include "zmemcpyinc.h"
#define copysize 42
#include "zmemcpyinc.h"
#define copysize 43
#include "zmemcpyinc.h"
#define copysize 44
#include "zmemcpyinc.h"
#define copysize 45
#include "zmemcpyinc.h"
#define copysize 46
#include "zmemcpyinc.h"
#define copysize 47
#include "zmemcpyinc.h"
#define copysize 48
#include "zmemcpyinc.h"
#define copysize 49
#include "zmemcpyinc.h"
#define copysize 50
#include "zmemcpyinc.h"
#define copysize 51
#include "zmemcpyinc.h"
#define copysize 52
#include "zmemcpyinc.h"
#define copysize 53
#include "zmemcpyinc.h"
#define copysize 54
#include "zmemcpyinc.h"
#define copysize 55
#include "zmemcpyinc.h"
#define copysize 56
#include "zmemcpyinc.h"
#define copysize 57
#include "zmemcpyinc.h"
#define copysize 58
#include "zmemcpyinc.h"
#define copysize 59
#include "zmemcpyinc.h"
#define copysize 60
#include "zmemcpyinc.h"
#define copysize 61
#include "zmemcpyinc.h"
#define copysize 62
#include "zmemcpyinc.h"
#define copysize 63
#include "zmemcpyinc.h"
#define copysize 64
#include "zmemcpyinc.h"
#define copysize 65
#include "zmemcpyinc.h"
#define copysize 66
#include "zmemcpyinc.h"
#define copysize 67
#include "zmemcpyinc.h"
#define copysize 68
#include "zmemcpyinc.h"
#define copysize 69
#include "zmemcpyinc.h"
#define copysize 70
#include "zmemcpyinc.h"
#define copysize 71
#include "zmemcpyinc.h"
#define copysize 72
#include "zmemcpyinc.h"
#define copysize 73
#include "zmemcpyinc.h"
#define copysize 74
#include "zmemcpyinc.h"
#define copysize 75
#include "zmemcpyinc.h"
#define copysize 76
#include "zmemcpyinc.h"
#define copysize 77
#include "zmemcpyinc.h"
#define copysize 78
#include "zmemcpyinc.h"
#define copysize 79
#include "zmemcpyinc.h"
#define copysize 80
#include "zmemcpyinc.h"
#define copysize 81
#include "zmemcpyinc.h"
#define copysize 82
#include "zmemcpyinc.h"
#define copysize 83
#include "zmemcpyinc.h"
#define copysize 84
#include "zmemcpyinc.h"
#define copysize 85
#include "zmemcpyinc.h"
#define copysize 86
#include "zmemcpyinc.h"
#define copysize 87
#include "zmemcpyinc.h"
#define copysize 88
#include "zmemcpyinc.h"
#define copysize 89
#include "zmemcpyinc.h"
#define copysize 90
#include "zmemcpyinc.h"
#define copysize 91
#include "zmemcpyinc.h"
#define copysize 92
#include "zmemcpyinc.h"
#define copysize 93
#include "zmemcpyinc.h"
#define copysize 94
#include "zmemcpyinc.h"
#define copysize 95
#include "zmemcpyinc.h"
#define copysize 96
#include "zmemcpyinc.h"
#define copysize 97
#include "zmemcpyinc.h"
#define copysize 98
#include "zmemcpyinc.h"
#define copysize 99
#include "zmemcpyinc.h"
#define copysize 100
#include "zmemcpyinc.h"
#define copysize 101
#include "zmemcpyinc.h"
#define copysize 102
#include "zmemcpyinc.h"
#define copysize 103
#include "zmemcpyinc.h"
#define copysize 104
#include "zmemcpyinc.h"
#define copysize 105
#include "zmemcpyinc.h"
#define copysize 106
#include "zmemcpyinc.h"
#define copysize 107
#include "zmemcpyinc.h"
#define copysize 108
#include "zmemcpyinc.h"
#define copysize 109
#include "zmemcpyinc.h"
#define copysize 110
#include "zmemcpyinc.h"
#define copysize 111
#include "zmemcpyinc.h"
#define copysize 112
#include "zmemcpyinc.h"
#define copysize 113
#include "zmemcpyinc.h"
#define copysize 114
#include "zmemcpyinc.h"
#define copysize 115
#include "zmemcpyinc.h"
#define copysize 116
#include "zmemcpyinc.h"
#define copysize 117
#include "zmemcpyinc.h"
#define copysize 118
#include "zmemcpyinc.h"
#define copysize 119
#include "zmemcpyinc.h"
#define copysize 120
#include "zmemcpyinc.h"
#define copysize 121
#include "zmemcpyinc.h"
#define copysize 122
#include "zmemcpyinc.h"
#define copysize 123
#include "zmemcpyinc.h"
#define copysize 124
#include "zmemcpyinc.h"
#define copysize 125
#include "zmemcpyinc.h"
#define copysize 126
#include "zmemcpyinc.h"
#define copysize 127
#include "zmemcpyinc.h"
#define copysize 128
#include "zmemcpyinc.h"#pragma runtime_checks( "s", off ) __forceinline void zmemcpy(char* dest, const char* src, size_t size){
#define pCopyFunc(x) ZMemoryCopy::___copy_##xstatic void(*const static_copys[129])(char* dest, const char* src) ={ZMemoryCopy::___copy_0,pCopyFunc(1), pCopyFunc(2), pCopyFunc(3), pCopyFunc(4), pCopyFunc(5), pCopyFunc(6), pCopyFunc(7), pCopyFunc(8), pCopyFunc(9), pCopyFunc(10),pCopyFunc(11), pCopyFunc(12), pCopyFunc(13), pCopyFunc(14), pCopyFunc(15), pCopyFunc(16), pCopyFunc(17), pCopyFunc(18), pCopyFunc(19), pCopyFunc(20),pCopyFunc(21), pCopyFunc(22), pCopyFunc(23), pCopyFunc(24), pCopyFunc(25), pCopyFunc(26), pCopyFunc(27), pCopyFunc(28), pCopyFunc(29), pCopyFunc(30),pCopyFunc(31), pCopyFunc(32), pCopyFunc(33), pCopyFunc(34), pCopyFunc(35), pCopyFunc(36), pCopyFunc(37), pCopyFunc(38), pCopyFunc(39), pCopyFunc(40),pCopyFunc(41), pCopyFunc(42), pCopyFunc(43), pCopyFunc(44), pCopyFunc(45), pCopyFunc(46), pCopyFunc(47), pCopyFunc(48), pCopyFunc(49), pCopyFunc(50),pCopyFunc(51), pCopyFunc(52), pCopyFunc(53), pCopyFunc(54), pCopyFunc(55), pCopyFunc(56), pCopyFunc(57), pCopyFunc(58), pCopyFunc(59), pCopyFunc(60),pCopyFunc(61), pCopyFunc(62), pCopyFunc(63), pCopyFunc(64), pCopyFunc(65), pCopyFunc(66), pCopyFunc(67), pCopyFunc(68), pCopyFunc(69), pCopyFunc(70),pCopyFunc(71), pCopyFunc(72), pCopyFunc(73), pCopyFunc(74), pCopyFunc(75), pCopyFunc(76), pCopyFunc(77), pCopyFunc(78), pCopyFunc(79), pCopyFunc(80),pCopyFunc(81), pCopyFunc(82), pCopyFunc(83), pCopyFunc(84), pCopyFunc(85), pCopyFunc(86), pCopyFunc(87), pCopyFunc(88), pCopyFunc(89), pCopyFunc(90),pCopyFunc(91), pCopyFunc(92), pCopyFunc(93), pCopyFunc(94), pCopyFunc(95), pCopyFunc(96), pCopyFunc(97), pCopyFunc(98), pCopyFunc(99), pCopyFunc(100),pCopyFunc(101), pCopyFunc(102), pCopyFunc(103), pCopyFunc(104), pCopyFunc(105), pCopyFunc(106), pCopyFunc(107), pCopyFunc(108), pCopyFunc(109), pCopyFunc(110),pCopyFunc(111), pCopyFunc(112), pCopyFunc(113), pCopyFunc(114), pCopyFunc(115), pCopyFunc(116), pCopyFunc(117), pCopyFunc(118), pCopyFunc(119), pCopyFunc(120),pCopyFunc(121), pCopyFunc(122), pCopyFunc(123), pCopyFunc(124), pCopyFunc(125), pCopyFunc(126), pCopyFunc(127), pCopyFunc(128),};
#undef pCopyFuncif (size >= 128)__copy_group(dest, src, size);if (size & 127)static_copys[size & 127](dest + (size &~127), src + (size &~127));}__forceinline void zmemcpy_max128(char* dest, const char* src, size_t size){
#define pCopyFunc(x) ZMemoryCopy::___copy_##xstatic void(*const static_copys[129])(char* dest, const char* src) ={ZMemoryCopy::___copy_0,pCopyFunc(1), pCopyFunc(2), pCopyFunc(3), pCopyFunc(4), pCopyFunc(5), pCopyFunc(6), pCopyFunc(7), pCopyFunc(8), pCopyFunc(9), pCopyFunc(10),pCopyFunc(11), pCopyFunc(12), pCopyFunc(13), pCopyFunc(14), pCopyFunc(15), pCopyFunc(16), pCopyFunc(17), pCopyFunc(18), pCopyFunc(19), pCopyFunc(20),pCopyFunc(21), pCopyFunc(22), pCopyFunc(23), pCopyFunc(24), pCopyFunc(25), pCopyFunc(26), pCopyFunc(27), pCopyFunc(28), pCopyFunc(29), pCopyFunc(30),pCopyFunc(31), pCopyFunc(32), pCopyFunc(33), pCopyFunc(34), pCopyFunc(35), pCopyFunc(36), pCopyFunc(37), pCopyFunc(38), pCopyFunc(39), pCopyFunc(40),pCopyFunc(41), pCopyFunc(42), pCopyFunc(43), pCopyFunc(44), pCopyFunc(45), pCopyFunc(46), pCopyFunc(47), pCopyFunc(48), pCopyFunc(49), pCopyFunc(50),pCopyFunc(51), pCopyFunc(52), pCopyFunc(53), pCopyFunc(54), pCopyFunc(55), pCopyFunc(56), pCopyFunc(57), pCopyFunc(58), pCopyFunc(59), pCopyFunc(60),pCopyFunc(61), pCopyFunc(62), pCopyFunc(63), pCopyFunc(64), pCopyFunc(65), pCopyFunc(66), pCopyFunc(67), pCopyFunc(68), pCopyFunc(69), pCopyFunc(70),pCopyFunc(71), pCopyFunc(72), pCopyFunc(73), pCopyFunc(74), pCopyFunc(75), pCopyFunc(76), pCopyFunc(77), pCopyFunc(78), pCopyFunc(79), pCopyFunc(80),pCopyFunc(81), pCopyFunc(82), pCopyFunc(83), pCopyFunc(84), pCopyFunc(85), pCopyFunc(86), pCopyFunc(87), pCopyFunc(88), pCopyFunc(89), pCopyFunc(90),pCopyFunc(91), pCopyFunc(92), pCopyFunc(93), pCopyFunc(94), pCopyFunc(95), pCopyFunc(96), pCopyFunc(97), pCopyFunc(98), pCopyFunc(99), pCopyFunc(100),pCopyFunc(101), pCopyFunc(102), pCopyFunc(103), pCopyFunc(104), pCopyFunc(105), pCopyFunc(106), pCopyFunc(107), pCopyFunc(108), pCopyFunc(109), pCopyFunc(110),pCopyFunc(111), pCopyFunc(112), pCopyFunc(113), pCopyFunc(114), pCopyFunc(115), pCopyFunc(116), pCopyFunc(117), pCopyFunc(118), pCopyFunc(119), pCopyFunc(120),pCopyFunc(121), pCopyFunc(122), pCopyFunc(123), pCopyFunc(124), pCopyFunc(125), pCopyFunc(126), pCopyFunc(127), pCopyFunc(128),};
#undef pCopyFunc__assume(size <= 128);static_copys[size](dest, src);}
#pragma runtime_checks( "s", restore)
}
using ZMemoryCopy::zmemcpy;
using ZMemoryCopy::zmemcpy_max128;

zmemcpyinc.h :

#ifndef END_WITH_copysize
#ifndef _COMBINE2
#define _COMBINE2(x,y) x##y
#define _COMBINE(x,y) _COMBINE2(x,y)
#endif
#define END_WITH_copysize(x) _COMBINE(x, copysize)
#endif#pragma runtime_checks( "s", off )
inline void END_WITH_copysize(___copy_)(char* dest, const char* src)
{__asm{mov esi, dword ptr[src];mov edi, dword ptr[dest];}__if_exists(z::If<(copysize >= 0x80 * 3)>::True){__asm{prefetchnta[esi + 0x40];}int vsize = copysize;while ((vsize -= 0x80) >= 0x80)}//__if_exists(z::If<(copysize >= 0x80 * 2)>::True){__asm{movdqu xmm0, xmmword ptr[esi + 0x00];movdqu xmm1, xmmword ptr[esi + 0x10];movdqu xmm2, xmmword ptr[esi + 0x20];movdqu xmm3, xmmword ptr[esi + 0x30];movdqu xmm4, xmmword ptr[esi + 0x40];movdqu xmm5, xmmword ptr[esi + 0x50];movdqu xmm6, xmmword ptr[esi + 0x60];movdqu xmm7, xmmword ptr[esi + 0x70];prefetchnta[esi + 0x80];prefetchnta[esi + 0xC0];movdqu xmmword ptr[edi + 0x00], xmm0;movdqu xmmword ptr[edi + 0x10], xmm1;movdqu xmmword ptr[edi + 0x20], xmm2;movdqu xmmword ptr[edi + 0x30], xmm3;movdqu xmmword ptr[edi + 0x40], xmm4;movdqu xmmword ptr[edi + 0x50], xmm5;movdqu xmmword ptr[edi + 0x60], xmm6;movdqu xmmword ptr[edi + 0x70], xmm7;add esi, 0x80;add edi, 0x80;}}enum { offset1 = 0 };//__if_exists(z::If<(copysize >= 0x80)>::True){__asm{movdqu xmm0, xmmword ptr[esi + 0x00];movdqu xmm1, xmmword ptr[esi + 0x10];movdqu xmm2, xmmword ptr[esi + 0x20];movdqu xmm3, xmmword ptr[esi + 0x30];movdqu xmm4, xmmword ptr[esi + 0x40];movdqu xmm5, xmmword ptr[esi + 0x50];movdqu xmm6, xmmword ptr[esi + 0x60];movdqu xmm7, xmmword ptr[esi + 0x70];}__if_exists(z::If<(copysize & 0x60)>::True){__asm{prefetchnta[esi + 0x80];}}__asm{movdqu xmmword ptr[edi + 0x00], xmm0;movdqu xmmword ptr[edi + 0x10], xmm1;movdqu xmmword ptr[edi + 0x20], xmm2;movdqu xmmword ptr[edi + 0x30], xmm3;movdqu xmmword ptr[edi + 0x40], xmm4;movdqu xmmword ptr[edi + 0x50], xmm5;movdqu xmmword ptr[edi + 0x60], xmm6;movdqu xmmword ptr[edi + 0x70], xmm7;//    add esi, 0x80;//    add edi, 0x80;}enum { offset2 = 0x80 };}__if_exists(z::If<(copysize >= 0x80)>::False){enum { offset2 = 0 };}//__if_exists(z::If<(copysize & 0x40)>::True){__asm{movdqu xmm0, xmmword ptr[esi + offset2 + 0x00];movdqu xmm1, xmmword ptr[esi + offset2 + 0x10];movdqu xmm2, xmmword ptr[esi + offset2 + 0x20];movdqu xmm3, xmmword ptr[esi + offset2 + 0x30];movdqu xmmword ptr[edi + offset2 + 0x00], xmm0;movdqu xmmword ptr[edi + offset2 + 0x10], xmm1;movdqu xmmword ptr[edi + offset2 + 0x20], xmm2;movdqu xmmword ptr[edi + offset2 + 0x30], xmm3;}enum { offset3 = offset2 + 0x40 };}__if_exists(z::If<(copysize & 0x40)>::False){enum { offset3 = offset2 };}//__if_exists(z::If<(copysize & 0x20)>::True){__asm{movdqu xmm4, xmmword ptr[esi + offset3 + 0x00];movdqu xmm5, xmmword ptr[esi + offset3 + 0x10];movdqu xmmword ptr[edi + offset3 + 0x00], xmm4;movdqu xmmword ptr[edi + offset3 + 0x10], xmm5;}enum { offset4 = offset3 + 0x20 };}__if_exists(z::If<(copysize & 0x20)>::False){enum { offset4 = offset3 };}//__if_exists(z::If<(copysize & 0x10)>::True){__asm{movdqu xmm6, xmmword ptr[esi + offset4 + 0x00];movdqu xmmword ptr[edi + offset4 + 0x00], xmm6;}enum { offset5 = offset4 + 0x10 };}__if_exists(z::If<(copysize & 0x10)>::False){enum { offset5 = offset4 };}//__if_exists(z::If<(copysize & 0x8)>::True){__asm{movlpd xmm7, qword ptr[esi + offset5];movlpd qword ptr[edi + offset5], xmm7;}enum { offset6 = offset5 + 0x8 };}__if_exists(z::If<(copysize & 0x8)>::False){enum { offset6 = offset5 };}//__if_exists(z::If<(copysize & 0x7)>::True){enum { copydone = false };{__if_exists(z::If < ((copysize & 0x7) > 4) && copysize >= 8 > ::True) // 5 6 7 //8字节移动版{enum{ copy_offset = (copysize & 0x7) - 8 };__asm{movlpd xmm0, qword ptr[esi + offset6 + copy_offset];movlpd qword ptr[edi + offset6 + copy_offset], xmm0;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x7) >= 4)>::True) // 4 5 6 7        //缓冲区不够先移动4字节{__asm{mov eax, dword ptr[esi + offset6];mov dword ptr[edi + offset6], eax;}enum{ offset6 = offset6 + 4 };}__if_exists(z::If <!copydone && ((copysize & 0x3) == 3) && (copysize >= 4)> ::True) //3{__asm{mov eax, dword ptr[esi + offset6 - 1];mov dword ptr[edi + offset6 - 1], eax;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x3) == 3)> ::True) //3{__asm{mov ax, word ptr[esi + offset6];mov word ptr[edi + offset6], ax;mov al, byte ptr[esi + offset6 + 2];mov byte ptr[edi + offset6 + 2], al;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x3) == 2) > ::True) //2{__asm{mov ax, word ptr[esi + offset6];mov word ptr[edi + offset6], ax;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x3) == 1) > ::True) //1{__asm{mov al, byte ptr[esi + offset6];mov byte ptr[edi + offset6], al;}enum { copydone = true };//return;}__if_exists(z::If <!copydone && ((copysize & 0x3) == 0) > ::True) //0{enum { copydone = true };//return;}__if_exists(z::If<!copydone>::True){static_assert(0, "");}}}
}
#pragma runtime_checks( "s", restore ) #undef copysize








这篇关于z memcpy（for MSVC）小内存高速复制的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

原文地址:
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.chinasem.cn/article/747500。

相关文章

C#文件复制异常："未能找到文件"的解决方案与预防措施

C#文件复制异常："未能找到文件"的解决方案与预防措施

《C#文件复制异常：未能找到文件的解决方案与预防措施》在C#开发中,文件操作是基础中的基础,但有时最基础的File.Copy()方法也会抛出令人困惑的异常,当targetFilePath设置为D:2... 目录一个看似简单的文件操作问题问题重现与错误分析错误代码示例错误信息根本原因分析全面解决方案1. 确保
阅读更多...
Redis实现高效内存管理的示例代码

Redis实现高效内存管理的示例代码

《Redis实现高效内存管理的示例代码》Redis内存管理是其核心功能之一,为了高效地利用内存,Redis采用了多种技术和策略,如优化的数据结构、内存分配策略、内存回收、数据压缩等,下面就来详细的介绍... 目录1. 内存分配策略jemalloc 的使用2. 数据压缩和编码ziplist示例代码3. 优化的
阅读更多...
深入解析C++ 中std::map内存管理

深入解析C++ 中std::map内存管理

《深入解析C++中std::map内存管理》文章详解C++std::map内存管理,指出clear()仅删除元素可能不释放底层内存,建议用swap()与空map交换以彻底释放,针对指针类型需手动de... 目录1️、基本清空std::map2️、使用 swap 彻底释放内存3️、map 中存储指针类型的对象
阅读更多...
Python内存优化的实战技巧分享

Python内存优化的实战技巧分享

《Python内存优化的实战技巧分享》Python作为一门解释型语言,虽然在开发效率上有着显著优势,但在执行效率方面往往被诟病,然而,通过合理的内存优化策略,我们可以让Python程序的运行速度提升3... 目录前言python内存管理机制引用计数机制垃圾回收机制内存泄漏的常见原因1. 循环引用2. 全局变
阅读更多...
MySQL 临时表与复制表操作全流程案例

MySQL 临时表与复制表操作全流程案例

《MySQL临时表与复制表操作全流程案例》本文介绍MySQL临时表与复制表的区别与使用,涵盖生命周期、存储机制、操作限制、创建方法及常见问题,本文结合实例代码给大家介绍的非常详细,感兴趣的朋友跟随小... 目录一、mysql 临时表（一）核心特性拓展（二）操作全流程案例1. 复杂查询中的临时表应用2. 临时
阅读更多...
MySQL实现多源复制的示例代码

MySQL实现多源复制的示例代码

《MySQL实现多源复制的示例代码》MySQL的多源复制允许一个从服务器从多个主服务器复制数据,这在需要将多个数据源汇聚到一个数据库实例时非常有用,下面就来详细的介绍一下,感兴趣的可以了解一下... 目录一、多源复制原理二、多源复制配置步骤2.1 主服务器配置Master1配置Master2配置2.2 从服
阅读更多...
MySQL配置多主复制的实现步骤

MySQL配置多主复制的实现步骤

《MySQL配置多主复制的实现步骤》多主复制是一种允许多个MySQL服务器同时接受写操作的复制方式,本文就来介绍一下MySQL配置多主复制的实现步骤,具有一定的参考价值,感兴趣的可以了解一下... 目录1. 环境准备2. 配置每台服务器2.1 修改每台服务器的配置文件3. 安装和配置插件4. 启动组复制4.
阅读更多...
MySQL 内存使用率常用分析语句

MySQL 内存使用率常用分析语句

《MySQL内存使用率常用分析语句》用户整理了MySQL内存占用过高的分析方法,涵盖操作系统层确认及数据库层bufferpool、内存模块差值、线程状态、performance_schema性能数据... 目录一、 OS层二、 DB层1. 全局情况2. 内存占js用详情最近连续遇到mysql内存占用过高导致
阅读更多...
最新Spring Security的基于内存用户认证方式

最新Spring Security的基于内存用户认证方式

《最新SpringSecurity的基于内存用户认证方式》本文讲解SpringSecurity内存认证配置,适用于开发、测试等场景,通过代码创建用户及权限管理,支持密码加密,虽简单但不持久化,生产环... 目录1. 前言2. 因何选择内存认证？3. 基础配置实战❶ 创建Spring Security配置文件
阅读更多...
java内存泄漏排查过程及解决

java内存泄漏排查过程及解决

《java内存泄漏排查过程及解决》公司某服务内存持续增长,疑似内存泄漏,未触发OOM,排查方法包括检查JVM配置、分析GC执行状态、导出堆内存快照并用IDEAProfiler工具定位大对象及代码... 目录内存泄漏内存问题排查1.查看JVM内存配置2.分析gc是否正常执行3.导出 dump 各种工具分析4.
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2