16바이트 정렬 해서 16바이트 단위로 처리하는거보다 2배 빨라지긴 했는데

더 좋은 방법 있으면 알려주라


        // 16바이트에 정렬된 주소, 데이터는 16바이트 배수

        BOOL gFN_MemoryCompare_Aligned_128BIT_SIMD(const void* pSource, size_t SizeSource, unsigned char code)

        {

            // SSE2 명령어 한정(2001년 이후 CPU)

            _Assert(pSource && SizeSource);

            const size_t c_SizeChunk = sizeof(__m128i);

            const size_t c_nChunk = SizeSource / c_SizeChunk;

            _Assert(SizeSource % c_SizeChunk == 0);


            const __m128i c_code = _mm_set1_epi8((char)code);

            const __m128i* p = (const __m128i*)pSource;


            // X 단위로 처리

            const size_t c_Chunk_X = 4;

            const size_t c_SizeChunk_X = c_SizeChunk * c_Chunk_X;

            const size_t c_nChunk_X = SizeSource / c_SizeChunk_X;

            if(0 < c_nChunk_X)

            {

                const __m128i* pEND_N_X = p + (c_Chunk_X*c_nChunk_X);

                do{

                    const __m128i r0 = _mm_xor_si128(p[0], c_code);

                    const __m128i r1 = _mm_xor_si128(p[1], c_code);

                    const __m128i r2 = _mm_xor_si128(p[2], c_code);

                    const __m128i r3 = _mm_xor_si128(p[3], c_code);

                    const __m128i r01 = _mm_or_si128(r0, r1);

                    const __m128i r23 = _mm_or_si128(r2, r3);

                    const __m128i r0123 = _mm_or_si128(r01, r23);

                    if(r0123.m128i_u64[0] | r0123.m128i_u64[1])

                        return FALSE;

                    p += c_Chunk_X;

                }while(p != pEND_N_X);

            }


            // 남은 부분 1개 단위 처리

            const __m128i* pEND_All = reinterpret_cast<const __m128i*>((byte*)pSource + SizeSource);

            while(p != pEND_All)

            {

                const __m128i r = _mm_xor_si128(*p, c_code);

                if(r.m128i_u64[0] | r.m128i_u64[1])

                    return FALSE;

                p++;

            }

            return TRUE;

        }