Che cosa conta come un flop?

Question

Dire che ho un programma in C che in pseudoish è:

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

è il numero di Flops per questo (1 [x ++] + 1 [x * 5] + 1 [2+ (x + 5)) ] * 10 [loop], per 30 FLOPS? Ho difficoltà a capire cosa sia un flop.

Nota che [...] indicano da dove vengono i miei conteggi per "operazioni" da.

Answer 1

Ai fini delle misurazioni FLOPS, in genere sono incluse solo aggiunte e moltiplicazioni. Cose come divisioni, reciproche, radici quadrate e funzioni trascendentali sono troppo costose da includere come un'unica operazione, mentre cose come carichi e negozi sono troppo banali.

In altre parole, il corpo del loop contiene 2 add e 1 multiplo, quindi (supponendo che x sia in virgola mobile) ogni iterazione del ciclo è 3 ops; se esegui il ciclo 10 volte hai fatto 30 operazioni.

Si noti che durante la misurazione di MIPS, il ciclo sarà composto da più di 3 istruzioni poiché include anche carichi e depositi che la misurazione FLOPS non conta.

Answer 2

FLOPS sta per operazioni fluttuanti al secondo. Se hai a che fare con interi, allora non hai operazioni in virgola mobile nel tuo codice.

Answer 3

x è un intero o una variabile a virgola mobile? Se è un numero intero, il tuo ciclo potrebbe non contenere alcun flop.

Answer 4

I manifesti hanno messo in chiaro che FLOPS (dettagliato here) sono preoccupati con virgola mobile (a differenza di numero intero) operazioni al secondo , in modo non solo si ha a contare quante operazioni si sta eseguendo, ma in che periodo di tempo.

Se "x" e "a" sono float, stai facendo un buon tentativo di contare il numero di operazioni nel tuo codice, ma dovresti controllare il codice dell'oggetto per assicurarti quale quantità di virgola mobile le istruzioni sono effettivamente utilizzate. Ad esempio, se "a" non viene successivamente utilizzato, un compilatore di ottimizzazione potrebbe non preoccuparsi di calcolarlo.

Inoltre, alcune operazioni mobili (come l'aggiunta) potrebbero essere molto più veloci di altre (come la moltiplicazione), quindi un ciclo di soli float può essere eseguito su molti più FLOP di un ciclo di soli numeri multipli sulla stessa macchina .

Answer 5

FLOP (le lettere minuscole s indicano il plurale di FLOP, per commento di Martinho Fernandes) si riferiscono alle istruzioni in virgola mobile del linguaggio macchina, quindi dipende da quante istruzioni viene compilato il codice.

Prima di tutto, se tutte queste variabili sono numeri interi, non ci sono FLOP in questo codice. Supponiamo, tuttavia, che il tuo linguaggio riconosca tutte queste costanti e variabili come variabili in virgola mobile a precisione singola (usando una precisione singola, il caricamento delle costanti è più semplice).

Questo codice potrebbe compilare a (su 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 

Quindi, secondo la definizione di Gabe, ci sono 4 FLOPS all'interno del ciclo (3x add.s e 1x mul.s). Ci sono 5 FLOP se si conta anche il confronto del ciclo c.gt.s. Moltiplicalo per 10 per un totale di 40 (o 50) FLOP usati dal programma.

Un compilatore di ottimizzazione migliore potrebbe riconoscere che il valore di a non è utilizzato all'interno del ciclo, quindi è necessario calcolare solo il valore finale di a. Si potrebbe generare il codice che sembra

 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 

In questo caso, si dispone di 2 aggiunge e 1 confronto all'interno del ciclo (moltiplicato per 10 vi dà 20 o 30 FLOPS), più 1 moltiplicazione e 1 Oltre al di fuori del ciclo. Pertanto, il tuo programma impiega 22 o 32 FLOP a seconda che contiamo le comparazioni.