Удвоения быстрее, чем числа с плавающей запятой в C#?

Это указывает на то, что числа с плавающей запятой немного быстрее, чем удвоения: http://www.herongyang.com/cs_b/performance.html

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

Плавающие должны быть быстрее в 32-битной системе, но профилируйте код, чтобы убедиться, что вы оптимизируете правильные вещи.

Короткий ответ: «используйте ту точность, которая требуется для получения приемлемых результатов».

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

Учитывая, что JIT для .NET пытается оставить ваши операции с плавающей запятой с требуемой точностью, мы можем взглянуть на документацию Intel для ускорения наших операций. На платформе Intel ваши операции с плавающей запятой могут выполняться с промежуточной точностью 80 бит и преобразовываться с точностью до требуемой.

В руководстве Intel по операциям с плавающей запятой C++ ¹ (извините, есть только мертвое дерево) они упоминают:

• Use a single precision type (for example, float) unless the extra precision obtained through double or long double is required. Greater precision types increase memory size and bandwidth requirements. ...
• Avoid mixed data type arithmetic expressions

Этот последний пункт важен как вы можете замедлить себя с помощью ненужных бросков в / из поплавка и удвоения, что приводит к JIT-коду, который просит x87 отбрасывать его от своего 80-битного промежуточного формата между операциями!

1. Да, там написано C++, но стандарт C# плюс знание CLR позволяет нам знать, что информация для C++ должна быть применима в этом случае.

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

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

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

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

С арифметикой 387 FPU float работает быстрее, чем double для некоторых длинных итеративных операций, таких как pow, log и т. д. (И только если компилятор правильно устанавливает управляющее слово FPU).

Однако с упакованной арифметикой SSE это имеет большое значение.

Я пишу трассировщик лучей, и замена поплавков на двойные для моего класса Color дает мне ускорение на 5%. Замена векторов с плавающей запятой на двойные еще на 5% быстрее! Довольно круто :)

Это с Core i7 920

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

Это меня удивило, но, полагаю, это связано с характером моей проблемы. Я не делаю приведений между float и double в основных операциях, и мои вычисления в основном складываются, умножаются и вычитаются.

Это мой i7 920, работающий под управлением 64-битной операционной системы.

Я только что прочитал «Microsoft .NET Framework-Application Development Foundation 2nd» для экзамена MCTS 70-536, и на странице 4 (глава 1) есть примечание:

NOTE Optimizing performance with built-in types
The runtime optimizes the performance of 32-bit integer types (Int32 and UInt32), so use those types for counters and other frequently accessed integral variables. For floating-point operations, Double is the most efficient type because those operations are optimized by hardware.

Это написано Тони Нортрупом. Я не знаю, авторитет он или нет, но я ожидаю, что официальная книга для экзамена .NET должна иметь некоторый вес. Конечно, это не гарантия. Я просто подумал, что добавлю это к этому обсуждению.

Маттейс,

Ты неправ. 32-разрядная версия намного эффективнее 16-разрядной - в современных процессорах ... Возможно, не с точки зрения памяти, но с точки зрения эффективности 32-разрядная версия - лучший способ.

Вам действительно стоит обновить своего профессора до чего-то более «современного». ;)

Во всяком случае, чтобы ответить на вопрос; float и double имеют одинаковую производительность, по крайней мере, на моем Intel i7 870 (как в теории).

Вот мои измерения:

(Я создал «алгоритм», который я повторил 10 000 000 раз, а затем повторил его 300 раз, и из этого я получил среднее значение.)

double
-----------------------------
1 core  = 990 ms
4 cores = 340 ms
6 cores = 282 ms
8 cores = 250 ms

float
-----------------------------
1 core  = 992 ms
4 cores = 340 ms
6 cores = 282 ms
8 cores = 250 ms