Was gilt als Flop?

Question

sagen, ich habe ein C-Programm, dass in pseudoish ist:

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

Ist die Zahl der FLOPS für diesen (1 [x ++] + 1 [x * 5] + 1 [2 + (x + 5))] * 10 [loop], 30 FLOPS? Ich habe Probleme zu verstehen, was ein Flop ist.

Beachten Sie die [...] sind die anzeigt, wo ich meine Zählungen bin immer für „Operationen“ aus.

Answer 1

Für die Zwecke der Messungen FLOP, in der Regel nur Additionen und Multiplikationen sind enthalten. Dinge wie Divisionen, reziproke, Quadratwurzeln und transzendente Funktionen sind zu teuer als eine einzelne Operation zu schließen, während Dinge wie Lade- und Speichervorgänge zu trivial sind.

Mit anderen Worten, die Schleife Körper enthält 2 addiert und 1 multiplizieren, um (unter der Annahme x ist Gleitkomma) jede Schleifeniteration 3 ops ist; wenn Sie die Schleife 10 Mal ausgeführt haben Sie 30 ops getan.

Beachten Sie, dass bei MIPS Messung der Schleife wäre mehr als 3 Anweisungen, weil es auch Lade- und Speichervorgänge beinhaltet, dass die Messung FLOPS zählt nicht.

Answer 2

FLOPS steht für Operationen pro Sekunde schwimmen. Wenn Sie mit ganzen Zahlen zu tun, dann haben Sie keine Gleitkommaoperationen in Ihrem Code.

Answer 3

Die Plakate haben deutlich gemacht, dass FLOPS (detaillierte hier ) befassen sich mit Gleitkomma (im Gegensatz zu integer) Operationen pro Sekunde , damit Sie nicht nur zählen müssen, wie viele Operationen Sie ausführen, aber in welchem ??Zeitraum.

Wenn „x“ und „a“ schwebt, Sie macht einen guten Versuch, die Anzahl der Operationen in Ihrem Code zu zählen, aber man müßte den Objektcode überprüfen, um sicherzustellen, was Menge Gleitkommaanweisungen tatsächlich verwendet werden. Zum Beispiel, wenn „a“ ein optimierende Compiler es nicht anschließend verwendet, um nicht zu berechnen, könnte stören.

Auch einige Floating-Operationen (wie das Hinzufügen) könnte viel schneller sein als andere (wie Multiplikation), so dass eine Schleife von nur Schwimmer fügt als eine Schleife von nur Schwimmer vervielfacht auf der gleichen Maschine FLOPS an vielen mehr laufen konnte.

Answer 4

FLOPS (der Klein s gibt den Plural von FLOP, pro Martinho Fernandes Kommentar) bezieht sich auf Maschinensprache Gleitkommaanweisungen, so hängt es, wie viele Anweisungen, um Ihren Code compiliert bis auf.

Zunächst einmal, wenn alle diese Variablen ganze Zahlen sind, dann gibt es keine flops in diesem Code. Nehmen wir an, Sie jedoch, dass Ihre Sprache alle diese Konstanten und Variablen als einfacher Genauigkeit Punktvariablen Floating erkennt (mit einfacher Genauigkeit macht die Konstanten Laden einfacher).

Dieser Code könnte kompilieren (für 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

So nach Gabes Definition gibt es 4 flops innerhalb der Schleife (3x add.s und 1x mul.s). Es gibt 5 flops, wenn Sie auch die Schleife Vergleich c.gt.s zählen. Multipliziert mit 10 für eine Gesamtmenge von 40 (oder 50) flops von dem Programm verwendet.

Eine bessere Optimierung der Compiler erkennen könnte, dass der Wert von a nicht innerhalb der Schleife verwendet wird, so dass er nur den Endwert von a berechnen muss. Es könnte Code erzeugen, der aussieht wie

     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 diesem Fall haben Sie 2 addiert und 1 Vergleich innerhalb der Schleife (vervielfacht um 10 gibt Ihnen 20 oder 30 FLOPS), plus 1 Multiplikation und 1 zusätzlich außerhalb der Schleife. So jetzt Ihr Programm dauert 22 oder 32 FLOPS je nachdem, ob wir comparisions zählen.

Answer 5

X eine ganze Zahl oder eine Gleitkommavariable? Wenn es eine ganze Zahl ist, dann kann die Schleife nicht enthält jeden Flop.