Быстрое взвешенное среднее & amp; Дисперсия 10 бункеров

Я только что понял, что ваш массив данных начинается с массива int, поскольку в вашем коде не было объявлений. В версии SSE я вижу, что вы начинаете с целых чисел, а потом сохраняете их версию с плавающей запятой позже.

Сохранение целого числа позволит нам сделать цикл-счетчик-вектор простым ivec = _mm_add_epi32(ivec, _mm_set1_epi32(4)); В ответе Аки Суйхконена есть некоторые изменения, которые должны позволить ему намного лучше оптимизироваться. В частности, авто-векторизатор должен иметь возможность делать больше даже без -ffast-math, На самом деле, это довольно хорошо. Вы могли бы сделать лучше с внутренностями, особенно сохранение некоторого вектора 32-битных умножений и сокращение цепочки зависимостей.

Мой старый ответ, основанный на попытках оптимизировать ваш код, как написано, при условии ввода FP:

Вы можете объединить все 3 цикла в один, используя алгоритм @Jason связан с. Однако это может быть не выгодно, так как включает в себя разделение. Для небольшого количества бункеров, вероятно, просто зациклите несколько раз.

Начните с чтения руководств в http://agner.org/optimize/. Несколько приемов из его руководства по оптимизации сборки ускорят вашу попытку SSE (которую я отредактировал для вас в этом вопросе).

• по возможности объединяйте свои циклы, чтобы вы делали больше с данными при каждой их загрузке / хранении.

• несколько аккумуляторов, чтобы скрыть задержку циклических цепочек зависимостей. (Даже добавление FP занимает 3 цикла на последних процессорах Intel.) Это не относится к очень коротким массивам, подобным вашему.

• вместо преобразования int-> float на каждой итерации используйте счетчик цикла float, а также счетчик цикла int. (добавить вектор _mm_set1_ps(4.0f) каждая итерация.) _mm_set... с переменными args это то, чего следует избегать в циклах, когда это возможно. Требуется несколько инструкций (особенно когда каждый аргумент setr должен быть рассчитан отдельно.)

НКУ -O3 удается автоматически векторизовать первый цикл, но не остальные. С -O3 -ffast-math, это авто-векторизация больше. -ffast-math позволяет выполнять операции FP в порядке, отличном от указанного в коде. например складывая массив в 4 элемента вектора, и объединяя только 4 аккумулятора в конце.

Указание gcc, что входной указатель выровнен на 16, позволяет gcc автоматически векторизовать с гораздо меньшими накладными расходами (без скалярных циклов для невыровненных частей).

// return mean
float fpstats(float histVec[], float sum, float binSize, float binOffset, long numBins, float *variance_p)
{
numBins += 3;
numBins &= ~3;  // round up to multiple of 4.  This is just a quick hack to make the code fast and simple.
histVec = (float*)__builtin_assume_aligned(histVec, 16);

float invSum = 1.0f / float(sum);
float var = 0, fmean = 0;

for (int i = 0; i < numBins; ++i)
{
histVec[i] *= invSum;
float midPoint = (float)i*binSize + binOffset;
float f = histVec[i];
fmean += f * midPoint;
}

for (int i = 0; i < numBins; ++i)
{
float midPoint = (float)i*binSize + binOffset;
float f = histVec[i];
float diff = midPoint - fmean;
//        var += f * hwk::sqr(diff);
var += f * (diff * diff);
}
*variance_p = var;
return fmean;
}

gcc генерирует какой-то странный код для второго цикла.

        # broadcasting fmean after the 1st loop
subss   %xmm0, %xmm2    # fmean, D.2466
shufps  $0, %xmm2, %xmm2        # vect_cst_.16
.L5: ## top of 2nd loop
movdqa  %xmm3, %xmm5    # vect_vec_iv_.8, vect_vec_iv_.8
cvtdq2ps        %xmm3, %xmm3    # vect_vec_iv_.8, vect__32.9
movq    %rcx, %rsi      # D.2465, D.2467
addq    $1, %rcx        #, D.2465
mulps   %xmm1, %xmm3    # vect_cst_.11, vect__33.10
salq    $4, %rsi        #, D.2467
paddd   %xmm7, %xmm5    # vect_cst_.7, vect_vec_iv_.8
addps   %xmm2, %xmm3    # vect_cst_.16, vect_diff_39.15
mulps   %xmm3, %xmm3    # vect_diff_39.15, vect_powmult_53.17
mulps   (%rdi,%rsi), %xmm3      # MEM[base: histVec_10, index: _107, offset: 0B], vect__41.18
addps   %xmm3, %xmm4    # vect__41.18, vect_var_42.19
cmpq    %rcx, %rax      # D.2465, bnd.26
ja      .L8     #,   ### <--- This is insane.
haddps  %xmm4, %xmm4    # vect_var_42.19, tmp160
haddps  %xmm4, %xmm4    # tmp160, vect_var_42.21
.L2:
movss   %xmm4, (%rdx)   # var, *variance_p_44(D)
ret
.p2align 4,,10
.p2align 3
.L8:
movdqa  %xmm5, %xmm3    # vect_vec_iv_.8, vect_vec_iv_.8
jmp     .L5     #

Таким образом, вместо того, чтобы просто возвращаться к вершине на каждой итерации, gcc решает перейти вперед, чтобы скопировать регистр, а затем безоговорочно jmp вернуться к вершине петли. Буфер цикла uop может удалить внешние издержки этой глупости, но gcc должен был структурировать цикл так, чтобы он не копировал xmm5-> xmm3 и затем xmm3-> xmm5 каждую итерацию, потому что это глупо. Он должен иметь условный переход просто на вершину цикла.

Также обратите внимание на метод gcc, используемый для получения плавающей версии счетчика цикла: начните с целочисленного вектора 1 2 3 4, и добавить set1_epi32(4), Используйте это как вход для упакованного int-> float cvtdq2ps, На Intel HW эта инструкция выполняется на порте FP-add и имеет задержку в 3 цикла, такую ​​же, как у упакованного FP-add. gcc prob. было бы лучше просто добавить вектор set1_ps(4.0)даже при том, что это создает цепочку зависимостей с 3 циклами, переносимую циклом, вместо 1 вектора цикла int add с 3-тактным преобразованием, отбрасываемым на каждой итерации.

маленький счетчик итераций

Вы говорите, что это часто будет использоваться ровно на 10 корзин? Специализированная версия всего для 10 бинов может значительно ускорить процесс, исключая все издержки цикла и сохраняя все в регистрах.

При таком небольшом размере проблемы вы можете иметь веса FP, просто находящиеся в памяти, вместо того, чтобы каждый раз пересчитывать их с целочисленным преобразованием с плавающей запятой.

Кроме того, 10 бинов будет означать много горизонтальных операций по сравнению с количеством вертикальных операций, так как у вас есть только данные на два с половиной вектора.

Если именно 10 действительно распространено, специализируйте версию для этого. Если до 16 лет является распространенным, специализировать версию для этого. (Они могут и должны поделиться const float weights[] = { 0.0f, 1.0f, 2.0f, ...}; массив).

Возможно, вы захотите использовать встроенные функции для специализированных небольших проблемных версий, а не автоматическую векторизацию.

Наличие нулевого отступа после окончания полезных данных в вашем массиве все еще может быть хорошей идеей в ваших специализированных версиях. Тем не менее, вы можете загрузить последние 2 числа и очистить верхние 64b векторного регистра с помощью movq инструкция. (__m128i _mm_cvtsi64_si128 (__int64 a)). В ролях это __m128 и ты в порядке.