Jakie czynniki wpływają na wydajność tych operacji? Prawdopodobnie kompilatora i wersji kompilatora; ale czy system operacyjny lub Na to również wpływa marka/model procesora?

Głównie architektura procesora (i model - proszę przeczytać model, gdzie wspominam architekturę procesora w tej sekcji). Kompilator może mieć pewien wpływ, ale większość kompilatorów robi to całkiem dobrze, więc architektura procesora będzie miała większy wpływ niż kompilator.

System operacyjny nie będzie miał żadnego wpływu (poza "jeśli zmienisz system operacyjny, musisz użyć innego typu kompilatora, który zmienia to, co robi kompilator" w niektórych przypadkach - ale to prawdopodobnie mały efekt).

Czy normalny 32-bitowy system będzie używał 64-bitowych rejestrów nowoczesnych procesorów?

Które operacje będą szczególnie powolne, gdy emulowane na 32-bitach? Lub który nie będzie miał prawie żadnego spowolnienia?

Dodawanie i odejmowanie, jest gorsze, ponieważ muszą być wykonywane w sekwencji dwóch operacji, a druga operacja wymaga wykonania pierwszej - nie jest tak, jeśli kompilator produkuje tylko dwie operacje dodawania na niezależnych danych.

Mulitplikacja będzie dużo gorzej, jeśli parametry wejściowe są rzeczywiście 64-bitowe - więc 2^35 * 83 jest gorszy niż 2^31 * 2^31, na przykład. Wynika to z faktu, że procesor może produkować 32 x 32 bitów pomnożyć do wyniku 64-bitowego dość dobrze - około 5-10 cykli zegara. Ale mnożenie bitów 64 x 64 wymaga sporej ilości dodatkowego kodu, więc potrwa dłużej.

Dzielenie jest problemem podobnym do mnożenia - ale tutaj można wziąć 64-bitowe wejście z jednej strony, podzielić je przez wartość 32-bitową i uzyskać wartość 32-bitową. Ponieważ trudno przewidzieć, kiedy to zadziała, podział 64-bitowy jest prawdopodobnie prawie zawsze powolny.

Dane będą również zajmować dwa razy więcej miejsca w pamięci podręcznej, co może mieć wpływ na wyniki. I w podobnej konsekwencji, ogólne przydzielanie i przekazywanie danych będzie trwało dwa razy dłużej niż minimum, ponieważ jest dwa razy więcej danych do pracy.

Kompilator będzie również musiał użyć większej liczby rejestrów.

Czy istnieją jakieś istniejące wyniki testów porównawczych do wykorzystania int64_t/uint64_t na systemach 32-bitowych?

Prawdopodobnie, ale nie jestem tego świadoma. A nawet jeśli są, byłoby to tylko w pewnym sensie znaczące dla Ciebie, ponieważ mieszanka operacji jest bardzo krytyczna dla szybkości operacji.

Jeśli wydajność jest ważną częścią twojej aplikacji, porównuj swój kod (lub jego reprezentatywną część). Nie ma znaczenia, czy Benchmark X daje 5%, 25% czy 103% wolniejsze wyniki, Czy twój kod jest nieco wolniejszy albo szybciej w tych samych okolicznościach.

Czy ktoś ma własne doświadczenie na temat tego wpływu na wydajność?

Przekompilowałem kod, który używa 64-bitowych liczb całkowitych dla architektury 64-bitowej i stwierdziłem, że wydajność poprawia się o pewną znaczną ilość-aż o 25% na niektórych bitach kodu.

Zmiana systemu operacyjnego na 64-bitową wersję tego samego systemu, może pomoże?

Edit:

Ponieważ lubię dowiedzieć się, jaka jest różnica w tego rodzaju rzeczy, napisałem trochę kodu i z jakimś prymitywnym szablonem (wciąż ucząc się, że szablony bitowe nie są dokładnie moim najgorętszym tematem, muszę powiedzieć-Daj mi arytmetykę bitową i wskaźnikową, a (zazwyczaj) poprawię to... )

Oto kod, który napisałem, próbując odtworzyć kilka popularnych funktonów:

#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);
}

Zestawione z:

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

A wyniki są następujące: Uwaga: Patrz wyniki 2016 poniżej - wyniki te są nieco optymistyczne ze względu na różnicę w użyciu instrukcji SSE w trybie 64-bitowym, ale bez użycia SSE w trybie 32-bitowym.

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

Jak widzisz, dodawanie i mnożenie nie jest o wiele gorsze. Sekcja jest bardzo zła. Co ciekawe, dodatek matrycy nie jest w ogóle dużą różnicą.

I czy jest szybszy na 64-bitach słyszałem, że niektórzy z was pytają: Używając tych samych opcji kompilatora, po prostu -M64 zamiast - M32-yupp, dużo szybciej:

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

Edit, update for 2016: cztery warianty, z i bez SSE, w 32-i 64-bitowy tryb kompilatora.

Zazwyczaj używam clang++ jako mojego zwykłego kompilatora w dzisiejszych czasach. Próbowałem kompilować z g++ (ale nadal będzie to inna wersja niż wyżej, ponieważ zaktualizowałem swój komputer - i mam inny procesor też). Ponieważ g++ nie udało się skompilować wersji no-sse w 64-bitowej, nie widziałem w tym sensu. (g++ daje podobne wyniki i tak)

Jako krótka tabela:

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 |

Pełne wyniki z opcjami kompilacji.

$ 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