Ralentissement en 64 bits
Bonjour,
Je viens appeler à votre aide car je constate un ralentissement assez significatif sur un même code selon que je l'exécute sur des entiers 32 bits ou 64 bits (et cela sur une machine qui est en 64 bits).
Le code est donné ci-après. Il est inspiré d'un code réel mais a été simplifié pour faciliter la lecture (quoi que…). Du coup ce qu'il calcule maintenant n'a absolument aucun intérêt :).
Le tableau array contient 30 000 000 entiers aléatoires. Le tableau range définit seulement un intervalle à parcourir dans le tableau array (toujours de la même longueur dans ce cas-là).
J'effectue un certain nombre de requêtes sur mon tableau (1 000 000) et je calcule la somme des entiers rencontrés, histoire de faire quelque chose…
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
void test() {
uint nb = 300000000;
uint nb_queries = 1000000;
ullong sum = 0;
uint *array = new uint[nb];
uint range_size = 10;
uint *range = new uint[nb/range_size+1];
srand(1);
for (uint i=0; i < nb; i++) {
array[i] = rand() % 1000;
if (i % range_size == 0) {
range[i/range_size] = i;
}
}
range[nb/range_size] = nb;
for (uint i=0; i < nb_queries; i++) {
uint start = rand() % nb;
for (uint j = range[start / range_size]+1; j < range[start / range_size + 1]; j++) {
if (array[j-1] % 25 != array[j] % 25)
sum += array[j];
}
}
} |
Le type uint est défini soit comme un u_int32_t soit comme un u_int64_t selon l'exécution que je veux lancer.
Je mesure le temps que met la boucle externe (sur la variable i) à s'exécuter en utilisant gettimeofday.
À la fin j'affiche le temps par requête (c-à-d. le temps de la boucle externe divisé par le nombre de requêtes).
Le programme est compilé avec les options -Wall -pedantic -O3
J'ai lancé 10 fois le programme, et voici les résultats en 64 bits:
Code:
1
2
3
4
5
6
7
8
9
10
11
|
0.538002 us (64-bit)
0.534345 us (64-bit)
0.534997 us (64-bit)
0.535865 us (64-bit)
0.538192 us (64-bit)
0.535768 us (64-bit)
0.542856 us (64-bit)
0.53733 us (64-bit)
0.540097 us (64-bit)
0.534318 us (64-bit) |
Soit un temps moyen de 0,537177 µs par requête.
Puis en 32 bits :
Code:
1
2
3
4
5
6
7
8
9
10
11
|
0.41998 us (32-bit)
0.420473 us (32-bit)
0.414799 us (32-bit)
0.411799 us (32-bit)
0.411982 us (32-bit)
0.415471 us (32-bit)
0.418673 us (32-bit)
0.412244 us (32-bit)
0.414136 us (32-bit)
0.416502 us (32-bit) |
Soit un temps moyen de 0,415606 µs par requête.
La version 64 bits est donc 30% plus lente que la version 32 bits. Je retire alors le
Code:
if (array[j-1] % 25 != array[j] % 25)
et je relance les expériences dans les mêmes conditions.
Code:
1
2
3
4
5
6
7
8
9
10
11
|
0.283565 us (64-bit)
0.29084 us (64-bit)
0.270837 us (64-bit)
0.263805 us (64-bit)
0.252101 us (64-bit)
0.283732 us (64-bit)
0.261196 us (64-bit)
0.274833 us (64-bit)
0.277358 us (64-bit)
0.26613 us (64-bit) |
Soit un temps moyen de 0,27244 µs par requête.
Code:
1
2
3
4
5
6
7
8
9
10
11
|
0.256369 us (32-bit)
0.251514 us (32-bit)
0.247946 us (32-bit)
0.250032 us (32-bit)
0.282004 us (32-bit)
0.273818 us (32-bit)
0.254479 us (32-bit)
0.248506 us (32-bit)
0.276108 us (32-bit)
0.258223 us (32-bit) |
Soit un temps moyen de 0,2599 µs par requête.
Maintenant le code 64 bits est environ 5% plus lent que la version 32 bits.
Comment s'explique cette différence entre les versions 32 et 64 bits ? Comment puis-je y remédier ?
Merci d'avance
