sehr Kurze Warteschleifen für das korrekte Timing

[Siro]

@Klebwax:
Das Problem Optimierung ist mir schon recht oft zum Verhängnis geworden.
Genau in solchen Situationen wie Du eben beschrieben hast.
Habe immer öfter bemerkt, dass ein "volatile" unumgänglich ist, damit der "schlaue" Compiler es auch "richtig" versteht.
Am Anfang hab ich immer gemerkert warum der Compiler meinen Code klaut,
Er hat ja recht würd ich aus heutiger Sicht sagen, woher soll er wissen dass......


Ich hab grad noch etwas rumprobiert und da stellt sich gleich noch eine Frage:

Zuvor der Code, der schien zu laufen.....
Beim Timerüberlauf stimmt aber die Berechnung nicht mehr. Doch dazu später....

/*--------------------------------------------------------------------------*/
/* static volatile U16 t_old; */

inline void wait_us(U16 us)
{ U16 t_old;

  t_old = TIMER1_TC;
  while ((TIMER1_TC - t_old) < us) ;
}
/*--------------------------------------------------------------------------*/

Nun zur Frage:

Ich habe das Schlüsselwort "inline" benutzt, damit darf der Compiler den Code ja direkt einsetzen ohne einen Call.
Ob er das macht bleibt glaube ich ihm überlassen.
Damit ich meine Funktion evtl. sogar aus verschiedenen threads bzw. Interrupts aufrufen könnte, müsste mein Variable t_old ja Dynmsich auf dem Stack liegen, also Lokal zum Funktionsaufruf.
Aber wie funktioniert das mit dem Inline, ist das überhaupt erlaubt ? Inline und lokale Variable ?

Der Compiler könnte den Call nun sparen aber was macht er mit der Variable t_old ? die müste er ja dynamsich auf dem Stack verwalten.
Wenn es um Geschwindigkeit geht und ich nur aus einem Thread die Funktion aufrufe, kann ich die Variable ja Global anlegen,
ich vermute hier wird er den besten Code dafür erzeugen können.

[Siro]

Warum meine Berechnung nach Timerüberlauf nicht mehr funktioniert, habe ich unn auch ermittelt.


while (TIMER1_TC - t_old < us) ; /* geht nicht */

/* Also "komplette" explizite Typwandlung auf allen Werten und Ergebnissen angewendet: */

while ((U16)((U16)(TIMER1_TC) - (U16)(t_old)) < us) ; /* siehe da, es funktioniert */

/* nun Typwandlungen gekürzt */

while ((U16)(TIMER1_TC - t_old) < us) ; /* auch OKAY */


Durch die Integer Promotion des Standard Typs int bei 32 Bit muss hier anscheinend das Ergebnis der Subtraktion
explizit wieder in einen unsigned 16 Bit gewandelt werden, sonst geht es schief, jedoch nur manchmal, je nach Timerstand.

Ich bin begeistert und kann nun das Wochenende geniessen...
Habt auch ein schönes, warmes WE.

Siro

[Peter(TOO)]

Hallo Siro,

Ich habe das Schlüsselwort "inline" benutzt, damit darf der Compiler den Code ja direkt einsetzen ohne einen Call.
Ob er das macht bleibt glaube ich ihm überlassen.

Genau so ist es.

Damit ich meine Funktion evtl. sogar aus verschiedenen threads bzw. Interrupts aufrufen könnte, müsste mein Variable t_old ja Dynmsich auf dem Stack liegen, also Lokal zum Funktionsaufruf.
Aber wie funktioniert das mit dem Inline, ist das überhaupt erlaubt ? Inline und lokale Variable ?

Man kann in jedem Block heute eine lokale Variable festlegen, OK, bei K&R war das noch nicht erlaubt.

void function(void)
  {
      int i;
      // mach was mit i
        {
            int i2;
            // mach was mit i und i2
        }
      // ab hier gibt es i2 nicht mehr
      // mach noch was mit i
  }

Der Compiler könnte den Call nun sparen aber was macht er mit der Variable t_old ? die müste er ja dynamsich auf dem Stack verwalten.
Wenn es um Geschwindigkeit geht und ich nur aus einem Thread die Funktion aufrufe, kann ich die Variable ja Global anlegen,
ich vermute hier wird er den besten Code dafür erzeugen können.

Vermutlich wird der Compiler die einzelne Variable gar nicht auf dem Stack ablegen, sondern in einem Register behalten.
Kommt aber auf die CPU und den restlichen Code an.

Es gibt noch das Keyword register, damit konnte man dem Compiler nahelegen, welche Variablen, wenn möglich, in einem Register abgelegt werden sollen. Das war so eine "per Hand" Optimierung. Heute hat register keinen praktischen Wert mehr, der Compiler optimiert dies automatisch.

MfG Peter(TOO)

[Siro]

Guten Morgen und Danke Peter.

Nanu, da bin ich jetzt echt erstaunt, mit den "Block Lokalen" Variablen.
Das ist mir völlig neu... Ist das Ansi/C99 konform ?
Muss ich mal probieren, der Compiler müsste ja dann bei einem Verstoß meckern.

Ich denke auch, bei solchen Ein/Zweizeilern wird der Compiler das automatisch in den Registern halten.

Siro

[HaWe]

ja, das mit den Blockvariablen ist 100% ANSI C99.

Der C-Compiler wird die Variablen aber nur in den exe-Code übernehmen, wenn du mit ihren Werten auch irgendetwas machst (z.B. printf() Ausgabe). Wenn du nur rechnest, ohne mit den Ergebnissen was zu machen, fliegen sie komplett raus beim Kompilieren.
Nur das Zauberwörtchen
volatile
vor der Variablendefinition kann dich vor dieser Optimierung (egal welches Optimierungs-Level) schützen, also wundere dich nicht, wenn du sie eventuell nicht im exe-Code wiederfindest!