Quello che conta come un flop?

Question

Di 'Ho un programma C che in pseudoish è:

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

È il numero di flops per questa (1 [x ++] + 1 [x * 5] + 1 [2+ (x + 5))] * 10 [loop], per il 30 CADUTE? Sto avendo difficoltà a capire ciò che un flop è.

Si noti il ??[...] stanno indicando dove sto ottenendo i miei conteggi per "operazioni" da.

Answer 1

Ai fini della misurazione flop, di solito solo addizioni e moltiplicazioni sono inclusi. Cose come divisioni, reciproci, radici quadrate, e le funzioni trascendentali sono troppo costosi per includere come una singola operazione, mentre le cose come i carichi e negozi sono troppo banale.

In altre parole, il corpo del ciclo contiene 2 aggiunge e 1 moltiplicano, così (supponendo x è virgola mobile) ogni iterazione del ciclo è 3 OP; se si esegue il ciclo 10 volte che hai fatto 30 ops.

Si noti che quando si misura MIPS, il ciclo sarebbe stato più di 3 istruzioni perché include anche carichi e negozi che il flop di misura non conta.

Answer 2

FLOPS sta per le operazioni di mobile al secondo. Se avete a che fare con i numeri interi, allora non avete operazioni in virgola mobile nel codice.

Answer 3

I manifesti hanno chiarito che CADUTE (dettagliato qui ) si occupano virgola mobile (al contrario di interi) le operazioni di al secondo , in modo non solo si ha a contare quante operazioni si sta eseguendo, ma in quale periodo di tempo.

Se "x" e "a" sono galleggianti, stai facendo un tentativo bravo a contare il numero di operazioni nel codice, ma che avrebbe dovuto controllare il codice oggetto per fare in modo che quantità di istruzioni in virgola mobile sono realmente utilizzati. Ad esempio, se "a" non venga utilizzato successivamente, un compilatore ottimizzato potrebbe non essere fastidio calcolarla.

Inoltre, alcune operazioni a virgola mobile (ad esempio l'aggiunta) potrebbe essere molto più veloce rispetto ad altri (ad esempio moltiplicando), quindi un ciclo di soli galleggiante aggiunge potrebbe andare a molti più flop di un ciclo di soli moltiplica galleggiante sulla stessa macchina.

Answer 4

FLOPS (la minuscola s indica il plurale di FLOP, per Martinho Fernandes commento) riferiamo al linguaggio macchina istruzioni in virgola mobile, quindi dipende quante istruzioni tuoi compila codice fino a.

Prima di tutto, se tutte queste variabili sono interi, allora non ci sono FLOPS in questo codice. Supponiamo, tuttavia, che la lingua riconosca tutte queste costanti e variabili come variabili di punti in singola precisione floating (con singola precisione rende il caricamento delle costanti più facile).

Questo codice potrebbe compilare in (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 FLOPS se anche si conta il c.gt.s ciclo confronto. Moltiplicare questo da 10 per un totale di 40 (o 50) flop utilizzato dal programma.

Un compilatore migliore ottimizzazione può riconoscere che il valore di a non viene utilizzato all'interno del ciclo, quindi ha bisogno solo di calcolare il valore finale di a. Si potrebbe generare il codice che appare come

     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 ha 2 aggiunge e 1 confronto all'interno del ciclo (moltiplicato per 10 offre 20 o 30 FLOPS), più 1 moltiplicazione e addizione 1 all'esterno del ciclo. Così, il vostro programma richiede ora 22 o 32 FLOPS a seconda se contiamo comparazioni.

Answer 5

è x un numero intero o una variabile in virgola mobile? Se si tratta di un intero, allora il ciclo non può contenere flop.