A questão:

Qual é a sequência mais eficiente para gerar uma reunião de 3 passos de elementos de 32 bits da memória? Se a memória estiver organizada como:

MEM = R0 G0 B0 R1 G1 B1 R2 G2 B2 R3 G3 B3 ...

Queremos obter três registros YMM onde:

YMM0 = R0 R1 R2 R3 R4 R5 R6 R7
YMM1 = G0 G1 G2 G3 G4 G5 G6 G7
YMM2 = B0 B1 B2 B3 B4 B5 B6 B7

Motivação e discussão

O código escalar C é algo como

template <typename T>
T Process(const T* Input) {
  T Result = 0;
  for (int i=0; i < 4096; ++i) {
    T R = Input[3*i];
    T G = Input[3*i+1];
    T B = Input[3*i+2];
    Result += some_parallelizable_algorithm<T>(R, G, B);  
  }
  return Result;
}

Digamos quesome_parallelizable_algorithm foi escrito em intrínsecas e foi ajustado para a implementação mais rápida possível:

template <typename T>
__m256i some_parallelizable_algorithm(__m256i R, __m256i G, __m256i B);

Portanto, a implementação do vetor para T = int32_t pode ser algo como:

    template <>
    int32_t Process<int32_t>(const int32_t* Input) {
     __m256i Step = _mm256_set_epi32(0, 1, 2, 3, 4, 5, 6, 7);
     __m256i Result = _mm256_setzero_si256(); 
     for (int i=0; i < 4096; i+=8) {
       // R = R0 R1 R2 R3 R4 R5 R6 R7
       __m256i R = _mm256_i32gather_epi32 (Input+3*i, Step, 3);
       // G = G0 G1 G2 G3 G4 G5 G6 G7
       __m256i G = _mm256_i32gather_epi32 (Input+3*i+1, Step, 3);
       // B = B0 B1 B2 B3 B4 B5 B6 B7
       __m256i B = _mm256_i32gather_epi32 (Input+3*i+2, Step, 3);
       Result = _mm256_add_epi32 (Result, 
                                  some_parallelizable_algorithm<int32_t>(R, G, B));
     }
   // Here should be the less interesting part:
   // Perform a reduction on Result and return the result
}

Primeiro, isso pode ser feito porque há instruções de reunir elementos de 32 bits, mas não existem elementos de 16 bits ou elementos de 8 bits. Segundo, e mais importante, a instrução de coleta acima deve ser totalmente evitada por razões de desempenho. Provavelmente é mais eficiente usar grandes cargas contíguas e embaralhar os valores carregados para obter os vetores R, G e B.

    template <>
    int32_t Process<int32_t>(const int32_t* Input) {
     __m256i Result = _mm256_setzero_si256(); 
     for (int i=0; i < 4096; i+=3) {
       __m256i Ld0 = _mm256_lddqu_si256((__m256i*)Input+3*i));
       __m256i Ld1 = _mm256_lddqu_si256((__m256i*)Input+3*i+1));
       __m256i Ld2 = _mm256_lddqu_si256((__m256i*)Input+3*i+2));
       __m256i R = ???
       __m256i G = ???
       __m256i B = ???
       Result = _mm256_add_epi32 (Result, 
                                  some_parallelizable_algorithm<int32_t>(R, G, B));
     }
   // Here should be the less interesting part:
   // Perform a reduction on Result and return the result
}

Parece que, para as passadas power-2 (2, 4, ...), existem métodos conhecidos usando UNKPCKL / UNKPCKH, mas para acessos stride-3, não encontrei nenhuma referência.

Estou interessado em resolver isso para T = int32_t, T = int16_t e T = int8_t, mas, para manter o foco, vamos discutir apenas o primeiro caso.