Update PXMemory.c

Author: BitPaw

Code/PXUltimaC/PX/OS/Memory/PXMemory.c

@@ -404,33 +404,51 @@ void PXAPI PXMemorySet(void PXREF PXRestrict buffer, const PXByte value, const P
 
 PXI8U PXAPI PXMemoryCompareI8V(const PXI8U PXREF textList, const PXI8U listAmount, const PXI8U value)
 {
-    __m512i zero = _mm512_setzero_si512();
-    //__m512i zero = _mm512_set1_epi8('~');
+    return 0;
+}
+
+PXI8U PXAPI PXMemoryCompareI8V_Strait(const PXI8U PXREF dataList, const PXI8U listAmount, const PXI8U value)
+{
+    return 0;
+}
 
+PXI8U PXAPI PXMemoryCompareI8V_MMX(const PXI8U PXREF dataList, const PXI8U listAmount, const PXI8U value)
+{
+    return 0;
+}
+
+PXI8U PXAPI PXMemoryCompareI8V_SSE2(const PXI8U PXREF dataList, const PXI8U listAmount, const PXI8U value)
+{
+    return 0;
+}
+
+PXI8U PXAPI PXMemoryCompareI8V_AVX512(const PXI8U PXREF dataList, const PXI8U listAmount, const PXI8U value)
+{
+    const __m512i zero = _mm512_setzero_si512();
     __m512i value_vector = _mm512_set1_epi8(value); // Load target byte gets copy'ed 64x 
 
     for(PXI8U i = 0; i < listAmount; i += 64)
-    { 
-        __mmask64 mask = ((listAmount -i) > 64) ? 0xFFFFFFFFFFFFFFFF : (1LL << (listAmount - (i))) -1; // How many things can we load?
-        __m512i data_vector = _mm512_mask_loadu_epi8(zero, mask, &textList[i]); // Load compare array
+    {
+        __mmask64 mask = ((listAmount - i) > 64) ? 0xFFFFFFFFFFFFFFFF : (1LL << (listAmount - (i))) - 1; // How many things can we load?
+        __m512i data_vector = _mm512_mask_loadu_epi8(zero, mask, &dataList[i]); // Load compare array
 
         const PXI64U result = _mm512_cmp_epi8_mask(value_vector, data_vector, _MM_CMPINT_EQ); // Compare both 64x byte vs byte
 
-        char bufferA[64 * 2+1];
-        char bufferB[64 * 2+1];
+#if 0
+        char bufferA[64 * 2 + 1];
+        char bufferB[64 * 2 + 1];
 
         for(size_t i = 0; i < 64; ++i)
         {
             bufferA[2 * i + 0] = value_vector.m512i_u8[i];
             bufferA[2 * i + 1] = ' ';
-            bufferA[2 * i + 2] = 0;            
+            bufferA[2 * i + 2] = 0;
 
             bufferB[2 * i + 0] = PXTextMakePrintable(data_vector.m512i_u8[i]);
             bufferB[2 * i + 1] = ' ';
             bufferB[2 * i + 2] = 0;
         }
 
-#if 0
         PXLogPrint
         (
             PXLoggingAllocation,
@@ -459,7 +477,93 @@ PXI8U PXAPI PXMemoryCompareI8V(const PXI8U PXREF textList, const PXI8U listAmoun
 #else
         const PXI8U match_index = 63 - _lzcnt_u32(result); // Count leading zeros. We want the first one.
 #endif
- 
+
+
+        return i + match_index; // Index of first hit
+    }
+
+    return (PXI8U)-1; // No match!
+}
+
+PXI8U PXAPI PXMemoryCompareI16V(const PXI16U PXREF dataList, const PXI8U listAmount, const PXI16U value)
+{
+    return 0;
+}
+
+PXI8U PXAPI PXMemoryCompareI16V_Strait(const PXI16U PXREF dataList, const PXI8U listAmount, const PXI16U value)
+{
+    return 0;
+}
+
+PXI8U PXAPI PXMemoryCompareI16V_MMX(const PXI16U PXREF dataList, const PXI8U listAmount, const PXI16U value)
+{
+    return 0;
+}
+
+PXI8U PXAPI PXMemoryCompareI16V_SSE2(const PXI16U PXREF dataList, const PXI8U listAmount, const PXI16U value)
+{
+    return 0;
+}
+
+PXI8U PXAPI PXMemoryCompareI16V_AVX512(const PXI16U PXREF dataList, const PXI8U listAmount, const PXI16U value)
+{
+    const __m512i zero = _mm512_setzero_si512();
+    __m512i value_vector = _mm512_set1_epi16(value); // Load target byte gets copy'ed 32x 
+
+    for(PXI8U i = 0; i < listAmount; i += 32)
+    {
+        // How many 16-bit elements remain?
+        PXI8U remaining = listAmount - i;
+
+        // Mask for up to 32 16-bit lanes
+        __mmask32 mask = (remaining >= 32)
+            ? 0xFFFFFFFF
+            : ((1u << remaining) - 1u);
+
+        // Masked load of 16-bit values
+        __m512i data_vector = _mm512_mask_loadu_epi16(zero, mask, &dataList[i]);
+
+        // Compare 32x 16-bit lanes
+        __mmask32 result = _mm512_cmp_epi16_mask(value_vector, data_vector, _MM_CMPINT_EQ);
+
+#if 0
+        char bufferA[64 * 2 + 1];
+        char bufferB[64 * 2 + 1];
+
+        for(size_t i = 0; i < 64; ++i)
+        {
+            bufferA[2 * i + 0] = value_vector.m512i_u8[i];
+            bufferA[2 * i + 1] = ' ';
+            bufferA[2 * i + 2] = 0;
+
+            bufferB[2 * i + 0] = PXTextMakePrintable(data_vector.m512i_u8[i]);
+            bufferB[2 * i + 1] = ' ';
+            bufferB[2 * i + 2] = 0;
+        }
+
+        PXLogPrint
+        (
+            PXLoggingAllocation,
+            PXMemoryLogPrintTitle,
+            "SIMD-Compare",
+            "64x (%i) Target: %c\n"
+            "%s\n"
+            "%s",
+            listAmount,
+            value,
+            bufferA,
+            bufferB
+        );
+#endif
+
+
+        if(!result) // Not a single match, get to next
+        {
+            continue;
+        }
+
+        // We found a match!
+        const PXI8U match_index = 63 - _lzcnt_u32(result); // Count leading zeros. We want the first one.
 
         return i + match_index; // Index of first hit
     }