Вопрос:
Какова наиболее эффективная последовательность для создания сборника из 3-х битных элементов из памяти? Если память устроена так:
MEM = R0 G0 B0 R1 G1 B1 R2 G2 B2 R3 G3 B3 ...
Мы хотим получить три регистра YMM, где:
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
Мотивация и обсуждение
Скалярный код C похож на
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;
}
Скажем, что some_parallelizable_algorithm был написан в intrinsics и был настроен на максимально возможную возможную реализацию:
template <typename T>
__m256i some_parallelizable_algorithm(__m256i R, __m256i G, __m256i B);
Таким образом, векторная реализация для T = int32_t может быть примерно такой:
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
}
Во-первых, это можно сделать, потому что есть сбор инструкций для 32-битных элементов, но для 16-битных элементов или 8-битных элементов их нет. Во-вторых, и, что более важно, вышеприведенную инструкцию по сбору следует полностью исключить по соображениям производительности. Вероятно, более эффективно использовать смежные широкие нагрузки и перетасовывать загруженные значения для получения векторов R, G и 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
}
Кажется, что для power-2 strides (2, 4,...) существуют известные методы, использующие UNKPCKL/UNKPCKH, но для доступа к stride-3 я не мог найти никаких ссылок.
Я заинтересован в решении этого для T = int32_t, T = int16_t и T = int8_t, но чтобы оставаться сосредоточенным, давайте обсуждать только первый случай.
