__attribute__((target ("avx")))
never_inline
void memsetd_l2(dword *t, dword data, size_t len)
{
	__m128i val4 = _mm_set1_epi32(data);
	__m256i val8 = _mm256_set1_epi32(data);
	auto Set4 = [&](size_t at) { _mm_storeu_si128((__m128i *)(t + at), val4); };
	#define Set8(at) _mm256_storeu_si256((__m256i *)(t + at), val8);
	Set4(len - 4); // fill tail
	if(len >= 32) {
		if(len >= 1024*1024) { // for really huge data, bypass the cache
			huge_memsetd(t, data, len);
			return;
		}
		Set8(0); // align up on 16 bytes boundary
		const dword *e = t + len;
		t = (dword *)(((uintptr_t)t | 31) + 1);
		len = e - t;
		e -= 32;
		while(t <= e) {
			Set8(0); Set8(8); Set8(16); Set8(24);
			t += 32;
		}
	}
	if(len & 16) {
		Set8(0); Set8(8);
		t += 16;
	}
	if(len & 8) {
		Set8(0);
		t += 8;
	}
	if(len & 4)
		Set4(0);
}

inline
void FillX(void *p, dword data, size_t len)
{
	dword *t = (dword *)p;
	if(len < 4) {
		if(len & 2) {
			t[0] = t[1] = t[len - 1] = data;
			return;
		}
		if(len & 1)
			t[0] = data;
		return;
	}

	if(len >= 16) {
		memsetd_l2(t, data, len);
		return;
	}

	__m128i val4 = _mm_set1_epi32(data);
	auto Set4 = [&](size_t at) { _mm_storeu_si128((__m128i *)(t + at), val4); };
	Set4(len - 4); // fill tail
	if(len & 8) {
		Set4(0); Set4(4);
		t += 8;
	}
	if(len & 4)
		Set4(0);
}

template <class T>
void memcpy_t(T *t, const T *s, size_t count)
{
	if((sizeof(T) & 15) == 0)
		memcpydq((dqword *)t, (const dqword *)s, count * (sizeof(T) >> 4));
	else
	if((sizeof(T) & 7) == 0)
		memcpyq((qword *)t, (const qword *)s, count * (sizeof(T) >> 3));
	else
	if((sizeof(T) & 3) == 0)
		memcpyd((dword *)t, (const dword *)s, count * (sizeof(T) >> 2));
	else
		svo_memcpy((void *)t, (void *)s, count * sizeof(T));
}

TIMING SSE            : 46.95 ms - 46.95 ns (58.00 ms / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000
TIMING Non SSE        : 123.95 ms - 123.95 ns (135.00 ms / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000

TIMING SSE            : 119.41 ms - 119.41 ns ( 1.06 s  / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000
TIMING Non SSE        : 232.41 ms - 232.41 ns ( 1.18 s  / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000

'_mm_storeu_si32' was not declared in this scope; did you mean '_mm_storeu_epi32'?
 (): 47 |  _mm_storeu_si32(rgba, PackRGBA(x, _mm_setzero_si128()));
 (): |  ^~~~~~~~~~~~~~~
 (): |  _mm_storeu_epi32

MSBT19x64:

TIMING SSE            : 37.08 ms - 37.08 ns (50.00 ms / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000
TIMING Non SSE        : 129.08 ms - 129.08 ns (142.00 ms / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000

MSBT19:

TIMING SSE            : 29.88 ms - 29.88 ns (45.00 ms / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000
TIMING Non SSE        : 125.88 ms - 125.88 ns (141.00 ms / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000

CLANG:

TIMING SSE            : 37.41 ms - 37.41 ns (50.00 ms / 1000000 ), min:  0.00 ns, max:  2.00 ms, nesting: 0 - 1000000
TIMING Non SSE        : 125.41 ms - 125.41 ns (138.00 ms / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000

CLANGx64:

TIMING SSE            : 37.43 ms - 37.43 ns (47.00 ms / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000
TIMING Non SSE        : 129.43 ms - 129.43 ns (139.00 ms / 1000000 ), min:  0.00 ns, max:  1.00 ms, nesting: 0 - 1000000

never_inline
uint64 memhash64(const void *ptr, int len)
{
	const byte *s = (byte *)ptr;
	uint64 val = HASH64_CONST1;
	if(len >= 8) {
		if(len >= 32) {
			uint64 val1, val2, val3, val4;
			val1 = val2 = val3 = val4 = HASH64_CONST1;
			while(len >= 32) {
				val1 = HASH64_CONST2 * val1 + *(qword *)(s);
				val2 = HASH64_CONST2 * val2 + *(qword *)(s + 8);
				val3 = HASH64_CONST2 * val3 + *(qword *)(s + 16);
				val4 = HASH64_CONST2 * val4 + *(qword *)(s + 24);
				s += 32;
				len -= 32;
			}
			val = HASH64_CONST2 * val + val1;
			val = HASH64_CONST2 * val + val2;
			val = HASH64_CONST2 * val + val3;
			val = HASH64_CONST2 * val + val4;
		}
		const byte *e = s + len - 8;
		while(s < e) {
			val = HASH64_CONST2 * val + *(qword *)(s);
			s += 8;
		}
		return HASH64_CONST2 * val + *(qword *)(e);
	}
	if(len > 4) {
		val = HASH64_CONST2 * val + *(dword *)(s);
		val = HASH64_CONST2 * val + *(dword *)(s + len - 4);
		return val;
	}
	if(len >= 2) {
		val = HASH64_CONST2 * val + *(word *)(s);
		val = HASH64_CONST2 * val + *(word *)(s + len - 2);
		return val;
	}
	return len ? HASH64_CONST2 * val + *s : val;
}

never_inline
uint64 memhash32(const void *ptr, int len)
{
	const byte *s = (byte *)ptr;
	uint64 val = HASH32_CONST1;
	if(len >= 4) {
		if(len >= 16) {
			uint64 val1, val2, val3, val4;
			val1 = val2 = val3 = val4 = HASH32_CONST1;
			while(len >= 32) {
				val1 = HASH32_CONST2 * val1 + *(dword *)(s);
				val2 = HASH32_CONST2 * val2 + *(dword *)(s + 4);
				val3 = HASH32_CONST2 * val3 + *(dword *)(s + 8);
				val4 = HASH32_CONST2 * val4 + *(dword *)(s + 12);
				s += 16;
				len -= 16;
			}
			val = HASH32_CONST2 * val + val1;
			val = HASH32_CONST2 * val + val2;
			val = HASH32_CONST2 * val + val3;
			val = HASH32_CONST2 * val + val4;
		}
		const byte *e = s + len - 4;
		while(s < e) {
			val = HASH32_CONST2 * val + *(dword *)(s);
			s += 4;
		}
		return HASH32_CONST2 * val + *(dword *)(e);
	}
	if(len >= 2) {
		val = HASH32_CONST2 * val + *(word *)(s);
		val = HASH32_CONST2 * val + *(word *)(s + len - 2);
		return val;
	}
	return len ? HASH32_CONST2 * val + *s : val;
}