Was ist schneller?



  • Ich hab 'ne Frage zur Codeoptimierung: Was ist schneller? Auch wenn nur minimal

    1. x << y oder x * (2*y)
    2. x >> y oder x / (2*y)
    3. x / 2 oder x * .5
    4. x /= y oder x= x/y
    5. a=1/b; x=a*x; y=a*y; oder x= x/b; y= y/b


  • alles uninteressant, da der compiler das alles wegoptimiert.



  • Multi schneller als Div
    BitShift schneller als Multi



  • Falsch



  • Grundsätzlich sollte man Multiplikation gegenüber Division bevorzugen. Verwende beim Rest das, was der Algorithmus auch aussagt. Der Compiler optimiert sowieso Multiplikation/Division zu Shifts, sofern das möglich ist.



  • zu 99% "optimierst" du hier sowieso an der falschen stelle



  • Den 2^y Fall optimiert der Compiler nur wenn y eine compile-time Konstante ist. Wenn y keine compile-time Konstante ist auf jeden Fall x << y schreiben.

    Das Beispiel (5) optimieren viele Compiler nicht selbst zu Multiplikationen, da das Ergebnis leicht anders ist als bei direkter Division (und damit nichtmehr mit dem zusammenstimmt was man laut IEEE Standard erwarten dürfte).

    (4) ist vollkommen egal solange es sich um eingebaute Typen handelt, und (3) wird wohl von vielen Compilern zu einer Multiplikation verwandelt werden, solange der Kehrwert der Konstante exakt als float/double abbildbar ist.

    Wenn du wissen willst was allgemein schnell/langsam ist, hier mal von schnell nach langsam sortiert:

    1. Addition, Subtraktion, Shiften, AND/OR/XOR
    2. Multiplikation
    3. Division, Modulo
    4. sin, cos, tan, exp, log, ...

    If Abfragen (bzw. allgemein bedingte Sprünge) können auch einiges an Zeit kosten, lässt sich aber nicht einfach abschätzen wieviel. Es KANN z.B. Sinn machen eine Multiplikation mehr zu haben wenn man dafür ein if spart, es KANN aber genausogut sein dass es mit dem if und einer Multiplikation weniger schneller ist.



  • Blaze schrieb:

    Ich hab 'ne Frage zur Codeoptimierung: Was ist schneller? Auch wenn nur minimal

    1. x << y oder x * (2*y)
    2. x >> y oder x / (2*y)

    Die beiden Codes sind nicht einmal äquivalent. Ansonsten hängt es wohl davon ab, mit was für Werten du arbeitest (bei double ist die Shift-Variante nicht möglich, bei konstantem y wird der Compiler das vermutlich rausoptimieren)

    1. x / 2 oder x * .5

    Das hängt davon ab, von welchen Typen wir reden - bei Gleitkommazahlen ist die zweite Variante eventuell besser, bei int's die erste.

    1. x /= y oder x= x/y

    Macht für Build-in Typen keinen wesentlichen Unterschied - bei selbsterzeugten Typen (mit überladenen Operatoren) sollte die erste Variante schneller sein.

    1. a=1/b; x=a*x; y=a*y; oder x= x/b; y= y/b

    Hier gilt das selbe wie bei 3 (btw, mit int-Werten liefert die erste Variante falsche Ergebnisse)


Log in to reply