¿Qué se considera un fracaso?

Question

Decir que tengo un programa C que en pseudoish es:

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

es el número de fracasos para esto (1 [x ++] + 1 [x * 5] + 1 [2 + (x + 5))] * 10 [bucle], para 30 TIRÓN? Estoy teniendo problemas para entender lo que es un flop es.

Tenga en cuenta el [...] están indicando donde yo estoy haciendo mis conteos de "operaciones" de.

Answer 1

A los efectos de mediciones flops, por lo general están incluidos sólo adiciones y multiplicaciones. Cosas como divisiones, recíprocos, raíces cuadradas, y las funciones trascendentales son demasiado caros para incluir como una sola operación, mientras que cosas como las cargas y las tiendas son demasiado trivial.

En otras palabras, su cuerpo bucle contiene 2 añade y 1 se multiplican, por lo que (suponiendo x es de coma flotante) cada bucle de iteración es 3 ops; si se ejecuta el bucle de 10 veces que ha hecho 30 operaciones.

Tenga en cuenta que cuando se mide MIPS, el bucle sería más de 3 instrucciones, ya que también incluye las cargas y los almacenes que el FLOPS medición no cuenta.

Answer 2

FLOP Indica operaciones flotante por segundo. Si se trata de números enteros, entonces no tiene ningún operaciones de punto flotante en el código.

Answer 3

Los carteles han dejado claro que FLOPS (detallado aquí ) se ocupan de punto flotante (a diferencia de las operaciones de enteros) por segundo , lo que no sólo tiene que contar el número de operaciones que está realizando, pero en qué período de tiempo.

Si "x" y "a" son los flotadores, estás haciendo un buen intento de contar el número de operaciones en el código, pero que tendría que comprobar el código objeto para asegurarse de qué cantidad de instrucciones de coma flotante se usan en realidad. Por ejemplo, si "A" no se utilice posteriormente, un compilador de optimización podría no ser molesta para calcularla.

Además, algunas operaciones flotantes (por ejemplo, agregar) podría ser mucho más rápido que otros (tales como multiplicar), por lo que un bucle de sólo el flotador añade podría funcionar en muchos más flops de un bucle de sólo multiplica flotador en la misma máquina.

Answer 4

FLOPS (la s minúscula indica el plural de FLOP, por comentario Martinho Fernandes) se refería a lenguaje de máquina instrucciones de punto flotante, por lo que depende el número de instrucciones de sus compila el código a.

En primer lugar, si todas estas variables son números enteros, entonces no hay Flops en este código. Vamos a suponer, sin embargo, que la lengua reconoce todas estas constantes y variables como variables de punto flotante de precisión simple (con precisión simple hace que la carga de las constantes más fácil).

Este código podría compilar (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

Así que de acuerdo a la definición de Gabe, hay 4 Flops dentro del bucle (3x add.s y 1x mul.s). Hay 5 Flops si también contamos el c.gt.s comparación bucle. Multiplicar este por 10 para un total de 40 (o 50) Flops utilizados por el programa.

Un compilador mejor optimización podría reconocer que el valor de a no se utiliza dentro del bucle, por lo que sólo tiene que calcular el valor final de a. Podría generar código que se parece a

     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

En este caso, tiene 2 añade y 1 comparación dentro del bucle (, multiplicado por 10 le da 20 o 30 Flops), más 1 multiplicación y 1 Además fuera del bucle. De este modo, el programa ahora toma 22 o 32 FLOPS dependiendo de si contamos comparaciones.

Answer 5

es X un número entero o una variable de punto flotante? Si se trata de un entero, entonces su bucle no puede contener cualquier flops.