Warum ist der flüchtigen brauchte, in C?

Volatile weist den compiler nicht optimieren, was zu tun hat mit dem volatile-variable.

Gibt es nur einen Grund, es zu verwenden: Wenn Sie die Schnittstelle mit hardware.

Lassen Sie uns sagen, Sie haben ein kleines Stück hardware zugeordnet ist, in den RAM-Speicher irgendwo, und das hat zwei Adressen: eine Kommando-port und data-port:

typedef struct
{
  int command;
  int data;
  int isbusy;
} MyHardwareGadget;

Nun wollen Sie senden Befehl:

void SendCommand (MyHardwareGadget * gadget, int command, int data)
{
  //wait while the gadget is busy:
  while (gadget->isbusy)
  {
    //do nothing here.
  }
  //set data first:
  gadget->data    = data;
  //writing the command starts the action:
  gadget->command = command;
}

Sieht einfach, aber es kann fehlschlagen, weil der compiler ist frei, um die Reihenfolge zu ändern, in der Daten und Befehle geschrieben werden. Dies würde dazu führen, dass unsere kleine gadget, um Befehle mit den vorherigen Daten-Wert. Werfen Sie auch einen Blick auf das warten, während die busy-loop. Dass man optimiert. Der compiler wird versuchen, schlau zu sein, lies den Wert aus isbusy nur einmal und dann in einer endlos-Schleife. Das ist nicht, was Sie wollen.

Dem Weg, dies zu umgehen, ist zu erklären, dass die Zeiger gadget als flüchtig. Auf diese Weise wird der compiler gezwungen, das zu tun, was Sie schrieb. Sie können nicht entfernen Sie die Speicher-Zuweisungen, kann es nicht-cache-Variablen in Registern und Sie können nicht ändern die Reihenfolge der Aufgaben entweder:

Dies ist die richtige version:

   void SendCommand (volatile MyHardwareGadget * gadget, int command, int data)
    {
      //wait while the gadget is busy:
      while (gadget->isbusy)
      {
        //do nothing here.
      }
      //set data first:
      gadget->data    = data;
      //writing the command starts the action:
      gadget->command = command;
    }

InformationsquelleAutor Nils Pipenbrinck

Andere Verwendung für volatile ist signal-Handler. Wenn Sie code wie diesen:

quit = 0;
while (!quit)
{
    /* very small loop which is completely visible to the compiler */
}

Ist der compiler erlaubt zu bemerken die Schleife Körper nicht berühren quit Variablen und konvertieren Sie die Schleife, um eine while (true) Schleife. Auch wenn die quit variable auf die signal-handler für SIGINT und SIGTERM; der compiler hat keine Möglichkeit zu wissen, dass.

Jedoch, wenn die quit variable deklariert ist volatile der compiler gezwungen ist, laden Sie es jedes mal, weil es geändert werden kann anderswo. Das ist genau das, was Sie wollen in dieser situation.

InformationsquelleAutor CesarB

Finden Sie in diesem Artikel von Andrei Alexandrescu, "volatile - Multithread-Programmer ' s Best Friend"

volatile - Schlüsselwort wurde
entwickelt, um zu verhindern, dass compiler
Optimierungen, die machen könnte-code
falsch in der Gegenwart von bestimmten
asynchrone Ereignisse. Zum Beispiel, wenn
deklarieren Sie eine primitive variable als
volatile, der compiler ist nicht
gestattet cache ist es in einem register --
eine gemeinsame Optimierung ist, dass wäre
Fatal, wenn diese variable wurden
die gemeinsam von mehreren threads. Also die
die Allgemeine Regel ist, wenn Sie die Variablen haben
der primitive Typ, die geteilt werden muss
unter mehreren threads, erklären diese
Variablen volatile. Aber Sie können
eigentlich viel mehr mit diesem
keyword: Sie können es verwenden, um catch-code
das ist nicht thread-safe, und Sie können
tun, also zur compile-Zeit. Dieser Artikel
zeigt, wie es gemacht ist; die Lösung
um einen einfachen smart-pointer,
macht es auch leicht zu serialisieren
kritische code-Abschnitte.

Den Artikel gilt für beide C und C++.

Siehe auch den Artikel "C++ und die Tücken des Double-Checked Locking" von Scott Meyers und Andrei Alexandrescu:

Also, wenn der Umgang mit einige Speicherplätze (z.B. memory-mapped ports oder memory referenced von ISRs [ Interrupt-Service-Routinen ] ), einige Optimierungen müssen ausgesetzt werden. flüchtige vorhanden ist für die Angabe spezieller Behandlung für solche Standorte, insbesondere: (1) der Inhalt einer volatile-variable ist "instabil" (kann sich ändern durch unbekannt für den compiler), (2) alle schreibt, um flüchtige Daten "beobachten", damit Sie ausgeführt werden müssen, religiös, und (3) alle Vorgänge, die auf flüchtige Daten ausgeführt werden, in der Reihenfolge, in der Sie im Quellcode angezeigt werden. Die ersten beiden Regeln gewährleisten, dass die richtigen Lesen und schreiben. Die Letzte ermöglicht die Realisierung von I/O-Protokolle, mix-Eingang und-Ausgang. Dies ist informell, was C und C++'s volatile garantiert.

InformationsquelleAutor Robert S. Barnes

Einen marginalen nutzen für volatile ist die folgende. Angenommen, Sie möchten berechnen Sie die numerische Ableitung einer Funktion f :

double der_f(double x)
{
    static const double h = 1e-3;
    return (f(x + h) - f(x)) / h;
}

Das problem ist, dass x+h-x ist in der Regel nicht gleich h aufgrund roundoff Fehler. Denken Sie daran : wenn Sie zieht sehr nah zahlen, verlieren Sie eine Menge von signifikanten stellen, die ruinieren kann die Berechnung der Ableitung (denke 1.00001 - 1). Ein möglicher workaround könnte sein

double der_f2(double x)
{
    static const double h = 1e-3;
    double hh = x + h - x;
    return (f(x + hh) - f(x)) / hh;
}

aber je nach Plattform-und compiler-Schalter, die zweite Zeile der Funktion kann ausgelöscht werden durch ein aggressiv optimierender compiler. So schreiben Sie statt

    volatile double hh = x + h;
    hh -= x;

um den compiler zu zwingen Lesen Sie die memory location mit hh, der Verzicht auf eine eventuelle Optimierungs-Möglichkeit.

InformationsquelleAutor Alexandre C.

Flüchtige ist auch nützlich, wenn Sie erzwingen möchten, dass der compiler nicht optimieren, eine bestimmte code-Sequenz (z.B. für das schreiben eines micro-benchmark).

InformationsquelleAutor Diomidis Spinellis

volatile bedeutet, dass der Speicher wird sich wahrscheinlich ändern, und jederzeit geändert werden, aber etwas außerhalb der Kontrolle des anwenderprogramms. Dies bedeutet, dass, wenn Sie auf die variable verweisen, sollte das Programm immer überprüfen Sie die physische Adresse (also einem zugeordneten Eingabe-fifo), und nicht in einem Cache Weg.

InformationsquelleAutor Structure padding

Meiner Meinung nach, sollte man nicht zu viel erwarten von volatile. Um dies zu verdeutlichen, betrachten Sie das Beispiel in Nils Pipenbrinck hoch-stimmten Antwort.

Ich würde sagen, sein Beispiel ist nicht geeignet für volatile. volatile wird nur verwendet, um:
verhindern, dass der compiler von nützlichen und wünschenswerten Optimierungen. Es ist nichts über die thread-sichere, atomic access oder auch Speicher um.

In diesem Beispiel:

    void SendCommand (volatile MyHardwareGadget * gadget, int command, int data)
    {
      //wait while the gadget is busy:
      while (gadget->isbusy)
      {
        //do nothing here.
      }
      //set data first:
      gadget->data    = data;
      //writing the command starts the action:
      gadget->command = command;
    }

den gadget->data = data vor gadget->command = command nur ist nur gewährleistet, in kompilierter code, der vom compiler. Zur Zeit läuft der Prozessor noch eventuell verschiebt die Daten-und Befehls-Zuordnung, in Bezug auf die Prozessor-Architektur. Die hardware kann mit den falschen Daten(nehme gadget zugeordnet ist, die hardware-I/O). Die memory-Barriere muss zwischen Daten-und Befehls-Zuordnung.

InformationsquelleAutor Oliver

In der Sprache, entwickelt von Dennis Ritchie, jeden Zugriff auf jedes Objekt, andere als die automatische Objekte, deren Adresse nicht getroffen worden, würden die sich Verhalten, als wenn es berechnet die Adresse des Objekts, und dann gelesen oder geschrieben der Speicher an dieser Adresse. Dies machte die Sprache sehr mächtig, aber stark eingeschränkt Möglichkeiten zur Optimierung.

Während es vielleicht möglich gewesen, fügen Sie ein qualifier, die einladen würde zu einem compiler davon ausgehen, dass ein bestimmtes Objekt würde nicht geändert werden, in seltsame Wege, eine solche Annahme wäre für die überwiegende Mehrheit der Objekte in C-Programme, und es wäre unpraktisch, fügen Sie ein qualifier für alle Objekte, für die eine solche Annahme wäre angebracht. Auf der anderen Seite, einige Programme verwenden müssen einige Objekte, für die eine solche Annahme würde nicht halten. Um dieses Problem zu beheben, der Standard sagt, dass der Compiler kann davon ausgehen, dass Objekte, die nicht deklariert volatile wird nicht Ihren Wert beobachtet oder verändert in einer Weise, die außerhalb der compiler die Kontrolle, oder wäre außerhalb einer vernünftigen compiler Verständnis.

Weil verschiedene Plattformen haben verschiedene Möglichkeiten, in denen die Objekte beobachtet werden oder geändert werden, die außerhalb eines compiler-Steuerung, es ist angemessen, die Qualität Compiler für diese Plattformen sollten sich in Ihrer genauen Umgang mit volatile Semantik. Leider, weil der Standard konnte nicht schlagen, die Qualität Compiler soll für low-level-Programmierung auf einer Plattform behandeln soll volatile in einer Weise, die erkennen und alle relevanten Auswirkungen einer bestimmten lese - /schreib-operation auf dieser Plattform, viele Compiler zu kurz, dies zu tun in einer Weise, die machen es schwieriger, Dinge zu verarbeiten wie hintergrund I/O in einer Weise, die effizient ist, aber nicht gebrochen werden können durch compiler - "Optimierungen".

InformationsquelleAutor supercat

ist es nicht erlaubt-compiler zur automatischen ändern der Werte von Variablen. eine volatile-variable ist für den dynamischen Einsatz.

InformationsquelleAutor venu