Как влияет на производительность использование int64_t вместо int32_t в 32-битных системах?

Какие факторы влияют на выполнение этих операций? Вероятно,
версия компилятора и компилятора; но операционная система или
Изготовитель / модель процессора также влияют на это?

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

Операционная система не будет иметь никакого влияния (кроме «если вы меняете ОС, вам нужно использовать компилятор другого типа, который изменяет то, что делает компилятор» в некоторых случаях — но это, вероятно, небольшой эффект).

Будет ли обычная 32-разрядная система использовать 64-разрядные регистры современных процессоров?

Это невозможно. Если система находится в 32-битном режиме, она будет действовать как 32-битная система, дополнительные 32-битные регистры полностью невидимы, как если бы система была «истинной 32-битной системой». ,

какие операции будут особенно медленными при эмуляции на 32-битной версии? Или что почти не замедлится?

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

Мультипликация станет намного хуже, если входные параметры на самом деле будут 64-битными, поэтому, например, 2 ^ 35 * 83 хуже, чем 2 ^ 31 * 2 ^ 31. Это связано с тем фактом, что процессор может довольно хорошо производить умножение 32 x 32 бита на 64-битный результат — около 5-10 тактов. Но умножение на 64 x 64 бита требует значительного дополнительного кода, поэтому займет больше времени.

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

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

Компилятору также нужно будет использовать больше регистров.

Существуют ли какие-либо результаты тестов для использования int64_t / uint64_t в 32-битных системах?

Возможно, но я не знаю ни о чем. И даже если они есть, это будет для вас только несколько значимым, поскольку сочетание операций ОЧЕНЬ критично для скорости операций.

Если производительность является важной частью вашего приложения, тогда сравните ВАШ код (или некоторую его часть). На самом деле не имеет значения, дает ли Benchmark X результаты на 5%, 25% или 103% медленнее, если ваш код несколько отличается по объему медленнее или быстрее при тех же обстоятельствах.

У кого-нибудь есть собственный опыт об этом влиянии на производительность?

Я перекомпилировал некоторый код, который использует 64-разрядные целые числа для 64-разрядной архитектуры, и обнаружил, что производительность значительно возросла — до 25% для некоторых битов кода.

Может быть, поможет переход с вашей ОС на 64-битную версию той же самой ОС?

Редактировать:

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

Вот код, который я написал, пытаясь воспроизвести несколько общих функций:

#include <iostream>
#include <cstdint>
#include <ctime>

using namespace std;

static __inline__ uint64_t rdtsc(void)
{
unsigned hi, lo;
__asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
return ( (uint64_t)lo)|( ((uint64_t)hi)<<32 );
}

template<typename T>
static T add_numbers(const T *v, const int size)
{
T sum = 0;
for(int i = 0; i < size; i++)
sum += v[i];
return sum;
}template<typename T, const int size>
static T add_matrix(const T v[size][size])
{
T sum[size] = {};
for(int i = 0; i < size; i++)
{
for(int j = 0; j < size; j++)
sum[i] += v[i][j];
}
T tsum=0;
for(int i = 0; i < size; i++)
tsum += sum[i];
return tsum;
}template<typename T>
static T add_mul_numbers(const T *v, const T mul, const int size)
{
T sum = 0;
for(int i = 0; i < size; i++)
sum += v[i] * mul;
return sum;
}

template<typename T>
static T add_div_numbers(const T *v, const T mul, const int size)
{
T sum = 0;
for(int i = 0; i < size; i++)
sum += v[i] / mul;
return sum;
}template<typename T>
void fill_array(T *v, const int size)
{
for(int i = 0; i < size; i++)
v[i] = i;
}

template<typename T, const int size>
void fill_array(T v[size][size])
{
for(int i = 0; i < size; i++)
for(int j = 0; j < size; j++)
v[i][j] = i + size * j;
}uint32_t bench_add_numbers(const uint32_t v[], const int size)
{
uint32_t res = add_numbers(v, size);
return res;
}

uint64_t bench_add_numbers(const uint64_t v[], const int size)
{
uint64_t res = add_numbers(v, size);
return res;
}

uint32_t bench_add_mul_numbers(const uint32_t v[], const int size)
{
const uint32_t c = 7;
uint32_t res = add_mul_numbers(v, c, size);
return res;
}

uint64_t bench_add_mul_numbers(const uint64_t v[], const int size)
{
const uint64_t c = 7;
uint64_t res = add_mul_numbers(v, c, size);
return res;
}

uint32_t bench_add_div_numbers(const uint32_t v[], const int size)
{
const uint32_t c = 7;
uint32_t res = add_div_numbers(v, c, size);
return res;
}

uint64_t bench_add_div_numbers(const uint64_t v[], const int size)
{
const uint64_t c = 7;
uint64_t res = add_div_numbers(v, c, size);
return res;
}template<const int size>
uint32_t bench_matrix(const uint32_t v[size][size])
{
uint32_t res = add_matrix(v);
return res;
}
template<const int size>
uint64_t bench_matrix(const uint64_t v[size][size])
{
uint64_t res = add_matrix(v);
return res;
}template<typename T>
void runbench(T (*func)(const T *v, const int size), const char *name, T *v, const int size)
{
fill_array(v, size);

uint64_t long t = rdtsc();
T res = func(v, size);
t = rdtsc() - t;
cout << "result = " << res << endl;
cout << name << " time in clocks " << dec << t  << endl;
}

template<typename T, const int size>
void runbench2(T (*func)(const T v[size][size]), const char *name, T v[size][size])
{
fill_array(v);

uint64_t long t = rdtsc();
T res = func(v);
t = rdtsc() - t;
cout << "result = " << res << endl;
cout << name << " time in clocks " << dec << t  << endl;
}int main()
{
// spin up CPU to full speed...
time_t t = time(NULL);
while(t == time(NULL)) ;

const int vsize=10000;

uint32_t v32[vsize];
uint64_t v64[vsize];

uint32_t m32[100][100];
uint64_t m64[100][100];runbench(bench_add_numbers, "Add 32", v32, vsize);
runbench(bench_add_numbers, "Add 64", v64, vsize);

runbench(bench_add_mul_numbers, "Add Mul 32", v32, vsize);
runbench(bench_add_mul_numbers, "Add Mul 64", v64, vsize);

runbench(bench_add_div_numbers, "Add Div 32", v32, vsize);
runbench(bench_add_div_numbers, "Add Div 64", v64, vsize);

runbench2(bench_matrix, "Matrix 32", m32);
runbench2(bench_matrix, "Matrix 64", m64);
}

Составлено с:

g++ -Wall -m32 -O3 -o 32vs64 32vs64.cpp -std=c++0x

И результаты: Примечание: результаты 2016 года ниже — Эти результаты немного оптимистичны из-за разницы в использовании инструкций SSE в 64-битном режиме, но не в использовании SSE в 32-битном режиме.

result = 49995000
Add 32 time in clocks 20784
result = 49995000
Add 64 time in clocks 30358
result = 349965000
Add Mul 32 time in clocks 30182
result = 349965000
Add Mul 64 time in clocks 79081
result = 7137858
Add Div 32 time in clocks 60167
result = 7137858
Add Div 64 time in clocks 457116
result = 49995000
Matrix 32 time in clocks 22831
result = 49995000
Matrix 64 time in clocks 23823

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

И это быстрее на 64-битной, я слышал, некоторые из вас спрашивают:
Используя те же параметры компилятора, просто -m64 вместо -m32 — yupp, намного быстрее:

result = 49995000
Add 32 time in clocks 8366
result = 49995000
Add 64 time in clocks 16188
result = 349965000
Add Mul 32 time in clocks 15943
result = 349965000
Add Mul 64 time in clocks 35828
result = 7137858
Add Div 32 time in clocks 50176
result = 7137858
Add Div 64 time in clocks 50472
result = 49995000
Matrix 32 time in clocks 12294
result = 49995000
Matrix 64 time in clocks 14733

Редактирование, обновление на 2016 год:
четыре варианта, с SSE и без, в 32- и 64-битном режиме компилятора.

Я обычно использую clang ++ в качестве моего обычного компилятора в эти дни. Я попытался скомпилировать с помощью g ++ (но это все равно будет версия, отличная от описанной выше, поскольку я обновил свой компьютер — и у меня тоже другой процессор). Так как g ++ не смог скомпилировать версию no-sse в 64-битной версии, я не видел в этом смысла. (g ++ в любом случае дает похожие результаты)

В качестве короткого стола:

Test name      | no-sse 32 | no-sse 64 | sse 32 | sse 64 |
----------------------------------------------------------
Add uint32_t   |   20837   |   10221   |   3701 |   3017 |
----------------------------------------------------------
Add uint64_t   |   18633   |   11270   |   9328 |   9180 |
----------------------------------------------------------
Add Mul 32     |   26785   |   18342   |  11510 |  11562 |
----------------------------------------------------------
Add Mul 64     |   44701   |   17693   |  29213 |  16159 |
----------------------------------------------------------
Add Div 32     |   44570   |   47695   |  17713 |  17523 |
----------------------------------------------------------
Add Div 64     |  405258   |   52875   | 405150 |  47043 |
----------------------------------------------------------
Matrix 32      |   41470   |   15811   |  21542 |   8622 |
----------------------------------------------------------
Matrix 64      |   22184   |   15168   |  13757 |  12448 |

Полные результаты с опциями компиляции.

$ clang++ -m32 -mno-sse 32vs64.cpp --std=c++11 -O2
$ ./a.out
result = 49995000
Add 32 time in clocks 20837
result = 49995000
Add 64 time in clocks 18633
result = 349965000
Add Mul 32 time in clocks 26785
result = 349965000
Add Mul 64 time in clocks 44701
result = 7137858
Add Div 32 time in clocks 44570
result = 7137858
Add Div 64 time in clocks 405258
result = 49995000
Matrix 32 time in clocks 41470
result = 49995000
Matrix 64 time in clocks 22184

$ clang++ -m32 -msse 32vs64.cpp --std=c++11 -O2
$ ./a.out
result = 49995000
Add 32 time in clocks 3701
result = 49995000
Add 64 time in clocks 9328
result = 349965000
Add Mul 32 time in clocks 11510
result = 349965000
Add Mul 64 time in clocks 29213
result = 7137858
Add Div 32 time in clocks 17713
result = 7137858
Add Div 64 time in clocks 405150
result = 49995000
Matrix 32 time in clocks 21542
result = 49995000
Matrix 64 time in clocks 13757$ clang++ -m64 -msse 32vs64.cpp --std=c++11 -O2
$ ./a.out
result = 49995000
Add 32 time in clocks 3017
result = 49995000
Add 64 time in clocks 9180
result = 349965000
Add Mul 32 time in clocks 11562
result = 349965000
Add Mul 64 time in clocks 16159
result = 7137858
Add Div 32 time in clocks 17523
result = 7137858
Add Div 64 time in clocks 47043
result = 49995000
Matrix 32 time in clocks 8622
result = 49995000
Matrix 64 time in clocks 12448$ clang++ -m64 -mno-sse 32vs64.cpp --std=c++11 -O2
$ ./a.out
result = 49995000
Add 32 time in clocks 10221
result = 49995000
Add 64 time in clocks 11270
result = 349965000
Add Mul 32 time in clocks 18342
result = 349965000
Add Mul 64 time in clocks 17693
result = 7137858
Add Div 32 time in clocks 47695
result = 7137858
Add Div 64 time in clocks 52875
result = 49995000
Matrix 32 time in clocks 15811
result = 49995000
Matrix 64 time in clocks 15168

  C 7 6 5 4 3 2 1 0      C 7 6 5 4 3 2 1 0
0 1 1 1 1 1 1 1 1      1 0 0 0 0 0 0 0 0
+   0 0 0 0 0 0 0 1    -   0 0 0 0 0 0 0 1
= 1 0 0 0 0 0 0 0 0    = 0 1 1 1 1 1 1 1 1