Быстрое умножение / деление на 2 для поплавков и двойников (C / C++)

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

"интуитивный" способ сделать это-просто извлечь биты в 64-разрядное целое число и добавить значение сдвига непосредственно в экспоненту. (это будет работать до тех пор, пока вы не нажмете NAN или INF)

что-то вроде этого:

union{
    uint64 i;
    double f;
};

f = 123.;
i += 0x0010000000000000ull;

//  Check for zero. And if it matters, denormals as well.

обратите внимание, что этот код не c-совместимый в любом случае, и показана только для иллюстрации идеи. Любая попытка реализовать это должна быть сделана непосредственно в сборке или встроенных компонентах SSE.

однако, в большинство случаи накладные расходы на перемещение данных из единицы FP в целочисленную единицу (и обратно) будут стоить намного больше, чем просто прямое умножение. Это особенно относится к pre-SSE era, где значение должно храниться из FPU x87 в память, а затем прочитайте обратно в целочисленные регистры.

в эпоху SSE целочисленные SSE и FP SSE используют одни и те же регистры ISA (хотя у них все еще есть отдельные файлы регистров). По Агнер Туман, существует штраф от 1 до 2 циклов для перемещения данных между целочисленными единицами выполнения SSE и FP SSE. Таким образом, стоимость намного лучше, чем в эпоху x87, но она все еще существует.

All-in-all, это будет зависеть от того, что еще у вас есть на вашем конвейере. Но в большинстве случаев умножение все равно будет быстрее. Я столкнулся с этой же проблемой раньше, поэтому я говорю из первых рук.

теперь с 256-битными инструкциями AVX, которые поддерживают только инструкции FP, еще меньше стимула играть в такие трюки.

как о ldexp?

любой мало-мальски приличный компилятор будет генерировать оптимальный код на вашей платформе.

но, как указывает @Clinton, просто написать его "очевидным" способом должно быть так же хорошо. Умножение и деление на степени двух-детская игра для современного компилятора.

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

и, конечно, вы не должны тратить время даже думать об этом вопросе, если ваш инструмент профилирования не говорит вам. Но люди, которые прислушиваются к этому совету, никогда не будут нуждаться в нем, а те, кому он нужен, никогда не будут слушать.

[обновление]

хорошо, поэтому я просто попробовал ldexp с g++ 4.5.2. The cmath заголовок inlines это как вызов __builtin_ldexp, что, в свою очередь...

...испускает вызов libm

самый быстрый способ сделать это, вероятно:

x *= (1 << p);

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

помните, что C / C++ не является языком сборки. Использование оператора bitshift не обязательно компилируется в операцию сборки bitshift, но не использует умножение обязательно компилируется в умножение. Там происходит много странных и замечательных вещей, например, какие регистры используются и какие инструкции можно запускать одновременно, которые я недостаточно умен, чтобы понять. Но ваш компилятор, обладающий многими человеческими годами знаний и опыта и большой вычислительной мощью, намного лучше делает эти суждения.

п.з. имейте в виду, если ваш парный в массиве или другой структуре данных , ваш компилятор может быть очень умным и использовать SSE для нескольких 2 или даже 4 двойников одновременно. Однако выполнение большого сдвига битов, вероятно, запутает ваш компилятор и предотвратит эту оптимизацию.

какие еще операции требует этот алгоритм? Вы можете разбить свои поплавки на пары int (знак/мантисса и величина), выполнить обработку и восстановить их в конце.

умножение на 2 может быть заменено добавлением:x *= 2 эквивалентно x += x.

деление на 2 может быть заменено умножением на 0,5. Умножение обычно происходит значительно быстрее, чем деление.

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

Е. Г. для

typedef struct {double hi; double lo;} doubledouble;
doubledouble x;
x.hi*=2, x.lo*=2; //multiply x by 2
x.hi/=2, x.lo/=2; //divide x by 2

на самом деле я перегружен << и >> на doubledouble так что это аналог числа.

//x is a doubledouble type
x << 2 // multiply x by four;
x >> 3 // divide x by eight.

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