Производительность 32-разрядных целых чисел в 64-битной среде (С++)

Мы начали компилировать 32- и 64-разрядные версии некоторых наших приложений. Один из парней моего проекта поощряет нас переключать все наши 32-битные целые числа на их 64-битные эквиваленты, даже если значения гарантированно будут соответствовать 32-битовому пространству. Например, у меня есть значение, которое, как гарантируется, никогда не превысит 10 000, которое я храню в неподписанном int. Его рекомендация заключается в том, чтобы переключить это на size_t, чтобы он расширялся до 64 бит в 64-битной среде, хотя нам больше не понадобится дополнительное пространство. Он говорит, что использование 64-битных переменных ускорит приложение независимо от значений, хранящихся в каждой переменной. Он прав? Это, оказывается, много работы, и я не хочу прикладывать усилия, если это на самом деле не имеет значения.

Мы используем Microsoft Visual С++ 2008. Тем не менее, я надеюсь на более общий, независимый от платформы ответ.

И что ты думаешь? Правильно ли мы тратить время на изменение наших типов данных по причинам производительности, а не на дальность?

Ответ 1

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

В противном случае вы потратите много времени на устранение проблем.

Ответ 2

Хорошо, если 32-разрядные операции происходят в 64-битных регистрах, некоторые дополнительные инструкции должны быть испущены для обработки таких вещей, как установка флагов переноса/переполнения и т.д. Я был бы удивлен, если бы вы осознали какую-либо заметную производительность улучшение. Я могу все, но гарантировать, что в вашей программе есть намного худшие узлы.

Ответ 3

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

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

Ответ 4

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

Ответ 5

Идея о том, что использование 64-битного целого по сравнению с 32-битным целым будет ускорять работу, - это миф. Более важная вещь в вашем коде - использовать соответствующие типы. Например, при обращении к размеру массива или структуры данных используйте size_t, потому что предполагается, что должен представлять объект size_t. Если вы храните какую-то часть данных, используйте int, а не size_t, потому что это описание int.

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

Ответ 6

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

Как JaredPar говорит, если нет фактической причины для этого или если вам не нужен расширенный диапазон более крупных ints, это, вероятно, пустая трата времени.