superzmy

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 pCopyFunc



char 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");
	else
		puts("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
#endif

namespace z
{
#ifndef _Z_IF_DEFINED
#define _Z_IF_DEFINED
 template<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 >= 1600
 static_assert(z::If<false>::False, "");
 static_assert(z::If<true>::True, "");
#else
 enum{ ___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_##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 pCopyFunc

  if (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_##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 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

你可能感兴趣的:(C++,内存,memcpy,Studio,Visual)

c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
第四天旅游线路预览——从换乘中心到喀纳斯湖陟彼高冈yu 基于Google earth studio 的旅游规划和预览旅游
第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
Google earth studio 简介陟彼高冈yu 旅游
GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
第六集如何安装CentOS7.0，3分钟学会centos7安装教程 date分享
从光盘引导系统按回车键继续进入引导程序安装界面，选择语言这里选择简体中文版点击继续选择桌面安装下面给系统分区选择磁盘，点击完成选择基本分区，点击加号swap分区,大小填内存的两倍在选择根分区，使用所有可用的磁盘空间选择文件系统ext4点击完成，点击开始安装设置root密码，点击完成设置普通用户和密码，点击完成整个过程持续八分钟左右根据个人配置不同，时间长短不同好，现在点击重启系统进入重启状态点击本
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
C++菜鸟教程 - 从入门到精通第二节 DreamByte c++
一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
18、架构-可观测性之聚合度量大树~~ 架构 java python 后端架构
聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
C++ lambda闭包消除类成员变量 barbyQAQ c++c++java 算法
原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题（第三大题：完善程序代码） mmz1207 c++csp
最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
《 C++ 修炼全景指南：九》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南 c++算法 stl
摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
笋丁网页自动回复机器人V3.0.0免授权版源码希希分享软希网58soho_cn 源码资源笋丁网页自动回复机器人
笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
ARMV8体系结构简介：概述简单同学 ARMV8体系结构 ARMV8
1.前言本文主要概括的介绍ARMV8体系结构定义了哪些内容，概括的说：ARM体系结构定义了PE的行为，不会定义具体的实现ARM体系结构也定义了debug体系结构和trace体系结构ARM体系结构采用RISC指令集（1）长度一致的寄存器；（2）load/store架构，数据处理操作只能对寄存器内容进行处理，不会直接对内存的内容进行处理；（3）简单寻址方式，load/store地址来源于寄存器或指令域
20个新手学习c++必会的程序输出*三角形、杨辉三角等（附代码） X_StarX c++学习算法大学生开发语言数据结构
示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】汉子萌萌哒 CCF noi 算法数据结构 c++
一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
《 C++ 修炼全景指南：十》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南 c++数据结构 stl
摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
iOS内存管理简单理解烧烤有点辣
什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
经纬恒润二面&三七互娱一面&元象二面 Redstone Monstrosity 面试前端
1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
c++ opencv4.3 sift匹配图像处理大大大大大牛啊图像处理 opencv实战代码讲解 opencv sift c++opencv4 特征点
c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
一台适合普通办公使用的电脑推荐thinkpadE475 sam_1c14
图片发自App图片发自App缺点是内存只有4G。胜在便宜。14寸，很轻薄。给老婆买的。应该不能用来编程，会很慢的，真要用可以自己加根内存条，最大扩展到32G。图片发自App
《 C++ 修炼全景指南：四》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南 C++修炼全景指南 c++list 链表 stl
本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
华为云分布式缓存服务DCS 8月新特性发布华为云PaaS服务小智华为云分布式缓存
分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
c++ 内存处理函数 heeheeai c++开发语言
在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
矩阵求逆（JAVA）利用伴随矩阵 qiuwanchi 利用伴随矩阵求逆矩阵
package gaodai.matrix; import gaodai.determinant.DeterminantCalculation; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * 矩阵求逆(利用伴随矩阵) * @author 邱万迟
单例（Singleton）模式 aoyouzi 单例模式 Singleton
3.1 概述如果要保证系统里一个类最多只能存在一个实例时，我们就需要单例模式。这种情况在我们应用中经常碰到，例如缓存池，数据库连接池，线程池，一些应用服务实例等。在多线程环境中，为了保证实例的唯一性其实并不简单，这章将和读者一起探讨如何实现单例模式。 3.2
[开源与自主研发]就算可以轻易获得外部技术支持,自己也必须研发 comsci 开源
现在国内有大量的信息技术产品，都是通过盗版，免费下载，开源，附送等方式从国外的开发者那里获得的。。。。。。虽然这种情况带来了国内信息产业的短暂繁荣，也促进了电子商务和互联网产业的快速发展，但是实际上，我们应该清醒的看到，这些产业的核心力量是被国外的
页面有两个frame,怎样点击一个的链接改变另一个的内容 Array_06 UI XHTML
<a src="地址" targets="这里写你要操作的Frame的名字" />搜索然后你点击连接以后你的新页面就会显示在你设置的Frame名字的框那里 targerts="",就是你要填写目标的显示页面位置 ===================== 例如： <frame src=&
Struts2实现单个/多个文件上传和下载 oloz 文件上传 struts
struts2单文件上传：步骤01:jsp页面  　　<form action="fileUplo
推荐10个在线logo设计网站 362217990 logo
在线设计Logo网站。 1、http://flickr.nosv.org（这个太简单） 2、http://www.logomaker.com/?source=1.5770.1 3、http://www.simwebsol.com/ImageTool 4、http://www.logogenerator.com/logo.php?nal=1&tpl_catlist[]=2 5、ht
jsp上传文件香水浓 jsp fileupload
1. jsp上传 Notice： 1. form表单 method 属性必须设置为 POST 方法，不能使用 GET 方法 2. form表单 enctype 属性需要设置为 multipart/form-data 3. form表单 action 属性需要设置为提交到后台处理文件上传的jsp文件地址或者servlet地址。例如 uploadFile.jsp 程序文件用来处理上传的文
我的架构经验系列文章 - 前端架构 agevs JavaScript Web 框架 UI jQuer
框架层面：近几年前端发展很快，前端之所以叫前端因为前端是已经可以独立成为一种职业了，js也不再是十年前的玩具了，以前富客户端RIA的应用可能会用flash/flex或是silverlight，现在可以使用js来完成大部分的功能，因此js作为一门前端的支撑语言也不仅仅是进行的简单的编码，越来越多框架性的东西出现了。越来越多的开发模式转变为后端只是吐json的数据源，而前端做所有UI的事情。MVCMV
android ksoap2 中把XML(DataSet) 当做参数传递 aijuans android
我的android app中需要发送webservice ，于是我使用了 ksop2 进行发送，在测试过程中不是很顺利,不能正常工作.我的web service 请求格式如下 [html] view plain copy <Envelope xmlns="http://schemas.
使用Spring进行统一日志管理 + 统一异常管理 baalwolf spring
统一日志和异常管理配置好后，SSH项目中，代码以往散落的log.info() 和 try..catch..finally 再也不见踪影！统一日志异常实现类： [java] view plain copy package com.pilelot.web.util; impor
Android SDK 国内镜像 BigBird2012 android sdk
一、镜像地址： 1、东软信息学院的 Android SDK 镜像，比配置代理下载快多了。配置地址， http://mirrors.neusoft.edu.cn/configurations.we#android 2、北京化工大学的： IPV4:ubuntu.buct.edu.cn IPV4:ubuntu.buct.cn IPV6:ubuntu.buct6.edu.cn
HTML无害化和Sanitize模块 bijian1013 JavaScript AngularJS Linky Sanitize
一.ng-bind-html、ng-bind-html-unsafe AngularJS非常注重安全方面的问题，它会尽一切可能把大多数攻击手段最小化。其中一个攻击手段是向你的web页面里注入不安全的HTML，然后利用它触发跨站攻击或者注入攻击。考虑这样一个例子，假设我们有一个变量存
[Maven学习笔记二]Maven命令 bit1129 maven
mvn compile compile编译命令将src/main/java和src/main/resources中的代码和配置文件编译到target/classes中，不会对src/test/java中的测试类进行编译 MVN编译使用 maven-resources-plugin:2.6:resources maven-compiler-plugin:2.5.1:compile &nbs
【Java命令二】jhat bit1129 Java命令
jhat用于分析使用jmap dump的文件，，可以将堆中的对象以html的形式显示出来，包括对象的数量，大小等等，并支持对象查询语言。 jhat默认开启监听端口7000的HTTP服务，jhat是Java Heap Analysis Tool的缩写 1. 用法： [hadoop@hadoop bin]$ jhat -help Usage: jhat [-stack <bool&g
JBoss 5.1.0 GA:Error installing to Instantiated: name=AttachmentStore state=Desc ronin47
进到类似目录 server/default/conf/bootstrap，打开文件 profile.xml找到： Xml代码<bean name="AttachmentStore" class="org.jboss.system.server.profileservice.repository.AbstractAtta
写给初学者的6条网页设计安全配色指南 brotherlamp UI ui自学 ui视频 ui教程 ui资料
网页设计中最基本的原则之一是，不管你花多长时间创造一个华丽的设计，其最终的角色都是这场秀中真正的明星——内容的衬托我仍然清楚地记得我最早的一次美术课，那时我还是一个小小的、对凡事都充满渴望的孩子，我摆放出一大堆漂亮的彩色颜料。我仍然记得当我第一次看到原色与另一种颜色混合变成第二种颜色时的那种兴奋，并且我想，既然两种颜色能创造出一种全新的美丽色彩，那所有颜色
有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。写一个函数实现。复杂度是什么。 bylijinnan java 算法面试
import java.util.Random; import java.util.Set; import java.util.TreeSet; /** * http://weibo.com/1915548291/z7HtOF4sx * #面试题#有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。 * 写一个函数实现。复杂度是什么
struts2获得request、session、application方式 chiangfai application
1、与Servlet API解耦的访问方式。 a.Struts2对HttpServletRequest、HttpSession、ServletContext进行了封装，构造了三个Map对象来替代这三种对象要获取这三个Map对象，使用ActionContext类。 -----> package pro.action; import java.util.Map; imp
改变python的默认语言设置 chenchao051 python
import sys sys.getdefaultencoding() 可以测试出默认语言，要改变的话，需要在python lib的site-packages文件夹下新建： sitecustomize.py，这个文件比较特殊，会在python启动时来加载，所以就可以在里面写上： import sys sys.setdefaultencoding('utf-8') &n
mysql导入数据load data infile用法 daizj mysql 导入数据
我们常常导入数据！mysql有一个高效导入方法，那就是load data infile 下面来看案例说明基本语法： load data [low_priority] [local] infile 'file_name txt' [replace | ignore] into table tbl_name [fields [terminated by't'] [OPTI
phpexcel导入excel表到数据库简单入门示例 dcj3sjt126com PHP Excel
跟导出相对应的，同一个数据表，也是将phpexcel类放在class目录下，将Excel表格中的内容读取出来放到数据库中 <?php error_reporting(E_ALL); set_time_limit(0); ?> <html> <head> <meta http-equiv="Content-Type"
22岁到72岁的男人对女人的要求 dcj3sjt126com
22岁男人对女人的要求是：一，美丽，二，性感，三，有份具品味的职业，四，极有耐性，善解人意，五，该聪明的时候聪明，六，作小鸟依人状时尽量自然，七，怎样穿都好看，八，懂得适当地撒娇，九，虽作惊喜反应，但看起来自然，十，上了床就是个无条件荡妇。 32岁的男人对女人的要求，略作修定，是：一，入得厨房，进得睡房，二，不必服侍皇太后，三，不介意浪漫蜡烛配盒饭，四，听多过说，五，不再傻笑，六，懂得独
Spring和HIbernate对DDM设计的支持 e200702084 DAO 设计模式 spring Hibernate 领域模型
A：数据访问对象 DAO和资源库在领域驱动设计中都很重要。DAO是关系型数据库和应用之间的契约。它封装了Web应用中的数据库CRUD操作细节。另一方面，资源库是一个独立的抽象，它与DAO进行交互，并提供到领域模型的“业务接口”。资源库使用领域的通用语言，处理所有必要的DAO，并使用领域理解的语言提供对领域模型的数据访问服务。
NoSql 数据库的特性比较 geeksun NoSQL
Redis 是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。目前由VMware主持开发工作。 1. 数据模型作为Key-value型数据库，Redis也提供了键（Key）和值（Value）的映射关系。除了常规的数值或字符串，Redis的键值还可以是以下形式之一： Lists （列表） Sets
使用 Nginx Upload Module 实现上传文件功能 hongtoushizi nginx
转载自： http://www.tuicool.com/wx/aUrAzm 普通网站在实现文件上传功能的时候，一般是使用Python，Java等后端程序实现，比较麻烦。Nginx有一个Upload模块，可以非常简单的实现文件上传功能。此模块的原理是先把用户上传的文件保存到临时文件，然后在交由后台页面处理，并且把文件的原名，上传后的名称，文件类型，文件大小set到页面。下
spring-boot-web-ui及thymeleaf基本使用 jishiweili spring thymeleaf
视图控制层代码demo如下： @Controller @RequestMapping("/") public class MessageController { private final MessageRepository messageRepository; @Autowired public MessageController(Mes
数据源架构模式之活动记录 home198979 PHP 架构活动记录数据映射
hello!架构一、概念活动记录（Active Record）：一个对象，它包装数据库表或视图中某一行，封装数据库访问，并在这些数据上增加了领域逻辑。对象既有数据又有行为。活动记录使用直截了当的方法，把数据访问逻辑置于领域对象中。二、实现简单活动记录活动记录在php许多框架中都有应用，如cakephp。 <?php /** * 行数据入口类 *
Linux Shell脚本之自动修改IP pda158 linux centos Debian 脚本
作为一名 Linux SA，日常运维中很多地方都会用到脚本，而服务器的ip一般采用静态ip或者MAC绑定，当然后者比较操作起来相对繁琐，而前者我们可以设置主机名、ip信息、网关等配置。修改成特定的主机名在维护和管理方面也比较方便。如下脚本用途为：修改ip和主机名等相关信息，可以根据实际需求修改，举一反三！ #!/bin/sh #auto Change ip netmask ga
开发环境搭建独浮云 eclipse jdk tomcat
最近在开发过程中，经常出现MyEclipse内存溢出等错误，需要重启的情况，好麻烦。对于一般的JAVA+TOMCAT项目开发，其实没有必要使用重量级的MyEclipse，使用eclipse就足够了。尤其是开发机器硬件配置一般的人。 &n