STM32 Profiling: Barriere gegen Optimierung?

[Walter T. (nicolas)]

Hallo zusammen,

ich will auf meinem Cortex M4 bei einer Hand von Funktionen untersuchen, 
ob sich eine Optimierung lohnt. Dafür würde ich den Zyklen-Zähler 
verwenden. Jetzt stellt sich die Frage: Wie verhindere ich, dass der 
Compiler den Inhalt der Funktion vor oder hinter das Auslesen des 
Zyklenzählers verschiebt. Beispiel:

volatile struct
{
    int32_t max;
    int32_t min;
}
Cycles = {.max = 0, .min = INT32_MAX};

void foo()
{
    int64_t a = rand(), int64_t b = rand();

    volatile uint32_t startcyc = *DWT_CYCCNT;

    volatile int32_t c = a/b;

    volatile uint32_t stopcyc = *DWT_CYCCNT;
    int32_t cycles = (int32_t) (stopcyc - startcyc);
    Cycles.max = MAX( Cycles.max, cycles );
    Cycles.min = MIN( Cycles.min, cycles );
}


void bar()
{
    int64_t a = rand(), int64_t b = rand();

    volatile uint32_t startcyc = *DWT_CYCCNT;

    volatile int32_t c = functionOfInterest(a, b);

    volatile uint32_t stopcyc = *DWT_CYCCNT;
    int32_t cycles = (int32_t) (stopcyc - startcyc);
    Cycles.max = MAX( Cycles.max, cycles );
    Cycles.min = MIN( Cycles.min, cycles );
}

Bei foo() hat ja der Compiler jedes Recht, die Division vor das Auslesen 
des Zyklen-Zählers zu verlegen. Er muß ja nur die Zuweisung zu c 
dazwischenpacken. Gibt es eine Möglichkeit, solche Optimierungen zu 
verhindern, oder hilft hier nur Hoffen und das Lesen des 
Assembler-Listing?

Wie sieht es bei der zweiten Variante aus? Muß da der Funktionsaufruf 
zwischen den beiden volatile-Zugriffen erfolgen?

[leo (Gast)]

Walter T. schrieb:
> Wie verhindere ich, dass der
> Compiler den Inhalt der Funktion vor oder hinter das Auslesen des
> Zyklenzählers verschiebt.

Stichwort: gcc memory barrier

leo

[Nop (Gast)]

Walter T. schrieb:
> Gibt es eine Möglichkeit, solche Optimierungen zu
> verhindern

Nimm einfach so eine Compiler-Barrier jeweils vor und nach Deiner zu 
messenden Funtion:

#define CMPBAR __asm__ volatile("" : : : "memory")

[Walter T. (nicolas)]

Danke, das war das Stichwort, das ich gesucht hatte.

[arm (Gast)]

Nop schrieb:
> Walter T. schrieb:
>> Gibt es eine Möglichkeit, solche Optimierungen zu
>> verhindern
>
> Nimm einfach so eine Compiler-Barrier jeweils vor und nach Deiner zu
> messenden Funtion:
>
>

#define CMPBAR __asm__ volatile("" : : : "memory")

dafür stellt arm doch _DMB() im CMSIS bereit.

[Nop (Gast)]

arm schrieb:

> dafür stellt arm doch _DMB() im CMSIS bereit.

Das macht noch mehr, weil es nicht nur eine Compiler-Barriere darstellt, 
sondern auch einen CPU-Befehl rauswirft. Die Frage war aber nach 
Umsortierung durch den Compiler.