Ce qui compte comme un flop?

Question

Dire que j'ai un programme C qui est en pseudoish:

For i=0 to 10
    x++
    a=2+x*5
next

est le nombre de flops de ce (1 [x ++] + 1 [x * 5] + 1 [2 + (x + 5))] * 10 [boucle], pour 30 flops? J'ai du mal à comprendre ce qu'est un flop.

Notez que la [...] indiquent où je reçois mes comptes pour les « opérations » de.

Answer 1

Aux fins des mesures fiascos, habituellement seulement des additions et multiplications sont inclus. Des choses comme les divisions, racines carrées, inverses et fonctions transcendantes sont trop chers pour inclure une seule opération, alors que des choses comme des charges et les magasins sont trop trivial.

En d'autres termes, le corps de la boucle contient 2 et ajoute une multiplication, donc (en supposant que x est virgule flottante) à chaque itération de la boucle est de 3 ops; si vous exécutez 10 fois la boucle que vous avez fait 30 opérations.

Notez que lors de la mesure MIPS, votre boucle serait plus de 3 instructions, car il inclut également des charges et les magasins que la mesure FLOPS ne compte pas.

Answer 2

FLOPS est synonyme de opérations flottantes par seconde. Si vous traitez avec des nombres entiers, alors vous n'avez pas d'opérations en virgule flottante dans votre code.

Answer 3

Les affiches ont clairement fait savoir que FLOPS (détaillé ) sont concernés par virgule flottante opérations (par opposition à entier) par seconde , vous avez non seulement de compter le nombre d'opérations que vous effectuez, mais dans quelle période de temps.

Si « x » et « a » sont des flotteurs, vous faites une bonne tentative de compter le nombre d'opérations dans votre code, mais vous devez vérifier le code objet pour vous assurer que la quantité d'instructions à virgule flottante sont réellement utilisés. Par exemple, si « un » est pas utilisée par la suite, un compilateur d'optimisation peut ne pas être la peine de calculer.

En outre, certaines opérations flottantes (telles que l'ajout) pourrait être beaucoup plus rapide que d'autres (comme la multiplication), donc une boucle de flotteur n'ajoute pourrait fonctionner à beaucoup plus FLOPS qu'une boucle de multiplications flotteur uniquement sur la même machine.

Answer 4

FLOP (s indique le minuscule pluriel Plouf, par Martinho Fernandes commentaire) faites référence à des instructions en virgule flottante langage machine, donc cela dépend de combien d'instructions vos compiles de code jusqu'à.

Tout d'abord, si toutes ces variables sont des nombres entiers, alors il n'y a pas FLOP dans ce code. Supposons, cependant, que votre langue reconnaît toutes ces constantes et les variables comme variables à virgule flottante simple précision (avec simple précision facilite le chargement des constantes plus facile).

Ce code pourrait compiler à (MIPS):

Assignment of variables: x is in $f1, a is in $f2, i is in $f3.
All other floating point registers are compiler-generated temporaries.
$f4 stores the loop exit condition of 10.0
$f5 stores the floating point constant 1.0
$f6 stores the floating point constant 2.0
$t1 is an integer register used for loading constants
    into the floating point coprocessor.

     lui $t1, *upper half of 0.0*
     ori $t1, $t1,  *lower half of 0.0*
     lwc1 $f3, $t1
     lui $t1, *upper half of 10.0*
     ori $t1, $t1,  *lower half of 10.0*
     lwc1 $f4, $t1
     lui $t1, *upper half of 1.0*
     ori $t1, $t1,  *lower half of 1.0*
     lwc1 $f5, $t1
     lui $t1, *upper half of 2.0*
     ori $t1, $t1,  *lower half of 2.0*
     lwc1 $f6, $t1
st:  c.gt.s $f3, $f4
     bc1t end
     add.s $f1, $f1, $f5
     lui $t1, *upper half of 5.0*
     ori $t1, $t1,  *lower half of 5.0*         
     lwc1 $f2, $t1
     mul.s $f2, $f2, $f1
     add.s $f2, $f2, $f6
     add.s $f3, $f3, $f5
     j st
end: # first statement after the loop

Ainsi, selon la définition de Gabe, il y a 4 FLOP dans la boucle (3x add.s et 1x mul.s). Il y a 5 FLOP si vous comptez également la boucle c.gt.s comparision. Multiplier par 10 pour un total de 40 (ou 50) flops utilisés par le programme.

Une optimisation meilleur compilateur peut reconnaître que la valeur de a n'est pas utilisé à l'intérieur de la boucle, il n'a besoin que de calculer la valeur finale de a. Il pourrait générer un code qui ressemble à

     lui $t1, *upper half of 0.0*
     ori $t1, $t1,  *lower half of 0.0*
     lwc1 $f3, $t1
     lui $t1, *upper half of 10.0*
     ori $t1, $t1,  *lower half of 10.0*
     lwc1 $f4, $t1
     lui $t1, *upper half of 1.0*
     ori $t1, $t1,  *lower half of 1.0*
     lwc1 $f5, $t1
     lui $t1, *upper half of 2.0*
     ori $t1, $t1,  *lower half of 2.0*
     lwc1 $f6, $t1
st:  c.gt.s $f3, $f4
     bc1t end
     add.s $f1, $f1, $f5
     add.s $f3, $f3, $f5
     j st
end: lui $t1, *upper half of 5.0*
     ori $t1, $t1,  *lower half of 5.0*         
     lwc1 $f2, $t1
     mul.s $f2, $f2, $f1
     add.s $f2, $f2, $f6

Dans ce cas, vous avez 2 ajouts et 1 dans la boucle comparision (10 vous, multiplié donne 20 ou 30 FLOP), plus 1 multiplication et 1 plus en dehors de la boucle. Ainsi, votre programme prend maintenant 22 ou 32 FLOP selon que l'on compte comparisions.

Answer 5

est x un nombre entier ou une variable à virgule flottante? Si c'est un entier, votre boucle ne peut pas contenir de flops.