Re: Informatique : Optimisation, minimisation, projet

Sur des exemples a la con :


=========== i++ VS ++i ==================
$diff test1.c test2.c
7c7
< for(i=0; i<12000; i++)
---
> for(i=0; i<12000; ++i)
[13:39:45] cykl ~/test ¤ gcc -S test1.c
[13:39:52] cykl ~/test ¤ gcc -S test2.c
[13:39:55] cykl ~/test ¤ diff test1.s test2.s
1c1
< .file "test1.c"
---
> .file "test2.c"

Quelqu'un peu me presenter un exemple concret ???
notez qu'il n'y a meme pas d'O.


============== x*2 VS x + x ================
[13:47:03] cykl ~/test ¤ diff test3.c test4.c
7c7
< x = x * 2;
---
> x = x + x;
[13:48:03] cykl ~/test ¤ gcc -S test3.c
[13:48:10] cykl ~/test ¤ gcc -S test4.c
[13:48:12] cykl ~/test ¤ diff test3.s test4.s
1c1
< .file "test3.c"
---
> .file "test4.c"
21,23c21,23
< movl -4(%ebp), %eax
< sall 1,ドル %eax
< movl %eax, -4(%ebp)
---
> movl -4(%ebp), %edx
> leal -4(%ebp), %eax
> addl %edx, (%eax)
[13:48:15] cykl ~/test ¤ gcc -O3 -S test4.c
[13:48:20] cykl ~/test ¤ gcc -O3 -S test3.c
[13:48:22] cykl ~/test ¤ diff test3.s test4.s
1c1
< .file "test3.c"
---
> .file "test4.c"
==================== x / 2 VS x * 0.5 ====================
[13:49:54] cykl ~/test ¤ diff test3.c test4.c
7c7
< x = x / 2;
---
> x = x * 0.5;
[13:49:33] cykl ~/test ¤ gcc -S test3.c
[13:49:39] cykl ~/test ¤ gcc -S test4.c
[13:49:42] cykl ~/test ¤ diff test3.s test4.s
1c1
< .file "test3.c"
---
> .file "test4.c"
4a5,8
> .align 8
> .LC1:
> .long 0
> .long 1071644672
21,27c25,34
< movl -4(%ebp), %edx
< movl %edx, %eax
< sarl 31,ドル %eax
< shrl 31,ドル %eax
< leal (%eax,%edx), %eax
< sarl 1,ドル %eax
< movl %eax, -4(%ebp)
---
> fildl -4(%ebp)
> fldl .LC1
> fmulp %st, %st(1)
> fnstcw -6(%ebp)
> movw -6(%ebp), %ax
> movb 12,ドル %ah
> movw %ax, -8(%ebp)
> fldcw -8(%ebp)
> fistpl -4(%ebp)
> fldcw -6(%ebp)
[13:49:45] cykl ~/test ¤ gcc -O3 -S test4.c
[13:49:50] cykl ~/test ¤ gcc -O3 -S test3.c
[13:49:52] cykl ~/test ¤ diff test3.s test4.s
1c1
< .file "test3.c"
---
> .file "test4.c"
=============================================


Toutes ces astuces me paraisse etre un peu de l'enculage de mouche puisque a premiere vu le compilateur peut tres bien le faire tout seul. C'est un peu la meme chose que les multiplications par un multiple de 2 qui sont transformée en decallage de bit. A priori le compilateur le fait et l'ecrire en dur sert juste a rendre le code illisible.

S'amuser a lire les sorties assembleurs de l'ami gcc est parfois tres interessant meme si ce n'est faisable que sur de petits codes.

Donc je suis _VRAIMENT_ interessr pour qu'on me montre du code ou de telles optimisations _DOIVENT_ etre faites a la main et pourquoi le compilateur ne le fait pas lui meme. Il y'a d'autres optimisations (voir le lien que je donne plus bas) qui elles ont vraiment un impacte sur la vitesse d'execution en tenant compte des caracteristiques des processeurs (dependances des variables etc...). Mais bien entendu il est tres difficile d'ecrire du code comme ca :-)


De plus tes optimisations des operateurs binaires sont vraiment attroces. Et permettrons a ton programme de ne jamais etre portable. On pourrait aussi faire les syscalls en assembleur :-)