Discussion :

[Goten]

Bas écoute j'ai pourtant bien générer la solution release. Après pour la STL normalement ça link avec une version release non? J'ai MSVC installé, je me demande encore pourquoi.. x)

Sinon voilà mes résultats sous mingw (gcc 3.4.5):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
 
test                            description   absolute   operations   ratio with
number                                        time       per second   test0
 
 0                 "double pointer verify2"   3.72 sec   806.67 M     1.00
 1                 "double vector iterator"   3.56 sec   842.22 M     0.96
 2                 "double pointer reverse"   3.59 sec   834.72 M     0.97
 3         "double vector reverse_iterator"   8.03 sec   373.55 M     2.16
 4         "double vector iterator reverse"   8.05 sec   372.81 M     2.16
 5         "double pointer reverse reverse"   3.63 sec   827.59 M     0.97
 6 "double vector reverse_iterator reverse"   7.44 sec   403.39 M     2.00
 7 "double vector iterator reverse reverse"   7.45 sec   402.47 M     2.00
 
Total absolute time for Vector accumulate: 45.47 sec
 
Vector accumulate Penalty: 1.50
 
 
test                                           description   absolute   operations   ratio
 with
number                                                       time       per second   test0
 
 
 0                 "insertion_sort double pointer verify2"   1.95 sec    1.54 M     1.00
 1                 "insertion_sort double vector iterator"   1.97 sec    1.52 M     1.01
 2                 "insertion_sort double pointer reverse"   3.00 sec    1.00 M     1.54
 3         "insertion_sort double vector reverse_iterator"   2.56 sec    1.17 M     1.31
 4         "insertion_sort double vector iterator reverse"   2.56 sec    1.17 M     1.31
 5         "insertion_sort double pointer reverse reverse"   3.09 sec    0.97 M     1.58
 6 "insertion_sort double vector reverse_iterator reverse"   2.84 sec    1.05 M     1.46
 7 "insertion_sort double vector iterator reverse reverse"   2.83 sec    1.06 M     1.45
 
Total absolute time for Vector Insertion Sort: 20.81 sec
 
Vector Insertion Sort Penalty: 1.37
 
 
test                                      description   absolute   operations   ratio with
 
number                                                  time       per second   test0
 
 0                 "quicksort double pointer verify2"   2.33 sec   10.31 M     1.00
 1                 "quicksort double vector iterator"   2.84 sec    8.44 M     1.22
 2                 "quicksort double pointer reverse"   2.69 sec    8.93 M     1.15
 3         "quicksort double vector reverse_iterator"   2.69 sec    8.93 M     1.15
 4         "quicksort double vector iterator reverse"   2.69 sec    8.93 M     1.15
 5         "quicksort double pointer reverse reverse"   2.89 sec    8.30 M     1.24
 6 "quicksort double vector reverse_iterator reverse"   2.88 sec    8.35 M     1.23
 7 "quicksort double vector iterator reverse reverse"   2.84 sec    8.44 M     1.22
 
Total absolute time for Vector Quicksort: 21.84 sec
 
Vector Quicksort Penalty: 1.20
 
 
test                                      description   absolute   operations   ratio with
 
number                                                  time       per second   test0
 
 0                 "heap_sort double pointer verify2"   2.23 sec   10.74 M     1.00
 1                 "heap_sort double vector iterator"   2.22 sec   10.82 M     0.99
 2                 "heap_sort double pointer reverse"   3.11 sec    7.72 M     1.39
 3         "heap_sort double vector reverse_iterator"   3.27 sec    7.35 M     1.46
 4         "heap_sort double vector iterator reverse"   3.27 sec    7.35 M     1.46
 5         "heap_sort double pointer reverse reverse"   2.52 sec    9.54 M     1.13
 6 "heap_sort double vector reverse_iterator reverse"   2.75 sec    8.73 M     1.23
 7 "heap_sort double vector iterator reverse reverse"   2.67 sec    8.98 M     1.20
 
Total absolute time for Vector Heap Sort: 22.03 sec
 
Vector Heap Sort Penalty: 1.25

Voilà enfin des résultats cohérents. Sachant que c'est obtenu avec le nombre d'itérations par défaut soit 10 fois plus que ce que j'ai utilisé sous VS, ça confirme bien que y'a un problème avec ma compilation sous VS.

Demain je ferais sur gcc 4.4.x sous nux.

[Invité]

Tes résultats sous mingw sont les mêmes que les miens.

Pour Visual, je me souviens d'un problème rencontré par un collègue, qui avait essayé de remplacer la version STL livrée avec son compilateur par une autre, et avait constaté ce genre de ralentissement. Faudrait que je lui demande...

Francois

[Arzar]

Quelle version de gcc? Faudra que je teste avec la 4.4
Btw j'ai testé avec visual studio 2008 j'obtiens des résultats assez bizarre rien que pour l'accumulate sur un simple iterator :
pointer : 3,58 secondes
iterator : 40 secondes ...

_HAS_ITERATOR_DEBUGGING=0 et _SECURE_SCL=0
Sinon, dans un bench qui teste en profondeur la différence pointeur/itérateur ça fait des dégâts....

[Goten]

Ah bas oui de suite... Enfin dans ma tête ce genre de chose (de ce que j'ai lu ça check que les itérateurs soient pas hors limite du container) en release ça devrait être passez automatiquement à zéro non?

Voilà donc les résultats sous VS2008 fchartron :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
c:\Documents and Settings\Goten\Mes documents\Visual Studio 2008\Projects\bench\
Release\bench.exe
 
test                            description   absolute   operations   ratio with
number                                        time       per second   test0
 
 0                 "double pointer verify2"   3.52 sec   853.24 M     1.00
 1                 "double vector iterator"   3.56 sec   842.22 M     1.01
 2                 "double pointer reverse"   3.56 sec   841.99 M     1.01
 3         "double vector reverse_iterator"   3.59 sec   834.96 M     1.02
 4         "double vector iterator reverse"   3.56 sec   841.99 M     1.01
 5         "double pointer reverse reverse"   3.58 sec   838.46 M     1.02
 6 "double vector reverse_iterator reverse"   3.56 sec   841.99 M     1.01
 7 "double vector iterator reverse reverse"   3.53 sec   849.62 M     1.00
 
Total absolute time for Vector accumulate: 28.47 sec
 
Vector accumulate Penalty: 1.01
 
 
test                                           description   absolute   operations   ratio
 with
number                                                       time       per second   test0
 
 
 0                 "insertion_sort double pointer verify2"   1.94 sec    1.55 M     1.00
 1                 "insertion_sort double vector iterator"   1.91 sec    1.57 M     0.98
 2                 "insertion_sort double pointer reverse"   1.86 sec    1.61 M     0.96
 3         "insertion_sort double vector reverse_iterator"   1.86 sec    1.61 M     0.96
 4         "insertion_sort double vector iterator reverse"   1.91 sec    1.57 M     0.98
 5         "insertion_sort double pointer reverse reverse"   1.91 sec    1.57 M     0.98
 6 "insertion_sort double vector reverse_iterator reverse"   1.89 sec    1.59 M     0.98
 7 "insertion_sort double vector iterator reverse reverse"   1.91 sec    1.57 M     0.98
 
Total absolute time for Vector Insertion Sort: 15.17 sec
 
Vector Insertion Sort Penalty: 0.98
 
 
test                                      description   absolute   operations   ratio with
 
number                                                  time       per second   test0
 
 0                 "quicksort double pointer verify2"   2.08 sec   11.55 M     1.00
 1                 "quicksort double vector iterator"   2.16 sec   11.13 M     1.04
 2                 "quicksort double pointer reverse"   2.16 sec   11.13 M     1.04
 3         "quicksort double vector reverse_iterator"   2.16 sec   11.13 M     1.04
 4         "quicksort double vector iterator reverse"   2.14 sec   11.21 M     1.03
 5         "quicksort double pointer reverse reverse"   2.14 sec   11.21 M     1.03
 6 "quicksort double vector reverse_iterator reverse"   2.16 sec   11.13 M     1.04
 7 "quicksort double vector iterator reverse reverse"   2.14 sec   11.21 M     1.03
 
Total absolute time for Vector Quicksort: 17.13 sec
 
Vector Quicksort Penalty: 1.03
 
 
test                                      description   absolute   operations   ratio with
 
number                                                  time       per second   test0
 
 0                 "heap_sort double pointer verify2"   1.97 sec   12.20 M     1.00
 1                 "heap_sort double vector iterator"   2.13 sec   11.29 M     1.08
 2                 "heap_sort double pointer reverse"   2.61 sec    9.20 M     1.33
 3         "heap_sort double vector reverse_iterator"   2.77 sec    8.68 M     1.40
 4         "heap_sort double vector iterator reverse"   2.75 sec    8.73 M     1.40
 5         "heap_sort double pointer reverse reverse"   2.13 sec   11.29 M     1.08
 6 "heap_sort double vector reverse_iterator reverse"   2.16 sec   11.13 M     1.10
 7 "heap_sort double vector iterator reverse reverse"   2.13 sec   11.29 M     1.08
 
Total absolute time for Vector Heap Sort: 18.63 sec
 
Vector Heap Sort Penalty: 1.20

Tout aussi bon .

[Silverstone]

Visual c++ est de loin le meilleur compilateur pour Windows (d'après ce que j'ai pu constater).

Cela sens le mauvais compilo -- maintenant BCB est un ancien ...

Je pense qu'il a fait son temps, qu'il repose en paix à présent...

[Invité]

D'après tous les benchmarks que j'ai pu lire, le meilleur compilateur pour Windows, en termes de vitesse du code produit, c'est celui d'Intel (qui utilise, il est vrai, Visual comme front end).

Pour le reste, la notion de "meilleur" est très subjective. En ce qui me concerne, il sera nettement plus facile de lâcher la STL (que j'utilise plus souvent pour "faire moderne" que parce que j'en ai réellement besoin) que BCB (autour duquel s'organise mon interface...) Et BCB6, tout vieillot qu'il soit reste "mon meilleur" compilateur, parce que c'est celui sous lequel je développe le plus efficacement (NB j'ai également Visual et GCC, et je les utilise de temps en temps)

Francois

[Invité]

Je me rends compte que je n'ai pas remercié les testeurs bénévoles... Merci beaucoup à vous. A charge de revanche !

Francois

[Silverstone]

D'après tous les benchmarks que j'ai pu lire, le meilleur compilateur pour Windows, en termes de vitesse du code produit, c'est celui d'Intel (qui utilise, il est vrai, Visual comme front end).

Oui mais je suppose qu'il ne marche que pour les processeurs Intel, ce qui rend la chose plus facile .

[Goten]

Oui mais je suppose qu'il ne marche que pour les processeurs Intel, ce qui rend la chose plus facile .

Non non.. le code produit marche aussi sur amd. Après pour autre chose que le x86 je sais pas du tout.

[Arzar]

Oui mais je suppose qu'il ne marche que pour les processeurs Intel, ce qui rend la chose plus facile .

?
Le code compilé par ICC tourne sur n'importe quel processeur x86. Ça serait un peu bête d'obtenir des programmes qui se limiteraient à la moitié des pc du marché, non ? Par contre, bien sur, ICC produit du code particulièrement optimisé pour les processeurs intels.

D'après tous les benchmarks que j'ai pu lire, le meilleur compilateur pour Windows, en termes de vitesse du code produit, c'est celui d'Intel (qui utilise, il est vrai, Visual comme front end).

Je viens justement de tester la démo de la dernière version d'ICC 11.1.
Il est en effet tout aussi bon.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
C:\Documents and Settings\Thomas Petit\My Documents\Visual Studio 2008\Projects\Benchmark\Release\Benchmark.exe
 
test                            description   absolute   operations   ratio with
number                                        time       per second   test0
 
 0                 "double pointer verify2"   0.95 sec   3147.95 M     1.00
 1                 "double vector iterator"   0.95 sec   3147.95 M     1.00
 2                 "double pointer reverse"   1.55 sec   1939.24 M     1.62
 3         "double vector reverse_iterator"   1.58 sec   1901.14 M     1.66
 4         "double vector iterator reverse"   1.63 sec   1846.15 M     1.71
 5         "double pointer reverse reverse"   0.95 sec   3147.95 M     1.00
 6 "double vector reverse_iterator reverse"   0.95 sec   3147.95 M     1.00
 7 "double vector iterator reverse reverse"   0.97 sec   3095.98 M     1.02
 
Total absolute time for Vector accumulate: 9.53 sec
 
Vector accumulate Penalty: 1.25
 
 
test                                           description   absolute   operations   ratio with
number                                                       time       per second   test0
 
 0                 "insertion_sort double pointer verify2"   1.51 sec    1.98 M     1.00
 1                 "insertion_sort double vector iterator"   1.33 sec    2.26 M     0.88
 2                 "insertion_sort double pointer reverse"   1.91 sec    1.57 M     1.26
 3         "insertion_sort double vector reverse_iterator"   1.30 sec    2.31 M     0.86
 4         "insertion_sort double vector iterator reverse"   1.30 sec    2.31 M     0.86
 5         "insertion_sort double pointer reverse reverse"   1.31 sec    2.29 M     0.87
 6 "insertion_sort double vector reverse_iterator reverse"   1.30 sec    2.31 M     0.86
 7 "insertion_sort double vector iterator reverse reverse"   1.31 sec    2.29 M     0.87
 
Total absolute time for Vector Insertion Sort: 11.27 sec
 
Vector Insertion Sort Penalty: 0.91
 
 
test                                      description   absolute   operations   ratio with
number                                                  time       per second   test0
 
 0                 "quicksort double pointer verify2"   1.95 sec   12.28 M     1.00
 1                 "quicksort double vector iterator"   2.16 sec   11.13 M     1.10
 2                 "quicksort double pointer reverse"   2.20 sec   10.89 M     1.13
 3         "quicksort double vector reverse_iterator"   2.13 sec   11.29 M     1.09
 4         "quicksort double vector iterator reverse"   2.13 sec   11.29 M     1.09
 5         "quicksort double pointer reverse reverse"   2.09 sec   11.46 M     1.07
 6 "quicksort double vector reverse_iterator reverse"   2.16 sec   11.13 M     1.10
 7 "quicksort double vector iterator reverse reverse"   2.14 sec   11.21 M     1.10
 
Total absolute time for Vector Quicksort: 16.95 sec
 
Vector Quicksort Penalty: 1.10
 
 
test                                      description   absolute   operations   ratio with
number                                                  time       per second   test0
 
 0                 "heap_sort double pointer verify2"   1.97 sec   12.20 M     1.00
 1                 "heap_sort double vector iterator"   2.20 sec   10.89 M     1.12
 2                 "heap_sort double pointer reverse"   2.23 sec   10.74 M     1.14
 3         "heap_sort double vector reverse_iterator"   2.00 sec   12.00 M     1.02
 4         "heap_sort double vector iterator reverse"   2.00 sec   12.00 M     1.02
 5         "heap_sort double pointer reverse reverse"   2.25 sec   10.67 M     1.14
 6 "heap_sort double vector reverse_iterator reverse"   2.28 sec   10.52 M     1.16
 7 "heap_sort double vector iterator reverse reverse"   2.30 sec   10.45 M     1.17
 
Total absolute time for Vector Heap Sort: 17.23 sec
 
Vector Heap Sort Penalty: 1.11

Il est quand même un peu moins "stable" que MSVC sur la pénalité d'abstraction. Alors que MSVC aligne les 1.0 imperturbablement, ICC dérape de temps en temps.

Deux petites particularités intéressantes :
1) Il éclate complètement MSVC 10 sur le premier test "Vector accumulate". Sur mon pc, on passe de 30 secondes à 10 secondes et de 796.60 M à 3147.95 M d'opérations par secondes ! Le timing des autres tests est par contre à peu près identique... Bizarre...

2) Pour le deuxième test, ICC donne des "pénalités" d'abstraction de 1.00, 0.88, 1.26, 0.86, 0.86, 0.87, 0.86, 0.87 pour un total de .... 0.91 !
C'est un mystère complet pour moi. Je ne comprends pas du tout comment un compilateur peut faire une meilleure optimisation avec un itérateur qu'avec un pointeur, même dans les cas les plus tordus, car sous Visual Studio ICC utilise la STL de microsoft, qui définit un itérateur de vecteur peu ou prou comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
template <typename T>
class Vector_Iterator
{
public:
// plein de fonction.... operator *, operator ++, operator --,  etc
 
private:
   T* _Ptr;
}

[Silverstone]

Par contre, bien sur, ICC produit du code particulièrement optimisé pour les processeurs intels.

Oui donc ça n'est valable que pour les processeurs Intel . En tout cas en ce qui concerne les optimisations (ce qui rend la chose plus facile)...

Alors que MSVC aligne les 1.0 imperturbablement, ICC dérape de temps en temps.

Il était sur une patinoire ? Ca pourrait expliquer .

[Invité]

?
1) Il éclate complètement MSVC 10 sur le premier test "Vector accumulate". Sur mon pc, on passe de 30 secondes à 10 secondes et de 796.60 M à 3147.95 M d'opérations par secondes ! Le timing des autres tests est par contre à peu près identique... Bizarre...

Accumulate est une fonction assez particulière, dans le sens où (à la difference des autres tests, fondés sur des tris) elle parcourt le tableau de proche en proche, et l'ordre de parcours est connu à l'avance. Donc, ni saut ni indirection. Je soupçonne que c'est typiquement ce qu'un compilateur "dédié" comme ICC sait parfaitement exploiter. Je suis juste un peu surpris que cela ne se retrouve pas dans quicksort, parce que la boucle internet de quicksort (recherche de pivot) ca repose exactement sur le même principe. Sans doute à cause des tests...

2) Pour le deuxième test, ICC donne des "pénalités" d'abstraction de 1.00, 0.88, 1.26, 0.86, 0.86, 0.87, 0.86, 0.87 pour un total de .... 0.91 !
C'est un mystère complet pour moi. Je ne comprends pas du tout comment un compilateur peut faire une meilleure optimisation avec un itérateur qu'avec un pointeur, même dans les cas les plus tordus,

Ma théorie personnelle, là dessus, c'est que dans le cas où il travaille sur des itérateurs, ICC n'effectue pas les optimisations de code dans le même sens que pour des types natifs. En gros, sur des types natifs, il va privilégier des optimisations "bas niveau" alors que pour des types utilisateur il commence par simplifier le code "haut niveau".

Pour insert sort, dont la boucle de plus haut niveau est assez simple, je pense qu'il arrive à appliquer (pour les itérateurs) la même ruse que celle qui fait des merveilles avec accumulate. En revanche, quand il a des pointeurs, il commence par une optimisation malencontreuse de bas niveau...

Ceci dit, hors STL, la différence de vitesse entre Visual et ICC est assez documentée. Au fil des années Visual se rapproche, mais ICC a encore pas mal d'avance.

Francois