ho un'applicazione in cui parte del ciclo interno era fondamentalmente:differenza di velocità tra l'utilizzo int e unsigned int miscelato con doppie
double sum = 0;
for (int i = 0; i != N; ++i, ++data, ++x) sum += *data * x;
Se x è un int senza segno quindi il codice ha 3 volte più lungo come con int!
Questo faceva parte di un più ampio codice di base, ma ho avuto verso il basso per l'essenziale:
#include <iostream>
#include <cstdlib>
#include <vector>
#include <time.h>
typedef unsigned char uint8;
template<typename T>
double moments(const uint8* data, int N, T wrap) {
T pos = 0;
double sum = 0.;
for (int i = 0; i != N; ++i, ++data) {
sum += *data * pos;
++pos;
if (pos == wrap) pos = 0;
}
return sum;
}
template<typename T>
const char* name() { return "unknown"; }
template<>
const char* name<int>() { return "int"; }
template<>
const char* name<unsigned int>() { return "unsigned int"; }
const int Nr_Samples = 10 * 1000;
template<typename T>
void measure(const std::vector<uint8>& data) {
const uint8* dataptr = &data[0];
double moments_results[Nr_Samples];
time_t start, end;
time(&start);
for (int i = 0; i != Nr_Samples; ++i) {
moments_results[i] = moments<T>(dataptr, data.size(), 128);
}
time(&end);
double avg = 0.0;
for (int i = 0; i != Nr_Samples; ++i) avg += moments_results[i];
avg /= Nr_Samples;
std::cout << "With " << name<T>() << ": " << avg << " in " << (end - start) << "secs" << std::endl;
}
int main() {
std::vector<uint8> data(128*1024);
for (int i = 0; i != data.size(); ++i) data[i] = std::rand();
measure<int>(data);
measure<unsigned int>(data);
measure<int>(data);
return 0;
}
compilazione con nessuna ottimizzazione:
[email protected]:/home/luispedro/tmp/so §g++ test.cpp
[email protected]:/home/luispedro/tmp/so §./a.out
With int: 1.06353e+09 in 9secs
With unsigned int: 1.06353e+09 in 14secs
With int: 1.06353e+09 in 9secs
Con ottimizzazione:
[email protected]:/home/luispedro/tmp/so §g++ -O3 test.cpp
[email protected]:/home/luispedro/tmp/so §./a.out
With int: 1.06353e+09 in 3secs
With unsigned int: 1.06353e+09 in 12secs
With int: 1.06353e+09 in 4secs
Non capisco perché una così grande differenza di velocità. Ho provato a capirlo dall'assemblaggio generato, ma non ho ottenuto nulla. Qualcuno ha qualche pensiero?
È qualcosa a che fare con l'hardware o è una limitazione dei macchinari di ottimizzazione di gcc? Scommetto il secondo.
La mia macchina è un Intel 32 bit con Ubuntu 9.10.
Modifica: Da quando Stephen ha chiesto, ecco la sorgente deselezionata (da una compilazione -O3). Credo che ho ottenuto le principali loop:
versione int:
40: 0f b6 14 0b movzbl (%ebx,%ecx,1),%edx
sum += *data * pos;
44: 0f b6 d2 movzbl %dl,%edx
47: 0f af d0 imul %eax,%edx
++pos;
4a: 83 c0 01 add $0x1,%eax
sum += *data * pos;
4d: 89 95 54 c7 fe ff mov %edx,-0x138ac(%ebp)
++pos;
if (pos == wrap) pos = 0;
53: 31 d2 xor %edx,%edx
55: 3d 80 00 00 00 cmp $0x80,%eax
5a: 0f 94 c2 sete %dl
T pos = 0;
double sum = 0.;
for (int i = 0; i != N; ++i, ++data) {
5d: 83 c1 01 add $0x1,%ecx
sum += *data * pos;
60: db 85 54 c7 fe ff fildl -0x138ac(%ebp)
++pos;
if (pos == wrap) pos = 0;
66: 83 ea 01 sub $0x1,%edx
69: 21 d0 and %edx,%eax
T pos = 0;
double sum = 0.;
for (int i = 0; i != N; ++i, ++data) {
6b: 39 f1 cmp %esi,%ecx
sum += *data * pos;
6d: de c1 faddp %st,%st(1)
T pos = 0;
double sum = 0.;
for (int i = 0; i != N; ++i, ++data) {
6f: 75 cf jne 40
versione non firmata:
50: 0f b6 34 13 movzbl (%ebx,%edx,1),%esi
sum += *data * pos;
54: 81 e6 ff 00 00 00 and $0xff,%esi
5a: 31 ff xor %edi,%edi
5c: 0f af f0 imul %eax,%esi
++pos;
5f: 83 c0 01 add $0x1,%eax
if (pos == wrap) pos = 0;
62: 3d 80 00 00 00 cmp $0x80,%eax
67: 0f 94 c1 sete %cl
T pos = 0;
double sum = 0.;
for (int i = 0; i != N; ++i, ++data) {
6a: 83 c2 01 add $0x1,%edx
sum += *data * pos;
6d: 89 bd 54 c7 fe ff mov %edi,-0x138ac(%ebp)
73: 89 b5 50 c7 fe ff mov %esi,-0x138b0(%ebp)
++pos;
if (pos == wrap) pos = 0;
79: 89 ce mov %ecx,%esi
7b: 81 e6 ff 00 00 00 and $0xff,%esi
sum += *data * pos;
81: df ad 50 c7 fe ff fildll -0x138b0(%ebp)
++pos;
if (pos == wrap) pos = 0;
87: 83 ee 01 sub $0x1,%esi
8a: 21 f0 and %esi,%eax
for (int i = 0; i != N; ++i, ++data) {
8c: 3b 95 34 c7 fe ff cmp -0x138cc(%ebp),%edx
sum += *data * pos;
92: de c1 faddp %st,%st(1)
for (int i = 0; i != N; ++i, ++data) {
94: 75 ba jne 50
Questa è la versione -O3, motivo per cui le linee di sorgente saltare su e giù. Grazie.
È piuttosto strano. Quanti test di temporizzazione hai eseguito? In genere, se trovo un multiplo 3x, devo interrogare se ci sono stati processi in background che si verificano contemporaneamente. Hai eseguito 10 test di questo tipo? – wheaties
Per interesse personale mi piacerebbe vedere l'assembly generato da quel codice, ma la mia ipotesi (totalmente non supportata dal fatto, semplicemente un sentimento istintivo) è che Intel probabilmente ottimizza le conversioni in virgola mobile su interi con segno perché i float sono firmati e un la conversione in un numero intero senza segno richiede un ulteriore marshalling dei dati. – Beanz
Se pubblichi lo smontaggio per il ciclo senza segno, scriverò una descrizione dettagliata di dove esattamente i tuoi cicli stanno andando =) –