Является ли float медленнее, чем double? 64-битная программа работает быстрее, чем 32-битная?

Классическая архитектура x86 использует модуль с плавающей запятой (FPU) для выполнения вычислений с плавающей запятой. FPU выполняет все вычисления в своих внутренних регистрах, каждый из которых имеет 80-битную точность. Каждый раз, когда вы пытаетесь работать с float или double, переменная сначала загружается из памяти во внутренний регистр FPU. Это означает, что нет абсолютно никакой разницы в скорости реальных вычислений, так как в любом случае вычисления выполняются с полной 80-битной точностью. Единственное, что может отличаться, это скорость загрузки значения из памяти и сохранения результата обратно в память. Естественно, на 32-битной платформе загрузка/сохранение double может занять больше времени, чем float. На 64-битной платформе разницы быть не должно.

Современные архитектуры x86 поддерживают расширенные наборы инструкций (SSE/SSE2) с новыми инструкциями, которые могут выполнять те же самые вычисления с плавающей запятой без использования «старых» инструкций FPU. Однако, опять же, я не ожидал увидеть никакой разницы в скорости вычислений для float и double. А так как эти современные платформы 64-битные, то и скорость загрузки/сохранения должна быть одинаковой.

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

Изменить: (Чтобы обратиться к комментарию @MSalters) То, что я сказал выше, относится к фундаментальным арифметическим операциям. Когда дело доходит до библиотечных функций, ответ будет зависеть от нескольких деталей реализации. Если набор инструкций платформы с плавающей запятой содержит инструкцию, которая реализует функциональность данной библиотечной функции, то то, что я сказал выше, обычно применимо и к этой функции (обычно это включает такие функции, как sin, cos, sqrt). Для других функций, функциональность которых не поддерживается непосредственно в наборе инструкций FP, ситуация может оказаться существенно иной. Вполне возможно, что float версии таких функций могут быть реализованы более эффективно, чем их double версии.

На ваш первый вопрос уже был дан ответ здесь, на SO.

Ваш второй вопрос полностью зависит от «размера» данных, с которыми вы работаете. Все сводится к низкоуровневой архитектуре системы и тому, как она обрабатывает большие значения. 64-битные данные в 32-битной системе потребуют 2 тактов для доступа к 2 регистрам. Те же самые данные в 64-битной системе должны занимать только 1 цикл для доступа к 1 регистру.

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

Хотя в большинстве систем double будет иметь ту же скорость, что и float для отдельных значений, вы правы в том, что вычисление таких функций, как sqrt, sin и т. д. с одинарной точностью, должно быть намного быстрее, чем их вычисление с двойной точностью. В C99 вы можете использовать функции sqrtf, sinf и т. д., даже если ваши переменные double, и получить преимущество.

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

Из некоторых исследований и эмпирических измерений, которые я сделал на Java:

• основные арифметические операции с числами типа double и float практически идентичны на оборудовании Intel, за исключением деления;
• с другой стороны, на Cortex-A8, который используется в iPhone 4 и iPad, даже «базовая» арифметика для двойных чисел занимает примерно в два раза больше времени, чем для чисел с плавающей запятой (добавление FP регистра для числа с плавающей запятой занимает около 4 нс по сравнению с FP регистра для числа с плавающей запятой). двойной занимает около 9 нс);
• Я сделал некоторые тайминги методов в java.util.Math (тригонометрические функции и т. д.), что может представлять интерес - в принципе, некоторые из них могут работать быстрее с числами с плавающей запятой, поскольку для расчета с точностью до числа с плавающей запятой потребуется меньше терминов; с другой стороны, многие из них оказываются «не такими плохими, как вы думаете»;

Верно также и то, что могут быть особые обстоятельства, при которых, например. проблемы с пропускной способностью памяти перевешивают время «сырых» вычислений.

«Родное» внутреннее представление с плавающей запятой в x86 FPU имеет ширину 80 бит. Это отличается как от float (32 бита), так и от double (64 бита). Каждый раз, когда значение перемещается в FPU или из него, выполняется преобразование. Существует только одна инструкция FPU, которая выполняет операцию sin и работает с внутренним 80-битным представлением.

Будет ли это преобразование быстрее для float или для double, зависит от многих факторов и должно быть измерено для данного приложения.

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