Почему компиляторы C++ не делают лучше постоянное сворачивание?

Я был разочарован, обнаружив, что без поддержки быстрой математики ни GCC 8.2, Clang 6 или MSVC 19 не смогли сделать никаких оптимизаций на всем протяжении наивного точечного продукта с матрицей, полной 0s.

у них нет другого выбора, к сожалению. Так как IEEE плавает подписали нули, добавив 0.0 не является операцией идентификации:

-0.0 + 0.0 = 0.0 // Not -0.0!

точно так же умножение на ноль не всегда дает ноль:

0.0 * Infinity = NaN // Not 0.0!

Итак, компиляторы просто невозможно выполнить эти постоянные сгибы в точечном продукте, сохраняя соответствие IEEE float-для всего, что они знают, ваш вход может содержать подписанные нули и/или бесконечности.

вам придется использовать -ffast-math чтобы сделать эти складки, но это может иметь нежелательные последствия. Вы можете получить более мелкозернистый контроль с определенными флагами (от http://gcc.gnu.org/wiki/FloatingPointMath). согласно приведенному выше объяснению, добавление следующих двух флагов должно позволить постоянный адрес статьи: --21-->-ffinite-math-only,-fno-signed-zeros

действительно, Вы получаете ту же сборку, что и с -ffast-math таким образом:https://godbolt.org/z/vGULLA вы отказываетесь только от подписанных нулей (вероятно, не имеющих отношения к делу), NaNs и бесконечностей. Предположительно, если бы вы все еще производили их в своем коде, вы получили бы неопределенное поведение, поэтому взвесьте свои варианты.

---

а почему ваш пример не оптимизирован лучше даже с -ffast-math: то есть на Eigen. Предположительно они имеют векторизацию на своих матричных операциях,которые намного сложнее для компиляторов видеть. Простой цикл правильно оптимизирован с помощью следующих параметров:https://godbolt.org/z/OppEhY

один из способов заставить компилятор оптимизировать умножение на 0 и 1 - это вручную развернуть цикл. Для простоты давайте использовать

#include <array>
#include <cstddef>
constexpr std::size_t n = 12;
using Array = std::array<double, n>;

тогда мы можем реализовать простой dot функция с использованием выражений сгиба (или рекурсии, если они недоступны):

<utility>
template<std::size_t... is>
double dot(const Array& x, const Array& y, std::index_sequence<is...>)
{
    return ((x[is] * y[is]) + ...);
}

double dot(const Array& x, const Array& y)
{
    return dot(x, y, std::make_index_sequence<n>{});
}

теперь давайте посмотрим на вашу функцию

double test(const Array& b)
{
    const Array a{1};    // = {1, 0, ...}
    return dot(a, b);
}

С -ffast-math gcc 8.2 производит:

test(std::array<double, 12ul> const&):
  movsd xmm0, QWORD PTR [rdi]
  ret

clang 6.0.0 идет по тому же пути строки:

test(std::array<double, 12ul> const&): # @test(std::array<double, 12ul> const&)
  movsd xmm0, qword ptr [rdi] # xmm0 = mem[0],zero
  ret

например,

double test(const Array& b)
{
    const Array a{1, 1};    // = {1, 1, 0...}
    return dot(a, b);
}

мы

test(std::array<double, 12ul> const&):
  movsd xmm0, QWORD PTR [rdi]
  addsd xmm0, QWORD PTR [rdi+8]
  ret

дополнительно. лязг разворачивает a for (std::size_t i = 0; i < n; ++i) ... цикл без всех этих трюков с выражениями сгиба, gcc не делает и нуждается в некоторой помощи.