Optimisation de tests... - Page 1

En Basic 82/83(+) ça va bien plus vite de faire :

:x+(k=24)(x<94)-(k=26)(x>0)->x

que :
:if k=24 and x < 94:x+1->x
:if k=26 and x > 0:x-1->x
Sur 89, j'en sais rien je n'ai jamais programmé en BASIC.

Es-ce qu'en C la même chose serait plus rapide ? :

x=x+(k=24)(x<94)-(k=26)(x>0);

Au lieu de faire:
if(k=24 && x<94)
{
x++;
}

if(k=26 && x>0)
{
x--;
}

Bon j'en doute bcp mais bon j'aimerais bien savoir de ce qu'il est ait.

Bonne question. Je n'en ai aucune idée. Je vais comparer les codes générés
Je pense quand même que ce sera plus rapide avec la deuxième solution, en fait...

Oui, je pense aussi.

Ben à vrai dire, juste ne regardant la tête des codes générés, je ne suis pas trop capable de te dire ça. Il faudrait à la limite compter les cycles...
Peut-être que la deuxième solution est légèrement devant, mais de peu.

La deuxième solution sera clairement la plus rapide. Si Ti-GCC optimise bien, dans le meilleur des cas il convertira la première solution en la deuxième, mais ne fera pas mieux.

En fait :
1) les multiplications sont très lentes, sauf si c'est une constante puissance de 2 (mais ici ce n'est pas constant)
2) (x<94) est développé de manière interne en ({ if (x<94) then 1; else 0; }), donc ça n'apporte rien (Kevin va dire que TI-GCC utilise des sxx, mais ça n'apporte pas grand chose)

voué, ce sera la derniere...

Pollux
a écrit : 1) les multiplications sont très lentes, sauf si c'est une constante puissance de 2 (mais ici ce n'est pas constant)

TIGCC n'a pas mis de multiplication

2) (x<94) est développé de manière interne en ({ if (x<94) then 1; else 0; }), donc ça n'apporte rien (Kevin va dire que TI-GCC utilise des sxx, mais ça n'apporte pas grand chose)

Oui, TIGCC utilise des sxx, mais ça change quoi ?

arf, j'ai été long pour taper ... lol

jackiechan> qu'est-ce qu'il génère TI-GCC? (par curiosité)

Je poste la source directement, ou bien je fais un "source" (coloration syntaxique, mais n° de lignes chiants) ?

as you feel

Bon, bah les deux alors fonction1:      link.w %a6,#0      move.w %d0,%d2 #L19     x+=(k==24)*(x<94)-(k==26)*(x>0);  return x;      cmp.w #93,%d1      jbgt .L2      cmp.w #24,%d0      seq %d0      ext.w %d0      neg.w %d0 .L3:      tst.w %d1      jble .L4      add.w %d1,%d0      cmp.w #26,%d2      jbne .L5      subq.w #1,%d0      jbra .L5      .even .L4:      add.w %d1,%d0      jbra .L5      .even .L2:      clr.w %d0      jbra .L3      .even .L5:      unlk %a6      rts      .even      .globl     fonction2 fonction2:      link.w %a6,#0      move.w %d0,%d2      move.w %d1,%d0 #L25     if(k==24 && x<94)  {  x++;  }      cmp.w #24,%d2      jbeq .L10 .L8: #L29     if(k==26 && x>0)  {      cmp.w #26,%d2      jbne .L9      tst.w %d0      jble .L9 #L31     x--; ...      subq.w #1,%d0      jbra .L9      .even .L10:      cmp.w #93,%d1      jbgt .L8 #L27     x++; ...      addq.w #1,%d0      jbra .L8      .even .L9:      unlk %a6      rts

fonction1:
	link.w %a6,#0
	move.w %d0,%d2
#L19	x+=(k==24)*(x<94)-(k==26)*(x>0);  return x;
	cmp.w #93,%d1
	jbgt .L2
	cmp.w #24,%d0
	seq %d0
	ext.w %d0
	neg.w %d0
.L3:
	tst.w %d1
	jble .L4
	add.w %d1,%d0
	cmp.w #26,%d2
	jbne .L5
	subq.w #1,%d0
	jbra .L5
	.even
.L4:
	add.w %d1,%d0
	jbra .L5
	.even
.L2:
	clr.w %d0
	jbra .L3
	.even
.L5:
	unlk %a6
	rts

	.even
	.globl	fonction2
fonction2:
	link.w %a6,#0
	move.w %d0,%d2
	move.w %d1,%d0
#L25	if(k==24 && x<94)  {  x++;  }
	cmp.w #24,%d2
	jbeq .L10
.L8:
#L29	if(k==26 && x>0)  {
	cmp.w #26,%d2
	jbne .L9
	tst.w %d0
	jble .L9
#L31	x--; ...
	subq.w #1,%d0
	jbra .L9
	.even
.L10:
	cmp.w #93,%d1
	jbgt .L8
#L27	x++; ...
	addq.w #1,%d0
	jbra .L8
	.even
.L9:
	unlk %a6
	rts

Tu devrais plutôt mettre:
x+=(k=24 && x<94)-(k=26 && x>0);

OK il n'est pas idiot mais la 2è solution génère quand même un code plus efficace...