was muss als volatile definiert werden?

[Micha (Gast)]

wenn ich in einer ISR z.B. sowas hier hab:

buffer[pointer++] = UDR0;

dann ist mir klar dass die Variable "pointer" als volatile definiert 
werden muss, wenn ich diese von ausserhalb anzapfen möchte, was 
normalerweise der Fall ist.

Nicht klar ist mir, ob das array "buffer" auch als volatile definiert 
werden muss oder nicht. Ich vermute mal nicht, da es ja nur einen 
Speicherbereich reserviert, bin mir aber nicht ganz sicher - bleiben 
Schreibzugriffe in die Plätze des Arrays womöglich auch in Registern 
hängen wenn man es nicht als volatile definiert, oder ist das Unsinn?

[Karl H. (kbuchegg)]

Micha schrieb:

> Nicht klar ist mir, ob das array "buffer" auch als volatile definiert
> werden muss oder nicht.

Kommt drauf an, wie es auf 'der anderen Seite' benutzt wird. Aber im 
Prinzip muss das genauso volatile gemacht werden.

> Ich vermute mal nicht, da es ja nur einen
> Speicherbereich reserviert

und eine Variable reserviert keinen Speicherbereich?

FAQ: Was hat es mit volatile auf sich

[Micha (Gast)]

Karl Heinz schrieb:
> FAQ: Was hat es mit volatile auf sich

Schwääre Kost. Wenn ich mal versuch den impliziten Teil deiner Aussage 
zu deuten ist es ne gute Idee im Zweifelsfall alles was irgendwie in 
einer ISR vorkommt als volatile zu definieren?
Wär für mich gut genug da ich eh kein Freund der totalen Optimierung 
bin.

[Karl H. (kbuchegg)]

Micha schrieb:
> Karl Heinz schrieb:
>> FAQ: Was hat es mit volatile auf sich
>
> Schwääre Kost.

Nicht wirklich.

Sieh dir dein hauptprogramm an.

Wenn da zb steht

   while( buffer[0] == 'a' )
     ;

dann gibt es keinen Grund für den Compiler, jedes mal neu den Inhalt von 
buffer[0] aus dem Speicher zu holen. Warum sollte er? Innerhalb der 
Schleife kann sich der Wert nicht ändern. Die Schleife wird, aus Sicht 
des Compilers also überhaupt nicht betreten (wenn buffer[0] nicht vorher 
schon 'a' war) bzw. sie ist eine Endlosschleife (weil buffer[0] sich ja 
aus SIcht des Compilers nicht ändern kann). Ergo wird der Compiler im 
Übereifer dir etwas gutes zu tun, eine falsche Optimierung vornehmen.


> Wenn ich mal versuch den impliziten Teil deiner Aussage
> zu deuten ist es ne gute Idee im Zweifelsfall alles was irgendwie in
> einer ISR vorkommt als volatile zu definieren?

Besser wäre es, wenn man versteht was man da macht und wann einem die 
Technik einen nicht gewollten Streich spielen kann.

[Kurzschluss (Gast)]

Micha schrieb:
> buffer[pointer++] = UDR0;

Kleine Anmerkung am Rande: der Name pointer ist für diese Variable sehr 
ungeschickt gewählt, weil diese Variable eben kein Pointer ist.
Etwas mit Index im Namen würde hier besser passen :)

[R. F. (rfr)]

Hallo,

buffer muss volatile werden, denn:

wenn von aussen der buffer beschrieben werden kann, ändern sich dessen 
Inhalte, und dann muss neu gelesen werden. Der buffer muss also volatile 
werden.

Da stets per Zeiger gelesen wird, muss der pointer nicht volatisiert 
werden, denn er wird bei jedem Zugriff auf das Array verwendet.

[Peter II (Gast)]

R. Freitag schrieb:
> Da stets per Zeiger gelesen wird, muss der pointer nicht volatisiert
> werden, denn er wird bei jedem Zugriff auf das Array verwendet.

nein. Der Compiler kann genauso gut auch den zugriff auf der Pointer 
wegoptimieren.