A SUPPRIMER

Messages postés
103
Date d'inscription
vendredi 21 avril 2006
Statut
Membre
Dernière intervention
10 février 2008
- - Dernière réponse : vecchio56
Messages postés
6539
Date d'inscription
lundi 16 décembre 2002
Statut
Modérateur
Dernière intervention
22 août 2010
- 27 juin 2006 à 15:13
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/38280-a-supprimer

Afficher la suite 
vecchio56
Messages postés
6539
Date d'inscription
lundi 16 décembre 2002
Statut
Modérateur
Dernière intervention
22 août 2010
7 -
La différence en i-- et --i est important quand i est un objet d'une classe, parce que ces deux opérateurs sont codés différemment. Comme --i retourne l'objet calculé ("i-1"), il est plus rapide que i-- que calcule un objet ("i-1") mais en retourne un autre ("i")
Pamaury
Messages postés
341
Date d'inscription
jeudi 3 avril 2003
Statut
Membre
Dernière intervention
17 juin 2008
1 -
Tu va surement me dire que je pinaille mais il me semble que tu ne code pas opengl :)
A chaque application sa spécialité, dans 99.99999999% des cas on en a rien à foutre de gagner une ns .

"Avant les tableaux que tu donnes (qui passent pas, mais ça c'est pas ta faute), tu dis que c'est l'algorithme qui compte. Je ne suis pas d'accord. Plus exactement, ça dépend.
Pour un étudiant qui a un projet à faire, effectivement, le principe est plus intéressant que le résultat.
Mais à l'inverse, je doute que les gens qui développent OpenGL (ou d'autres librairies du genre) s'amusent à faire du code particulièrement élégant. Là au contraire, si on peut gagner 1ms, c'est déjà énorme."

Ton raisonnement est faux .
On fait d'abord un bon algo puis on optimise . tu optimise pour gagner 1ns par pixel mais si ton algo utilise 1s pour traiter chaque pixel çà ne sert à rien donc l'algo compte beaucoup plus que l'optimisation .

Quand à ton prof je veux bien qu'il t'es dit çà mais sur developpez.com il y a aussi eut un thread là dessus . C'était assez intéressant de voir une centaine de post parler d'un sujet vain . De toute façon je ne vois même pas pourquoi on peut douter que les deux écriture génère du code différent mais bon c'est comme çà .

Pour le coup du loop/dec-jxx, les tableau semblent dire le contraire mais bon je n'irai pas tester .
fkx
Messages postés
44
Date d'inscription
jeudi 29 janvier 2004
Statut
Membre
Dernière intervention
26 juin 2006
-
Pamaury>

Alors, tout d'abord je vais te contredire en ce qui concerne developpez.com puisque je vais pas sur ce site. Et même mieux, je peux t'apprendre que c'est mon prof de compil' qui m'avait fait cette remarque. Donc, ça m'étonnerait bien que tu t'en rappelles !

D'autre part, si tu ne vois pas d'intérêt à gagner des nanosecondes, sache que moi non plus. J'aime le faire, c'est tout. Y'a des gens qui aiment le chocolat, et d'autres qui aiment gagner des nanosecondes. C'est pas la peine de se taper dessus pour savoir si y'a un intérêt à ça !

Avant les tableaux que tu donnes (qui passent pas, mais ça c'est pas ta faute), tu dis que c'est l'algorithme qui compte. Je ne suis pas d'accord. Plus exactement, ça dépend.
Pour un étudiant qui a un projet à faire, effectivement, le principe est plus intéressant que le résultat.
Mais à l'inverse, je doute que les gens qui développent OpenGL (ou d'autres librairies du genre) s'amusent à faire du code particulièrement élégant. Là au contraire, si on peut gagner 1ms, c'est déjà énorme.
(Oui oui, je sais : là on gagne des nanosecondes... Sauf que 1 nanoseconde de moins pour traiter 1 pixel, ça fait presque 2ms de gagnées pour une image en 1600x1200. Sur les 16ms dont on dispose pour calculer une image (en 60Hz), je trouve que gagner 1/8 de temps c'est pas si mal ! Et il y a sûrement plus de gens que ce que l'on peut croire qui utilisent cette résolution. Il suffit de faire des LANs pour le voir...)


Par flemme, je ne ferai pas de test concernant les gains de dec/jxx sur loop, même si je suis convaincu qu'on gagne plus de des nanosecondes...

Par contre et pour finir, j'ai moi-même désassemblé plein de petits bouts de code pour voir ce qui se passait (de toute façon, je crois que y'a que comme ça que je saurai la vérité à ce sujet), et la conclusion est la suivante (je la fait suffisament précise pour ne pas être ambigu mais aussi et surtout pour qu'elle puisse être dispensée, afin de lever ce voile qui pèse encore sur de nombreux programmeurs ;-) ) :

Dans les langages C et C++, les opérateurs unaires d'incrémentation/décrémentation préfixés et postfixés sont équivalents pour les types de base. Le code assembleur x86 généré utilise inc/dec pour les opérandes d'arithmétique entière. Les opérandes en virgule flottante sont quant à eux gérés par l'instruction fld1 suivie de faddp/fsubp.
(Test effectué avec gcc 4.0.2)

Voilà. Sur ce, je souhaite une bonne continuation à tout le monde.
cs_saylar
Messages postés
103
Date d'inscription
vendredi 21 avril 2006
Statut
Membre
Dernière intervention
10 février 2008
-
Moi, qui ne cherche pas à gagner des nanosecondes, je trouve qu'il est préferable de faire à l'inspir, parce que le temps de faire deux programmes de test, de les convertire en asm, d'écrire une remarque... est énorme par rapport au temps que prend l'ordinateur pour faire une boucle.

Sinon, on m'a fait remarquer qu'il serait bien de pouvoir choisir en tre la hauteur et la largeur. Bien sur, c'est possible, mais sachant qu'il faudrait doubler le code pour obtenir cette fonction, alors qu'il sufit d'ouvrir paint pour modifier ce qu'on veut, je préfère laisser comme ça. Sinon, merci quand même.

Enfin, merci à SAKINGDOM pour m'avoir reperé ce que je croit maintenant être le dernier bug :
"for(i=0; i>[...]; i+=1)"

Michel
Pamaury
Messages postés
341
Date d'inscription
jeudi 3 avril 2003
Statut
Membre
Dernière intervention
17 juin 2008
1 -
"Et à ce titre, quelqu'un m'a dit un jour qu'il était plus rapide de faire un --i qu'un i--"

Oui je me rappèle, c'était sur developpez.com et il a bien dû y avoir 200 post sur ce thread . Mais je vois pas pourquoi le compilo transformerer:
--i en dec i
et
i-- en sub i,1

Et d'ailleurs rien ne nous dit que as(l'assembleur de gcc) n'optimise pas sub i,1 en dec i .
Et enfin rien ne nous dit que le proc n'optimise pas sub i,1 en dec i .
Donc çà me parait stupide d'en débattre . Et puis pour gagner 1 ns sur 1 millier d'itération, merci le gain .

Pour en revenir au coup de la boucle . Cela ne change rien car on ne fait jamais assez d'itération pour voir la différence(s'il y en a une notable) .
Je ne fait pas parti des gens qui essaye de gratter 1 ns sur une boucle de 10000 itérations car ce n'est pas intéressant, c'est l'algorithme qui compte(et j'en sais quelque chose en la matière) .

Pour informations:
Loop:
Clocks 286 386 486
label: jump 8+m 11+m 6
no jump 4 ? 2

Dec:
Operands 808x 286 386 486
reg8 3 2 2 1
mem 15+EA 7 6 3
reg16/32 3 2 2 1

Jcxx:
Operands 808x 286 386 486
label: jump 18 8+m 9+m 8
no jump 6 4 5 5

Fais le calcul par toi-même....