GCC: Optimierungsanweisungen im Code

[i_hasser]

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]

Moin,

bringt es nichts das dierekt als asm code zu implemtieren?

mfg

 

[i_hasser]

Dann ist es x86 speziefisch, und das will ich tunlichst vermeiden.

 

[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

 

[i_hasser]

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]

Hab mal etwas getestet, ist genau das was ich gesucht hab. Also danke nochmal!

 

[i_hasser]

*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
[color=red]   c:   89 55 fc                mov    %edx,0xfffffffc(%ebp)
   f:   8b 55 fc                mov    0xfffffffc(%ebp),%edx[/color]
  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]

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]

Es soll ja auch sein wie fahren und bremsen gleichzeitig .

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

 

[Ray]

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]

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.