Быстрый обратный квадрат double в C / C++

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

1. вы уверены, что вам нужно double точность? Вы можете пожертвовать точностью достаточно легко:

   double d = somevalue();
   float c = 1.0f / ((float) d * (float) d);
   

   на 1.0f - это совершенно обязательное в этом случае, если вы используете 1.0 вместо этого вы получите double точности.

2. вы пробовали включить "небрежную" математику на своем компиляторе? На GCC вы можете использовать -ffast-math, есть аналогичные опции для других компиляторов. Корявость математика может быть более чем достаточно для вашего приложения. ( Edit: я не видел никакой разницы в результирующей сборке.)

3. если вы используете GCC, вы рассматривали использование -mrecip? Существует функция" взаимной оценки", которая имеет только около 12 бит точности, но она намного быстрее. Вы можете использовать метод Ньютона-Рафсона для повышения точности результат. The -mrecip опция заставит компилятор автоматически генерировать взаимную оценку и шаги Ньютона-Рафсона для вас, хотя вы всегда можете написать сборку самостоятельно, если хотите точно настроить компромисс производительности и точности. (Ньютон-Рафсон сходится!--42-->очень быстро.) ( Edit: я не смог заставить GCC генерировать RCPSS. Увидеть ниже.)

я нашел сообщение в блоге (источник) обсуждение точного проблема, которую вы проходите, и вывод автора заключается в том, что методы, такие как метод Кармака, не конкурируют с инструкцией RCPSS (которая -mrecip флаг на GCC использует).

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

трюки, которые не работают

1. метод Кармака: он устарел на современных процессорах, которые имеют опкоды взаимной оценки. Для reciprocals лучшая версия, которую я видел, дает только один бит точности - ничего по сравнению с 12 битами RCPSS. Я думаю, что это совпадение, что трюк так хорошо работает для взаимных квадратных корней; совпадение, которое вряд ли повторится.

2. перемаркировки переменная. Что касается компилятора, то между 1.0/(x*x) и double x2 = x*x; 1.0/x2. Я был бы удивлен, если бы вы нашли компилятор, который генерирует другой код для двух версий с оптимизацией, включенной даже до самого низкого уровня.

3. используя pow. The pow функция библиотеки-это монстр. С GCC -ffast-math выключен, вызов библиотеки довольно дорогой. С GCC -ffast-math включен, вы получаете то же самое код сборки для pow(x, -2) как сделать 1.0/(x*x), так что нет никакой выгоды.

обновление

вот пример приближения Ньютона-Рафсона для обратного квадрата значения с плавающей запятой двойной точности.

static double invsq(double x)
{
    double y;
    int i;
    __asm__ (
        "cvtpd2ps %1, %0\n\t"
        "rcpss %0, %0\n\t"
        "cvtps2pd %0, %0"
        : "=x"(y)
        : "x"(x));
    for (i = 0; i < RECIP_ITER; ++i)
        y *= 2 - x * y;
    return y * y;
}

к сожалению, с RECIP_ITER=1 бенчмарки на моем компьютере ставят его немного медленнее (~5%), чем простая версия 1.0/(x*x). Это быстрее (2x так же быстро) с нулевыми итерациями, но тогда вы получаете только 12 бит точность. Не знаю, хватит ли тебе 12 бит.

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

например, вы сказали, что -ffast-math вызвало нежелательную потерю точности; это может указывать на численную проблему стабильности в используемом алгоритме. При правильном выборе алгоритма многие проблемы можно решить с помощью float вместо double. (Конечно, вам может понадобиться более 24 бит. Я не знаю.)

я подозреваю RCPSS метод светит, если вы хотите вычислить несколько из них параллельно.