PERFORMANCE : I++ OU ++I ?
ndj55
Messages postés
13
Date d'inscription
lundi 4 juin 2001
Statut
Membre
Dernière intervention
13 décembre 2002
-
3 nov. 2002 à 21:03
pasm Messages postés 3 Date d'inscription mercredi 14 septembre 2005 Statut Membre Dernière intervention 28 octobre 2006 - 23 oct. 2005 à 22:47
pasm Messages postés 3 Date d'inscription mercredi 14 septembre 2005 Statut Membre Dernière intervention 28 octobre 2006 - 23 oct. 2005 à 22:47
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/10095-performance-i-ou-i
https://codes-sources.commentcamarche.net/source/10095-performance-i-ou-i
23 oct. 2005 à 22:47
12 janv. 2003 à 03:03
le i++ requiert de creer une variable temporaire, car on peut faire tableau[i++]; et i va exister dans 2 etat un etat non incrementé temporaire pour l'indice du tableau, et un etat incrementer pour la nouvelle valeur de i.
il faudrai transformer en asm une class integer refaite avec post incrementation et pre incrementation et la transformer en asm, en desactivant si possible les optimisations.
31 déc. 2002 à 15:20
int *a=x;
b=*(++a); est beaucoup plus lente que b=*(a++);
equivalent a: (a= a0 b=d0 );
addq #1,a0
move.l (a0),d0
contre:
move.l (a0)+,d0
...
@+
21 nov. 2002 à 15:22
19 nov. 2002 à 18:11
Pour les opérations sur les types de données simples (int par exemple), la différence ne se situe pas dans l'opération elle - même (les codes asm sont équivalents) mais sur l'évaluation de l'expression. Je m'explique :
int i = 5;
( ++i == 5 ) est faux car l'incrémentation a lieu avant l'évaluation
int i = 5;
( i ++ == 5 ) est vrai car l'incrémentation a lieu après l'évaluation
J'espère que c'est clair...
10 nov. 2002 à 12:15
9 nov. 2002 à 14:50
il y a aussi /FC,qui génere un code COD...
9 nov. 2002 à 01:37
*va tester ça*
8 nov. 2002 à 18:37
$L43572:
push esi
push OFFSET FLAT:??_C@_02JAFN@?$CFi?$AA@ ; `string'
call _printf
add esp, 8
inc esi
cmp esi, 32 ; 00000020H
jl SHORT $L43572
$L43576:
push esi
push OFFSET FLAT:??_C@_02JAFN@?$CFi?$AA@ ; `string'
call _printf
add esp, 8
inc esi
cmp esi, 32 ; 00000020H
jl SHORT $L43576
Voilà deux boucles qui font la meme chose mais l'incrmentation est différente... Tu vois bien que c'est la meme chose: "inc esi"...
8 nov. 2002 à 17:09
Ou peut tu voir la sortie asm de ton compilo stplè?
7 nov. 2002 à 21:45
Perso,j'utilise les deux,c'est selon mes humeurs...
6 nov. 2002 à 23:55
merci Kinamstrong !
6 nov. 2002 à 14:53
Bon bref je vienx soutenir vieux lion car Jhep n'est pas complètement convaincu.
Sinon je répon à la question de vieux utlisez vous i++ ou ++i. J'utilise c++ car c'est plus jolie, sinon si la boucle est grande et la performance primordiale j'écris ++c .ourquoi c et non pas i comme tout le monde?? Par ce que c c'est le nom du langage et puis c c'est la premièere lettre de compteur :)
Sinon j'ai pas compris ton tableau?? i++ et ++i pour le int c'est kif kif mais pour les double ++i c'est 5 kilomèetre devant?
En tout cas merci vieux lion d'avoir mis une source avec les tests car je ne savais pas que la différence de temps était aussi grande pour les double.
Si après l'exemple de vieux lion il y a encore des gens qui pense que i++ et ++i sont aussi rapide je me tire une balle :(
6 nov. 2002 à 13:16
unsigned int ElapsedTime[NBR_THREADS]; es à remplacer par
unsigned int ElapsedTime[NBR_TESTS];
6 nov. 2002 à 13:14
------------------------------------------------
#define NBR_TESTS 512 // Le Nombre De Mesures A Effectuer
ofstream StatFile;
int i;
unsigned long StartTime;
unsigned long EndTime;
unsigned int ElapsedTime[NBR_THREADS];
unsigned long TotalTime = 0;
float AverageTime;
for (i = 0; i < NBR_TESTS; ++i)
{
StartTime = timeGetTime();
/* C'est ici que doit se situer un appel unique à la fonction testée */
EndTime = timeGetTime();
ElapsedTime[i] = EndTime - StartTime;
}
StatFile.open("Stat.txt");
for (i = 0; i < NBR_TESTS; ++i)
{
StatFile << "Time For Thread " << i << " : " << ElapsedTime[i] << endl;
TotalTime += ElapsedTime[i];
}
StatFile << "---------------------------
Total Time: " << TotalTime << endl;
AverageTime = (float) TotalTime / (float) NBR_TESTS;
StatFile << "Average Time: " << AverageTime << endl;
StatFile.close();
-----------------------------------
Ici,un appel à la fonction entre les deux mesures de temps...
Dans un prog qui dessine des fractales,les écarts entre les fonctions identiques avec les meme arguments sont de l'ordre de 1 ou 2 millisecondes... Ce qui prouve que le timer est presque parfait,les différences de mesure pouvant etre dû aux aléas du systeme ou au manque de précision dans la mesure du temps...
Si quelqu'un veut bien refaire les tests de ce que dit vieuxLion avec cette méthode...
Sinon, si vous pensez que ce timer est encore imparfait... utilisez le Zen Timer de Michael Abrash écrit en ASM... Mais je pense qu'ici cé inutile...
6 nov. 2002 à 13:04
La différence majeure entre i++ et ++i réside en fait dans le fait que dans certains cas (fonction en général), la position de ++ (ou --) indique le moment où l'incrémentation doit être faite.... Ainsi,en notation préfixe cela signifie que l'on incrémente avant; en notation post-fixe,on incrémente après...
5 nov. 2002 à 17:59
des sortes de raccourcis de commandes.
Obtient-on les mêmes resultats avec i=i+1;
??????
5 nov. 2002 à 17:57
Mon prof me parlait d'une différence benine en tre les deux (++i et i++) mai la alors en faire un sujet c de la balle et franchement intéressant.
Au fait Galett , ta "macro compilation" ce n'est pas la précompilation!!!!!
@+
5 nov. 2002 à 14:05
Je m'explique, pour les 2 boucles qui sont différentes au niveau syntaxique, visual va faire une première passe pour essayer d'optimiser tout ça. Et ainsi il va transformé la seconde boucle en première boucle pour optimiser justement.
C'est comme si vous aviez sur une seule ligne :
i++;
j'espère bien que le compilateur va le traduire en ++i, sinon il serait pas très bon optimisateur, non ?
enfin c'est surtt une supposition, si qq1 pouvait le confirmer :)
5 nov. 2002 à 09:34
4 nov. 2002 à 23:15
En clair, une erreur est quelque part, mais personne, ou du moin je crois, na la solutions.... donc pout moi ++i = i++ tjr. j'etais convaincu par le teste de jhep mais l'asm plus puissant et vrai lui donne tord.... ??!!
4 nov. 2002 à 22:03
L'article (et mon bench) porte sur les structures et classes
En ce qui concerne les 'int' la variable temporaire est utilisée dans les deux cas car l'assembleur travaille déjà avec un Accumulateur et la zone mémoire.
C'est bien vu : il n'y a pas de différence... et le test de Jhep a plusieurs défauts :
1) il passe plus de temps à calculer time() que i++
2) le résultat n'est pas reproductible : inverser les deux tests pour voir !!!
3) il ne booste pas le process en real time pour être plus fiable : par ex :
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
pour Windows
mon Bench utilise GetTickCount() avant et après la boucle
4 nov. 2002 à 20:42
4 nov. 2002 à 20:40
Je me contenterai de critiquer le titre un peu racoleur (faut bien que je justifie mon label de râleur invétéré !). pour le reste nickel
4 nov. 2002 à 20:18
Regarde cela:
---------------------------------------------
for (i=0; i<32; ++i) // PreFix
printf("%i", i);
for (i=0; i<32; i++) // PreFix
printf("%i", i);
---------------------------------------------
regarde le code asm produit pas Visual Studio 6 avec optimisation:
---------------------------------------------
$L43572:
; Line 20
push esi
push OFFSET FLAT:??_C@_02JAFN@?$CFi?$AA@ ; `string'
call _printf
add esp, 8
inc esi
cmp esi, 32 ; 00000020H
jl SHORT $L43572
; Line 22
xor esi, esi
; Line 26
npad 7
$L43576:
; Line 23
push esi
push OFFSET FLAT:??_C@_02JAFN@?$CFi?$AA@ ; `string'
call _printf
add esp, 8
inc esi
cmp esi, 32 ; 00000020H
jl SHORT $L43576
---------------------------------------------
Et oui c'est exactement la meme chose pour les deux boucles... Donc pas de gain de perfs ici...
4 nov. 2002 à 00:16
sinon tu n'envisages pas de mettre toutes tes connaissances sur un site internet ?
ce serai très bénéfique pour de nombreux programmeurs je pense. :o)
3 nov. 2002 à 23:26
tu vois que l'on fait plus de boucles avec du ++i que du i++ ! (5%)
j'en profite pour joindre mon Benchmark dans la capture d'écran
elle indique 3% de gain pour une classe contenant un int, plus de 80% pour une classe contenant dix doubles et un int et 300% pour une classe contenant un char[256] et un int, etc...
3 nov. 2002 à 22:40
#include <stdio.h>
#include <time.h>
void main()
{
time_t timer;
int s 0, i 0;
printf("Attendez 10 seconds SVP.
");
time(&timer);
s = timer;
while(timer - s < 10){
time(&timer);
i++;
}
printf("Resultat de la boucle avec i++ : %i
", i);
printf("Attendez 10 seconds SVP.
");
i = 0;
time(&timer);
s = timer;
while(timer - s < 10){
time(&timer);
++i;
}
printf("Resultat de la boucle avec ++i : %i
", i);
getchar();
}
3 nov. 2002 à 22:13
3 nov. 2002 à 21:03
Un ++i serait plus rapide qu'un i++ ?