PDA

Archiv verlassen und diese Seite im Standarddesign anzeigen : GCC: Optimierungsanweisungen im Code



i_hasser
20.10.2004, 23:11
Hi

Such eine Möglichkeit GCC für einen kleineren Codeabschnitt (notfalls gehts auch per Compilerflag) anzuweisen, dass er keinen Code wegoptimieren soll.

Läuft auf sowas hinaus:

i+=j;
i+=j;
i+=j;
i+=j;
i+=j;
i+=j;
i+=j;
i+=j;

Und da will ich auch immer schön ein ADD im Assembleroutput sehen. Dummerweise optimiert GCC das einfach weg :(.

i und j sind einfache ints, komischerweise geht es wenn ich stattdessen floats nehme... brauch das aber auch mit ints.

Hannnibal
21.10.2004, 00:29
Moin,

bringt es nichts das dierekt als asm code zu implemtieren?

mfg

i_hasser
21.10.2004, 00:41
Dann ist es x86 speziefisch, und das will ich tunlichst vermeiden.

Ray
21.10.2004, 15:22
Deklariere Deine Variablen mit volatile, dann darf der Compiler das nicht wegoptimieren.

Alternativ kannst Du versuchen, mit (volatile type) zu casten, wobei Du das Increment ausschreiben mußt:


int i, j;
...
(volatile int) i = (volatile int)(i+j);
...

Oder so ähnlich.

Ciao,
Ray

i_hasser
21.10.2004, 15:34
Original geschrieben von Ray
Deklariere Deine Variablen mit volatile, dann darf der Compiler das nicht wegoptimieren.

Alternativ kannst Du versuchen, mit (volatile type) zu casten, wobei Du das Increment ausschreiben mußt:


int i, j;
...
(volatile int) i = (volatile int)(i+j);
...

Oder so ähnlich.

Ciao,
Ray

Also wenn es das ist wofür ich es halte...


DANKE!


Dummerweise hab ich jetzt schon ca. 4 Stunden mit dem Zeug zugebracht :(

i_hasser
21.10.2004, 15:36
Hab mal etwas getestet, ist genau das was ich gesucht hab. Also danke nochmal!

i_hasser
22.10.2004, 00:05
*grummel*

Also manchmal könnt ich gcc wirklich treten.

Jetzt gehts um sowas:

int a;
a=a+7
a=a+6

Die Sache ist etwas delikat. Einerseits sollen beide Additionen nacheinander durchgeführt werden. Das macht er auch schön wenn ich a als volatile int deklariere.

Andererseits soll a zwischen den Additionen aber nicht wieder zurückgeschrieben werden.

Also von der Sache her brauch ich ein a=a+7+6; ohne, dass er das +7 und +6 zusammenfasst. Ich hab vor die 6 und die 7 mal volatile geschrieben, ohne Ergebnis (hats trotzdem zu +13 zusammengefasst).

Dann hab ich das in Klammern gesetzt - auch nix. volatile vor Konstanten oder Berechnungsausdrücken scheint ihn nicht zu interessieren.

Die einzige Möglichkeit die mir so spontan einfallen würde wäre volatile register int a; ... aber das schmeckt ihm auch nicht. Da macht der wieder das draus:



00000000 <main>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 08 sub $0x8,%esp
6: 8b 55 fc mov 0xfffffffc(%ebp),%edx
9: 83 c2 06 add $0x6,%edx
c: 89 55 fc mov %edx,0xfffffffc(%ebp)
f: 8b 55 fc mov 0xfffffffc(%ebp),%edx
12: 83 c2 07 add $0x7,%edx
15: 89 55 fc mov %edx,0xfffffffc(%ebp)
18: 83 e4 f0 and $0xfffffff0,%esp
1b: 89 ec mov %ebp,%esp
1d: 31 c0 xor %eax,%eax
1f: 5d pop %ebp
20: c3 ret


Ich will da ein einwandfreies 'add $0x6, %edx \n add $0x7, %edx' stehen haben :-/

Ray
22.10.2004, 20:32
volatile register int a; ist Quatsch, das ist wie fahren und bremsen gleichzeitig.

volatile veranlasst den Compiler, bei jedem Zugriff die Variable zu benützen. D.h. er kann gar nicht anders, als immer zurückschreiben.

Und was ist mit:


int a;
a = (int)(volatile int) (a+7); // Um den Ausdruck allein zu betrachten
a = (int)(a+6); // Um a im Register zu halten

oder


int a;
a = (int) ((volatile int)(a)+7); // Um den Ausdruck allein zu betrachten
a = (int)(a+6); // Um a im Register zu halten

Aber warum brauchts das denn überhaupt?

i_hasser
22.10.2004, 20:44
Es soll ja auch sein wie fahren und bremsen gleichzeitig ;).

Geht um AMBiX, inzwischen hab ich das aber glücklicherweise etwas anders hingekommen.

Ray
22.10.2004, 20:47
Das es um AMBiX geht, war schon klar. ;)
Und wie ist nun die Lösung?

Oh, Freitag, kurz vor 21 Uhr und immer noch auf Arbeit. Mal wieder typisch. Muß jetzt Feierabend machen...

i_hasser
22.10.2004, 22:50
Ich hab das ganze etwas anders und vor allem mit nicht-konstanten Werten gemacht. Also es ist nach wie vor der Form x=x+y+z, aber eben mit Variablen. Dafür hab ich eben die Zugriffe auf selbige inkauf genommen (sind arrayvariablen, also da kann er nix vorhersagen), hat den Bench zwar etwas verändert praktisch hat er so aber fast mehr Wert.