горизонтальная сумма 8 упакованных 32-битных чисел с плавающей запятой

Быстро записал здесь (и, следовательно, непроверенный):

float sum(__m256 x) {
    __m128 hi = _mm256_extractf128_ps(x, 1);
    __m128 lo = _mm256_extractf128_ps(x, 0);
    lo = _mm_add_ps(hi, lo);
    hi = _mm_movehl_ps(hi, lo);
    lo = _mm_add_ps(hi, lo);
    hi = _mm_shuffle_ps(lo, lo, 1);
    lo = _mm_add_ss(hi, lo);
    return _mm_cvtss_f32(lo);
}

Для мин/макс замените _mm_add_ps и _mm_add_ss на _mm_max_* или _mm_min_*.

Обратите внимание, что это много работы для нескольких операций; AVX на самом деле не предназначен для эффективного выполнения горизонтальных операций. Если вы можете объединить эту работу для нескольких векторов, то возможны более эффективные решения.

Хотя ответ Стивена Кэнона, вероятно, идеален для нахождения горизонтального максимума/минимума, я думаю, что для горизонтальной суммы можно найти лучшее решение.

float horizontal_add (__m256 a) {
    __m256 t1 = _mm256_hadd_ps(a,a);
    __m256 t2 = _mm256_hadd_ps(t1,t1);
    __m128 t3 = _mm256_extractf128_ps(t2,1);
    __m128 t4 = _mm_add_ss(_mm256_castps256_ps128(t2),t3);
    return _mm_cvtss_f32(t4);        
}

Я попытался написать код, который позволяет избежать смешивания инструкций avx и не-avx, а горизонтальная сумма регистра avx, содержащего числа с плавающей запятой, может быть выполнена только avx с помощью

• 1x vperm2f128,
• 2x vshufps и
• 3x vaddps,

в результате получается регистр, в котором все записи содержат сумму всех элементов исходного регистра.

// permute
//  4, 5, 6, 7, 0, 1, 2, 3
// add
//  0+4, 1+5, 2+6, 3+7, 4+0, 5+1, 6+2, 7+3
// shuffle
//  1+5, 0+4, 3+7, 2+6, 5+1, 4+0, 7+3, 6+2
// add
//  1+5+0+4, 0+4+1+5, 3+7+2+6, 2+6+3+7, 
//  5+1+4+0, 4+0+5+1, 7+3+6+2, 6+2+7+3
// shuffle
//  3+7+2+6, 2+6+3+7, 1+5+0+4, 0+4+1+5, 
//  7+3+6+2, 6+2+7+3, 5+1+4+0, 4+0+5+1
// add
//  3+7+2+6+1+5+0+4, 2+6+3+7+0+4+1+5, 1+5+0+4+3+7+2+6, 0+4+1+5+2+6+3+7,
//  7+3+6+2+5+1+4+0, 6+2+7+3+4+0+5+1, 5+1+4+0+7+3+6+2, 4+0+5+1+6+2+7+3

static inline __m256 hsums(__m256 const& v)
{
    auto x = _mm256_permute2f128_ps(v, v, 1);
    auto y = _mm256_add_ps(v, x);
    x = _mm256_shuffle_ps(y, y, _MM_SHUFFLE(2, 3, 0, 1));
    x = _mm256_add_ps(x, y);
    y = _mm256_shuffle_ps(x, x, _MM_SHUFFLE(1, 0, 3, 2));
    return _mm256_add_ps(x, y);
}

Затем получить значение легко, используя _mm256_castps256_ps128 и _mm_cvtss_f32:

static inline float hadd(__m256 const& v)
{
    return _mm_cvtss_f32(_mm256_castps256_ps128(hsums(v)));
}

Я провел несколько базовых тестов по сравнению с другими решениями с __rdtscp и не нашел ни одного лучшего с точки зрения среднего количества циклов процессора на моем Intel i5-2500k.

Просматривая таблицы инструкций Agner, я обнаружил (для процессоров Sandy-Bridge):

                µops    lat.    1/tp    count

this:

vperm2f128      1       2       1       1
vaddps          1       3       1       3
vshufps         1       1       1       2

sum             6       13      6       6

Z boson:

vhaddps         3       5       2       2
vextractf128    1       2       1       1
addss           1       3       1       1

sum             8       15      6       4

Stephen Canon:

vextractf128    1       2       1       1
addps           1       3       1       2
movhlps         1       1       1       1
shufps          1       1       1       1
addss           1       3       1       1

sum             8       13      6       6

где для меня (из-за того, что значения довольно похожи) ни один из них явно не лучше (поскольку я не могу предвидеть, что имеет наибольшее значение: количество инструкций, количество микроопераций, задержка или пропускная способность). редактировать, примечание: потенциальная проблема, которая, как я предполагал, существует в следующем, не соответствует действительности. Я подозревал, что - если достаточно иметь результат в регистре ymm - мой hsums может быть полезен, поскольку он не t требует vzeroupper для предотвращения штрафа за переключение состояний и, таким образом, может чередоваться/выполняться одновременно с другими вычислениями avx с использованием разных регистров без введения какой-либо точки последовательности.