C/C++ Forum :: Konstanten/Quelltext-Werte Performance-Unterschied

tomax Mitglied 23:07:56 08.02.2010 Titel:

Hi,

ich lasse zwei Schleifen durchlaufen, in denen ich einmal mit einer
in den Quelltext geschriebenen "2" dividiere,
das zweite mal mit einer int-Konstanten mit dem Wert 2.
Die erste Variante mit der in den Quelltext geschriebenen "2"
ist jedoch 4mal schneller auf meinem Rechner.

Nur möchte ich gerne ohne Performance-Einbussen Konstanten an einer
zentralen Stelle definieren, beabsichtige also die zweite Schleife zu nutzen.
Nur wie bekomme ich die gleiche Performance wie in Schleife 1 hin ?

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	int main() { const int k = 2; int i, j; // viermal schneller als die zweite Schleife for(i = 0; i < 100000000; ++i) { j = i / 2; } // dauert 4mal so lang wie die erste Schleife for(i = 0; i < 100000000; ++i) { j = i / k; } }

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	int main() { const int k = 2; int i, j; // viermal schneller als die zweite Schleife for(i = 0; i < 100000000; ++i) { j = i / 2; } // dauert 4mal so lang wie die erste Schleife for(i = 0; i < 100000000; ++i) { j = i / k; } }

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	int main() { const int k = 2; int i, j; // viermal schneller als die zweite Schleife for(i = 0; i < 100000000; ++i) { j = i / 2; } // dauert 4mal so lang wie die erste Schleife for(i = 0; i < 100000000; ++i) { j = i / k; } }

volkard Moderator 23:12:58 08.02.2010 Titel:

Hast Du auch die Optimierungen angemacht?
Falls nein, mach das.
Falls ja, uih, da ist der Compiler aber blöd. Sowas behandle ich normalerweise damit, daß ich auf die nächste Version des Compilers warte.

Unregistrierter

Hey Thomas,

ich weiss nicht mit welchen Compiler du arbeitest, aber ich vermute einfach mal den GNC compiler (gcc). Du solltest die Optimierung erhoehen. Der gcc verwendet per Default (-O0) nahezu keine/bis keine Optimierung. Bei anderen Compilern werden andere Standardoptimierungen verwendet.

D.h. mit keiner Optimierung "erkennt" der Compiler die Konstante nicht und berechnet wahrscheinlich bei jedem Schleifendurchlauf die Division durch eine div-Assembleroperation, die recht teuer ist. Bei der Konstante hingegen kann der Compiler optimieren und stattdessen eine shift-left Operation verwenden, die viel guenstiger ist von der Laufzeit.

Wenn du jetzt eine hoehere Optimierung verwendest ... ich wuerde -O2 empfehlen ... erkennt der Compiler, dass k = 2 konstant ist und kann die Schleife entsprechend optimieren und auch eine shift-left anstatt div-Operation verwenden. D.h. du kannst deine Konstanten ohne Probleme an zentraler Stelle definieren.

Ich hoffe, das hilft dir weiter ...

- Andi -

tomax Mitglied 23:19:41 08.02.2010 Titel:

puh, nee, Compileroptimierung hab ich nicht gemacht, einfach mit gcc file.c (linux) kompiliert. Keine Ahnung, welche gcc-Option da wohl die richtige wäre, gibt ja da so einige, aber ich werde mal rumprobieren.

Bashar Mitglied 23:26:14 08.02.2010 Titel:

j und i sollte man evtl. noch volatile machen, sonst optimiert er die ganze Schleife und überhaupt alles weg

volkard Moderator 23:35:43 08.02.2010 Titel:

tomax schrieb:

puh, nee, Compileroptimierung hab ich nicht gemacht, einfach mit gcc file.c (linux) kompiliert. Keine Ahnung, welche gcc-Option da wohl die richtige wäre, gibt ja da so einige, aber ich werde mal rumprobieren.

Einfach -march=native -O3 und alles ist realistisch. Die Unterschiede zwichen Deinem Prozessor und den anderen sind erstaunlich gering.

tomax Mitglied 23:39:35 08.02.2010 Titel:

tatsächlich, "gcc -march=native -O3 file.c" funktioniert

Danke Euch !