Bonjour,
 
J'ai un programme qui fait des boucles for en cascade, sur 3 niveaux
1er niveau (le plus haut) : environ 50 boucles **Edit 50 et non 5**
2eme niveau : environ 5 boucles
3eme niveau : environ 15 boucles
 
soit environ 3750 passages au niveau le plus bas
 
se sont des boucles sur des itérateurs de deque
 
genre

 
J'ai relevé les temps suivant pour le parcours de la boucle
nbr passage au niveau le plus bas    -temps de parcours en s
3530                                               0.141
3600                                               0.094
3592                                               0.093
3629                                               0.11
3647                                               0.094
 
soit environ 1/10 eme de seconde
 
Ces temps me paraissent assez long surtout que je ne fait rien pour le moment dans la boucle (juste un i++)
Pensez vous qu'ils sont raisonnables ? (Est ce que l'ordre de grandeur est normal?)
 
Peut on l'optimiser ?
Si oui, quelle(s) methode(s) conseillez vous avec la bibliothèque stl ? (des astuces pour optimiser les traitement itératif avec la stl)
 
Question bonus : qu'est ce qui coute du temps dans une boucle ? l'incrément de l'itérateur ? les tests de condition de fin ?
 
Précision : j'ai un intelcore 2 Duo 7200T avec XP

au moins précalculer l'itérateur de fin, peut-être ? (stocker dans une variable locale ton (*rawMapIter).second.end(); )
 
Sinon, les optimisations vont plutôt être d'ordre algorithmiques, en règle générale.
 
On peut espérer que ce qui prend du temps dans la boucle, ce sera justement le traitement que tu fais dans le corps. Si jamais le traitement que tu fais dans le corps de ta boucle commence à devenir comparable au temps d'incrémentation de ton itérateur et de saut dans ta boucle, il faudra chercher à dérouler ta boucle et incrémenter ton itérateur par plus grands pas.

ce n'ait pas comme for(i=0;i<5;++i) , c'est plus lent!
 
declare les suivant as constant , ou calcule les avant la loop (si possible) :  
 
1/ (*rawMapIter).second.end();
2/ pObjIter+1
 
comment tu a mesurer (avec quoi) ?
et les 2 core functionnent ?
(test et poste les resultat ici , je veut voir ce qu'on gagne)  
 

Sorry theshockwave ,    
jai pas vu ta response quand je vien d'ecrire mas response
 

 
L'instruction d'initialisation de la boucle n'est pas exécutée à chaque tour, donc on s'en fiche.
Le mylti threading n'est vraisemblablement pas le sujet ici.

ca depend du compiler
.. pourqoui pas essayer sur un pentium4 normal
et comparer , ... 1/10 seconde c'est trop!
 (c'est pas 10Hz ????? )

encore une fois, tu racontes n'importe quoi. le multithreading n'a aucun rapport avec la choucroute.  
 
Le probleme ici est tres certainement le calcul de l'iterateur de foin qui n'est pas vu comme un invariant de boucle.
Je conseillerais aussi à l'OP d'utiliser std::for_each, std::accumulate et autres algorithmes de la STL plutot que de faire des boucles for.

Première question, est-ce que c'est bien du code optimisé?
Deuxièmement, comment est-ce que tu mesures le temps (50% en plus quand on diminue le nombre d'éléments de 2%, pour une opération qui ne dépend pas d'IO, ça fait penser à un problème méthodologique dans la mesure tant qu'on n'a pas une explication).

Pas de repsonse de toonj?
 

a propos de multithreading , je ne parle pas des  
thread ,...jai dit peut etre le processeur
va diviser le travail de cette loop en quelque maniere
entre les core ... ok je nsai rien de ces double core!  
Je vit encore avec P4 2.8Ghz et pas de problem.  

moi je tombe sur 375 et pas 3750

En fait au 1er niveau c'est 50 boucles.
Pour le calcul, j'ai utiliser la time. et la fonction clock();  

 
pour compiler, j'utilise Visual Studio 2008
 
Remarque de nullos : en testant sans le mode debug  je gagne facilement  un facteur 2 à 3 !!!
et donc je tourne aux environs de 0.040 ...  
N'empêche que je me serai attendu à des temps beaucoup plus faible quand même (de l''ordre du 1000ème de seconde), mais peut être que je phantasme un peu et que compte tenu du code (ci-après) et des outils utilisés cela est cohérent... Qu'en pensez vous ?
 
mon code exact est :

il est pas remanié volontairement, donc légèrement imbitable, mais peut être cela donnera des pistes

1/ Est-ce que quelqu'un a une idée de la précision de clock() sous Windows?  (la résolution est de 1ms, mais j'ai déjà vu des compteurs de temps avec une résolution supérieure à la précision).
 
2/ Tu es au mieux à 40 fois la précision, ça me semble assez faible si tu veux des mesures précises (surtout que je ne serais étonné que la précision soit toujours un 1/18 e ou a peu près hérité de DOS)
 
3/ Tu fais plus qu'itérer, tu as aussi une série de find dans des map qui ont un temps dépendant du nombre d'entrées dedans.  Pour plus de 8, ça ne m'étonnerais pas que ces finds prennent plus de temps que les itérations qui suivent (tu déclares qu'il n'y en a qu'environ 3...)
 
4/ Attention au cache, j'ai pas des chiffres précis en tête, mais j'ai en mémoire un rapport 100 entre le cache le plus rapide et la mémoire externe.

clock est a chier sous WiN32, il faut lui rpeferer QueryPerformanceCounter
 

les find des map sont en o(log N) de mémoire donc oui, ca coute au bout d'un moment
 

Ca depend des archis, ca oscille entre 15 et 350 selon l'archi et le niveau de cache

J'ai tout refait avec des for_each et des foncteurs
j'obtiens maintenant un temps quasi constant de 0.015s (comme c'est à peu près le même quel que soit le nombre de boucle (2000 ou 4000) j'en déduis que c'est la précision de la mesure
Surtout que je suis toujours en debug et que j'ai ajouté un peu du traitement au plus bas niveau de la boucle.
 
Conclusion : utiliser for_each
 
Cela soulève d'autres pbs que j'ai abordé dans un nouveau topic Enchainer les for_each de la Stl
http://forum.hardware.fr/hfr/Progr [...] m#t1954517
 
avis à ceux qui peuvent m'aider, et merci pour ce topic

On ne bench pas en debug...

Pourquoi est-ce qu'un for_each devrait être plus rapide qu'une boucle for?
 

Certaines implémentations de la STL font des optimisations en fonctions des propriétés des types ou tente de dérouler.

OMG un double core, ce sont deux processeurs identiques sur la même puce, c'est tout. Si tu n'as pas de threads, ton code s'exécute sur un seul core.

 
J'avais pas relevé  

j'ai essayer hier un code sur un double-core (tres retarder... )
 
pour le double core (ou +), la creation des thread  
est automatiser (plus facile) , ou le compiler a son mode
pour parallelizer les section du code ou on utilise l'openmp
(ca se control par les params du compiler )
 
ca s'applle work-sharing , j'ai etait pas loin du tout
 
pour l'openmp on ajoute :
 
#pragma omp parallel for num_threads(2) , ... il ya d'autre option de control
for(){
 #pragma ...optional ici
 for(){
 }
}  
 
... ne prenez pas ca au serieux ,
je ne suis pas entrain de passer des examens.
 
au revoir !
 
[EDIT : rien! , j'ajoute "parallel" entre "omp" et "for" ,voir le spec 2.5 pour les details]

c'est tout sauf du work sharing punaise ...  
quand tu essaye d'avoir l'air caler, renseigne toi mieux :€

 le dictionaire dit:  punaise = bug  
 
 je suis un bug !! , merci Joel F!    
 
 Ignorant , j'ai tester ca!    
 si tu nage encore en boost et Nt2 , j'ai plusieurs
 domaine a m'occuper , et je ne doit pas me concentrer
 sur des chose qu'on est sur d'apprendre en deux jour.
 
 ton but est d'avoir un leader-ship ou quoi sur ce forum ?
 j'ai remarquer ca des le debut , mais tu es trop
 superficiel avec trop d'euphorie!!
 
 j'essaye toujours a calmer les chose , mais...
 Ok je vous laisse , ENJOY!
 
 le probleme qu'il ne me connait pas ...
 peut etre il regarde les smilies et essaye d'imaginer!    
 
Quel type !!
 
 au revoir encore.    
 
[EDIT: je laisse comme ca! , je ne suis pas un moderateur ]

 
c'est une blague ?

Si vous continuez dans cette voie, ce sera même "a dans un mois"...