Welcome to the Lounge

theoldfool wrote:

Bad things come in 3's.

// returns whichever is greatest
int max(int x, int y) {
      return x*(x>y)+y*(x<=y);
}




      |                |
      |  OPTIMIZATION  |
      |  OPTIMIZATION  |
      |  OPTIMIZATION  |
      |  OPTIMIZATION  |
      |  OPTIMIZATION  |
      |  OPTIMIZATION  |
   ----                ----
   \                      /
    \                    /
     \                  /
      \                /
       \              /
        \            /
         \          /
          \        /
           \      /
            \    /
             \  /
              \/






// returns whichever is greatest
int max(int x, int y)
{
  if (x > y)
    return x;
  return y;
}

int max(int x, int y)
{
  int arr[2] = {y, x};
  return arr[(int)(x > y)];
}

#define _mm512_set1_epu8(c) _mm512_set1_epi32(uint32_t(c) * 0x01010101u)

size_t avx512f_strstr_v2_anysize(const char* string, size_t n, const char* needle, size_t k) {

    assert(n > 0);
    assert(k > 0);

    const __m512i first = _mm512_set1_epu8(needle[0]);
    const __m512i last  = _mm512_set1_epu8(needle[k - 1]);

    char* haystack = const_cast<char*>(string);
    char* end      = haystack + n;

    for (/**/; haystack < end; haystack += 64) {

        const __m512i block_first = _mm512_loadu_si512(haystack + 0);
        const __m512i block_last  = _mm512_loadu_si512(haystack + k - 1);

        const __m512i first_zeros = _mm512_xor_si512(block_first, first);
        // zeros = first_zeros | (block_last ^ last)
        const __m512i zeros = _mm512_ternarylogic_epi32(first_zeros, block_last, last, 0xf6);

        uint32_t mask = zero_byte_mask(zeros);
        while (mask) {

            const uint64_t p = __builtin_ctz(mask);

            if (memcmp(haystack + 4*p + 0, needle, k) == 0) {
                return (haystack - string) + 4*p + 0;
            }

            if (memcmp(haystack + 4*p + 1, needle, k) == 0) {
                return (haystack - string) + 4*p + 1;
            }

            if (memcmp(haystack + 4*p + 2, needle, k) == 0) {
                return (haystack - string) + 4*p + 2;
            }

            if (memcmp(haystack + 4*p + 3, needle, k) == 0) {
                return (haystack - string) + 4*p + 3;
            }

            mask = bits::clear_leftmost_set(mask);
        }
    }

    return size_t(-1);
}