Discussion :

[Frifron]

Salut,

je poste ici car j'ai remarqué qu'un parcours de conteneur avec itérateur sous visual studio (visual 2008 express) est plus lent qu'un parcours par indices.

En gros ce code :

Code :

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

1
2
3
4
5
6
 
for (vector<MyClass> it = myVector.begin(); it != myVector.end(); ++it)
{
    it->myFunction();
    //...
}

va être plus lent que ce code :

Code :

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

1
2
3
4
5
6
 
for (size_t i = 0; i < myVector.size(); ++i)
{
    myVector[i].myFunction();
    //...
}

Je compile en release avec toutes les opti de vitesse activées (je pense) et pour un grand nombre d'objets, la méthode 1 est plus lente que la méthode 2.

Je pense que visual doit vérifier la validité à chaque tour de boucle ou quelque chose comme ca. Y aurait il une option que j'ai oublié d'activer ou quelque chose ?

Je trouve ca dommage parceque du coup ca ne me pousse pas a utiliser les itérateurs alors que c'est une manière plus élégante de faire ses boucles.

Quelqu un a déjà remarquer ca ? Avez vous une solution ?

Merci beaucoup

[3DArchi]

Il y a les deux directives à désactiver pour éviter les vérifications sur les itérateurs : _HAS_ITERATOR_DEBUGGING et _SECURE_SCL.
Cependant, moi, en dessous de 10 000 000 d'éléments simples dans vecteur, je ne vois pas la différence.
Vers 100 000 000, j'ai une différence: 7s pour le premier parcours, 2 s pour le second.
A mon avis, tu te poses une mauvaise question. Dans 99% des cas, tes problèmes de perfs seront dûs à tes algos. Normalement, tu fais un algo qui marche. Ensuite tu instrumente ton code pour voir où sont tes problèmes de perfs. Et c'est là que tu agis. Je suis prêt à parier que le cas où tes perfs seront oblitérer par ton parcours d'un vecteur avec un itérateur n'arrivera pas dans 99% des cas.
Conclusion: utilise les itérateurs car comme tu le dis, c'est + sûr, +élégant et +indépendant de ton conteneur.

[Frifron]

Salut, merci pour ta réponse,

Je suis bien d'accord qu'il est mieux d'utiliser les itérateurs et que l'opti doit se faire en premier temps sur les algos. Cependant à algo similaire, je vois une différence entre parcours par itérateurs et parcours par indices.

Par exemple dans mon cas, c'est pour un moteur de particules. Avec 50000 particules j'ai un framerate de 140 avec indices et de 120 avec itérateurs. Il y a une perte de 15%, ce qui n'est pas vraiment négligeable dans mon cas.

Je ne comprend pas pourquoi ces directives sont définie en release. Je vais essayé de les désactiver pour voir si ca change quelquechose.

[3DArchi]

Salut,
Je compile avec /U:_HAS_ITERATOR_DEBUGGING et je change dans yvals.h :

Code :

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

1
2
3
4
#if !defined (_SECURE_SCL)
#define _SECURE_SCL 0
#endif

Je refais les tests avec ça :

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
75
76
77
78
79
80
81
82
83
84
 
#include <iostream>
#include <string>
#include <vector>
#include <iterator>
#include <algorithm>
#include <windows.h>
 
class MyClass
{
public:
   int i;
   MyClass():i(0){}
   void myFunction()
   {++i;}
};
 
struct Foncteur
{
   void operator()(MyClass &_elt)
   {_elt.myFunction();}
};
 
void f1(std::vector<MyClass>&vecteur_)
{
   DWORD dwTime = GetTickCount();
   for (std::vector<MyClass>::iterator it = vecteur_.begin(); it != vecteur_.end(); ++it)
   {
       it->myFunction();
   }
   dwTime = GetTickCount()-dwTime;
   std::cout<<"Iterator = "<<dwTime<<std::endl;
}
 
void f2(std::vector<MyClass>&vecteur_)
{
   DWORD dwTime = GetTickCount();
   for(size_t i = 0;i<vecteur_.size();++i){
       vecteur_[i].myFunction();
   }
   dwTime = GetTickCount()-dwTime;
   std::cout<<"[] = "<<dwTime<<std::endl;
}
 
void f3(std::vector<MyClass>&vecteur_)
{
   DWORD dwTime = GetTickCount();
   size_t i = vecteur_.size();
   while(i >0)
   {
      --i;
       vecteur_[i].myFunction();
   }
   dwTime = GetTickCount()-dwTime;
   std::cout<<"[](2) = "<<dwTime<<std::endl;
}
 
void f4(std::vector<MyClass>&vecteur_)
{
   DWORD dwTime = GetTickCount();
   std::for_each(vecteur_.begin(),vecteur_.end(),Foncteur());
   dwTime = GetTickCount()-dwTime;
   std::cout<<"Foncteur = "<<dwTime<<std::endl;
}
 
int main()
{
   int nbr_elts;
   std::cout<<"Nombre d'elements : ";
   std::cin>>nbr_elts;
   std::vector<MyClass> vecteur;
 
   while(nbr_elts>0){
      vecteur.resize(nbr_elts);
      f1(vecteur);
      f2(vecteur);
      f3(vecteur);
      f4(vecteur);
      std::cout<<"Nombre d'elements : ";
      std::cin>>nbr_elts;
   }
 
return 0;
}

Et là, j'ai des résultats comparables.

[EDIT]: il y a aussi certainement des phénomènes de cache que je ne maîtrise pas car en faisant la boucle plusieurs fois de suite, les résultats varient un peu et ne permettent plus de distinguer franchement une approche d'une autre.

[farscape]

salut,
tu es sur que HAS_ITERATOR_DEBUGGING est actif en release ?

[3DArchi]

salut,
tu es sur que HAS_ITERATOR_DEBUGGING est actif en release ?

Il me semble qu'il est défini par défaut. Et que il faut le passer en undef explicitement. Par rapport au code de Frifron, (sur Visual Express), la vérification sur les itérateurs se fait par un 'ou' (c'est plus ou moins dans le fichier <vector>) :

Code :

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

1
2
 
 #if _HAS_ITERATOR_DEBUGGING || _SECURE_SCL