Warum wird flüchtig in der Multithread-C- oder C ++ - Programmierung nicht als nützlich angesehen?

Wie in dieser Antwort, die ich kürzlich gepostet habe, gezeigt wurde, bin ich verwirrt über den Nutzen (oder das Fehlen davon) volatilein Multithread-Programmierkontexten.

Mein Verständnis ist folgendes: Jedes Mal, wenn eine Variable außerhalb des Kontrollflusses eines Codes, der darauf zugreift, geändert werden kann, sollte diese Variable als solche deklariert werden volatile. Signalhandler, E / A-Register und Variablen, die von einem anderen Thread geändert wurden, bilden solche Situationen.

Wenn Sie also ein globales int foohaben und foovon einem Thread gelesen und von einem anderen Thread atomar gesetzt werden (wahrscheinlich unter Verwendung einer geeigneten Maschinenanweisung), sieht der lesende Thread diese Situation genauso wie eine Variable, die von einem Signalhandler oder optimiert wurde geändert durch eine externe Hardwarebedingung und foosollte daher deklariert werden volatile(oder für Multithread-Situationen mit speicherbegrenzter Last zugegriffen werden, was wahrscheinlich eine bessere Lösung ist).

Wie und wo irre ich mich?

Das Problem volatilein einem Multithread-Kontext ist, dass es nicht alle Garantien bietet, die wir brauchen. Es hat einige Eigenschaften, die wir brauchen, aber nicht alle, also können wir uns nicht volatile alleine verlassen .

Die Grundelemente, die wir für die verbleibenden Eigenschaften verwenden müssten, bieten jedoch auch diejenigen, die volatiledies tun, sodass dies praktisch nicht erforderlich ist.

Für threadsichere Zugriffe auf gemeinsam genutzte Daten benötigen wir eine Garantie, dass:

• Das Lesen / Schreiben geschieht tatsächlich (der Compiler speichert den Wert stattdessen nicht nur in einem Register und verschiebt die Aktualisierung des Hauptspeichers bis viel später).
• dass keine Nachbestellung stattfindet. Angenommen, wir verwenden eine volatileVariable als Flag, um anzugeben, ob einige Daten zum Lesen bereit sind oder nicht. In unserem Code setzen wir einfach das Flag, nachdem wir die Daten vorbereitet haben, damit alles gut aussieht . Aber was ist, wenn die Anweisungen neu angeordnet werden, sodass das Flag zuerst gesetzt wird ?

volatilegarantiert den ersten Punkt. Es garantiert auch, dass keine Neuordnung zwischen verschiedenen flüchtigen Lese- / Schreibvorgängen erfolgt . Alle volatileSpeicherzugriffe erfolgen in der angegebenen Reihenfolge. Das ist alles, was wir für das benötigen, wofür volatilevorgesehen ist: das Manipulieren von E / A-Registern oder speicherabgebildeter Hardware, aber es hilft uns nicht bei Multithread-Code, bei dem das volatileObjekt häufig nur zum Synchronisieren des Zugriffs auf nichtflüchtige Daten verwendet wird. Diese Zugriffe können weiterhin relativ zu volatiledenen neu angeordnet werden.

Die Lösung zur Verhinderung einer Neuordnung besteht in der Verwendung einer Speicherbarriere , die sowohl dem Compiler als auch der CPU anzeigt, dass über diesen Punkt kein Speicherzugriff neu angeordnet werden darf . Durch das Platzieren solcher Barrieren um unseren Zugriff auf flüchtige Variablen wird sichergestellt, dass selbst nichtflüchtige Zugriffe nicht über den flüchtigen Zugriff hinweg neu angeordnet werden, sodass wir threadsicheren Code schreiben können.

Speicherbarrieren stellen jedoch auch sicher, dass alle ausstehenden Lese- / Schreibvorgänge ausgeführt werden, wenn die Barriere erreicht ist, sodass wir effektiv alles haben, was wir selbst benötigen, was volatileunnötig wird. Wir können das volatileQualifikationsmerkmal einfach vollständig entfernen .

Seit C ++ 11 std::atomic<T>geben uns atomare Variablen ( ) alle relevanten Garantien.

Sie können dies auch in der Linux-Kernel-Dokumentation berücksichtigen .

C-Programmierer haben häufig als volatil angesehen, dass die Variable außerhalb des aktuellen Ausführungsthreads geändert werden kann. Infolgedessen sind sie manchmal versucht, es im Kernel-Code zu verwenden, wenn gemeinsam genutzte Datenstrukturen verwendet werden. Mit anderen Worten, es ist bekannt, dass sie flüchtige Typen als eine Art einfache atomare Variable behandeln, was sie nicht sind. Die Verwendung von flüchtig im Kernel-Code ist fast nie korrekt. Dieses Dokument beschreibt warum.

Der wichtigste Punkt, den man in Bezug auf Volatilität verstehen muss, ist, dass sein Zweck darin besteht, die Optimierung zu unterdrücken, was fast nie das ist, was man wirklich tun möchte. Im Kernel muss man gemeinsam genutzte Datenstrukturen vor unerwünschtem gleichzeitigen Zugriff schützen, was eine ganz andere Aufgabe ist. Durch den Schutz vor unerwünschter Parallelität werden außerdem fast alle Optimierungsprobleme effizienter vermieden.

Die Kernel-Grundelemente, die den gleichzeitigen Zugriff auf Daten sicher machen (Spinlocks, Mutexe, Speicherbarrieren usw.), sind wie flüchtig, um unerwünschte Optimierungen zu verhindern. Wenn sie ordnungsgemäß verwendet werden, müssen sie auch nicht flüchtig verwendet werden. Wenn immer noch flüchtig ist, gibt es mit ziemlicher Sicherheit irgendwo einen Fehler im Code. In richtig geschriebenem Kernel-Code kann flüchtig nur dazu dienen, die Dinge zu verlangsamen.

Betrachten Sie einen typischen Block von Kernel-Code:

spin_lock(&the_lock);
do_something_on(&shared_data);
do_something_else_with(&shared_data);
spin_unlock(&the_lock);

Wenn der gesamte Code den Sperrregeln entspricht, kann sich der Wert von shared_data nicht unerwartet ändern, während the_lock gehalten wird. Jeder andere Code, der mit diesen Daten spielen möchte, wartet auf das Schloss. Die Spinlock-Grundelemente fungieren als Speicherbarrieren - sie sind ausdrücklich dafür geschrieben -, was bedeutet, dass Datenzugriffe nicht über sie hinweg optimiert werden. Der Compiler könnte also denken, dass er weiß, was in shared_data enthalten sein wird, aber der Aufruf von spin_lock () zwingt ihn, alles zu vergessen, was er weiß, da er als Speicherbarriere fungiert. Beim Zugriff auf diese Daten treten keine Optimierungsprobleme auf.

Wenn shared_data als flüchtig deklariert würde, wäre die Sperrung weiterhin erforderlich. Der Compiler würde jedoch auch daran gehindert, den Zugriff auf shared_data innerhalb des kritischen Abschnitts zu optimieren , wenn wir wissen, dass niemand anderes damit arbeiten kann. Während die Sperre gehalten wird, sind shared_data nicht flüchtig. Beim Umgang mit gemeinsam genutzten Daten macht eine ordnungsgemäße Sperrung die Flüchtigkeit unnötig - und möglicherweise schädlich.

Die flüchtige Speicherklasse war ursprünglich für speicherabgebildete E / A-Register gedacht. Innerhalb des Kernels sollten auch Registerzugriffe durch Sperren geschützt werden, aber man möchte auch nicht, dass der Compiler die Registerzugriffe innerhalb eines kritischen Abschnitts "optimiert". Innerhalb des Kernels werden E / A-Speicherzugriffe jedoch immer über Zugriffsfunktionen ausgeführt. Der direkte Zugriff auf den E / A-Speicher über Zeiger ist verpönt und funktioniert nicht auf allen Architekturen. Diese Accessoren sind so geschrieben, dass unerwünschte Optimierungen verhindert werden. Daher ist erneut keine Volatilität erforderlich.

Eine andere Situation, in der man versucht sein könnte, flüchtig zu verwenden, besteht darin, dass der Prozessor beschäftigt ist und auf den Wert einer Variablen wartet. Der richtige Weg, um ein geschäftiges Warten durchzuführen, ist:

while (my_variable != what_i_want)
    cpu_relax();

Der Aufruf von cpu_relax () kann den CPU-Stromverbrauch senken oder einem Hyperprozessor-Doppelprozessor nachgeben. Es dient auch als Speicherbarriere, so dass wiederum keine Flüchtigkeit erforderlich ist. Natürlich ist das Warten im Allgemeinen in der Regel zunächst ein unsozialer Akt.

Es gibt immer noch einige seltene Situationen, in denen Volatilität im Kernel Sinn macht:

• Die oben genannten Accessor-Funktionen können auf Architekturen, auf denen der direkte E / A-Speicherzugriff funktioniert, flüchtig verwendet werden. Im Wesentlichen wird jeder Accessor-Aufruf für sich genommen zu einem kleinen kritischen Abschnitt und stellt sicher, dass der Zugriff wie vom Programmierer erwartet erfolgt.

• Inline-Assembler-Code, der den Speicher ändert, aber keine anderen sichtbaren Nebenwirkungen hat, kann von GCC gelöscht werden. Durch Hinzufügen des flüchtigen Schlüsselworts zu asm-Anweisungen wird dieses Entfernen verhindert.

• Die Variable jiffies ist insofern besonders, als sie bei jedem Verweis einen anderen Wert haben kann, aber ohne spezielle Sperre gelesen werden kann. So können Jiffies volatil sein, aber die Hinzufügung anderer Variablen dieses Typs ist stark verpönt. Jiffies wird in dieser Hinsicht als "dummes Vermächtnis" (Linus 'Worte) angesehen; es zu reparieren wäre mehr Mühe als es wert ist.

• Zeiger auf Datenstrukturen im kohärenten Speicher, die möglicherweise von E / A-Geräten geändert werden, können manchmal rechtmäßig flüchtig sein. Ein von einem Netzwerkadapter verwendeter Ringpuffer, bei dem dieser Adapter die Zeiger ändert, um anzuzeigen, welche Deskriptoren verarbeitet wurden, ist ein Beispiel für diese Art von Situation.

Für den meisten Code gilt keine der oben genannten Begründungen für flüchtig. Infolgedessen wird die Verwendung von volatile wahrscheinlich als Fehler angesehen und bringt zusätzliche Kontrolle in den Code. Entwickler, die versucht sind, volatile zu verwenden, sollten einen Schritt zurücktreten und darüber nachdenken, was sie wirklich erreichen wollen.

Ich glaube nicht, dass Sie sich irren - flüchtig ist notwendig, um sicherzustellen, dass Thread A die Wertänderung sieht, wenn der Wert durch etwas anderes als Thread A geändert wird. Nach meinem Verständnis ist flüchtig im Grunde eine Möglichkeit, dies zu sagen Compiler "Zwischenspeichern Sie diese Variable nicht in einem Register, sondern lesen / schreiben Sie sie bei jedem Zugriff aus dem RAM-Speicher".

Die Verwirrung ist, dass Volatilität nicht ausreicht, um eine Reihe von Dingen zu implementieren. Insbesondere verwenden moderne Systeme mehrere Caching-Ebenen, moderne Multi-Core-CPUs führen zur Laufzeit einige ausgefallene Optimierungen durch, und moderne Compiler führen zur Kompilierungszeit einige ausgefallene Optimierungen durch, die alle dazu führen können, dass verschiedene Nebenwirkungen unterschiedlich auftreten Bestellung aus der Bestellung, die Sie erwarten würden, wenn Sie nur den Quellcode betrachten.

So flüchtig ist in Ordnung, solange Sie bedenken, dass die "beobachteten" Änderungen in der flüchtigen Variablen möglicherweise nicht genau zu dem Zeitpunkt auftreten, zu dem Sie glauben, dass sie eintreten werden. Versuchen Sie insbesondere nicht, flüchtige Variablen zu verwenden, um Operationen über Threads hinweg zu synchronisieren oder zu ordnen, da dies nicht zuverlässig funktioniert.

Persönlich ist meine Hauptverwendung (nur?) Für das flüchtige Flag ein "PleaseGoAwayNow" -Boolescher Wert. Wenn ich einen Worker-Thread habe, der kontinuierlich Schleifen durchläuft, muss er den flüchtigen Booleschen Wert bei jeder Iteration der Schleife überprüfen und beenden, wenn der Boolesche Wert jemals wahr ist. Der Hauptthread kann dann den Arbeitsthread sicher bereinigen, indem er den Booleschen Wert auf true setzt und dann pthread_join () aufruft, um zu warten, bis der Arbeitsthread verschwunden ist.

volatileist nützlich (wenn auch nicht ausreichend), um das Grundkonstrukt eines Spinlock-Mutex zu implementieren, aber sobald Sie das (oder etwas Überlegenes) haben, brauchen Sie kein anderes volatile.

Die typische Art der Multithread-Programmierung besteht nicht darin, jede gemeinsam genutzte Variable auf Maschinenebene zu schützen, sondern Schutzvariablen einzuführen, die den Programmfluss steuern. Anstelle von volatile bool my_shared_flag;dir sollte haben

pthread_mutex_t flag_guard_mutex; // contains something volatile
bool my_shared_flag;

Dies kapselt nicht nur den "schwierigen Teil", sondern ist grundsätzlich notwendig: C enthält keine atomaren Operationen, die zur Implementierung eines Mutex erforderlich sind; es muss nur volatilezusätzliche Garantien für den normalen Betrieb geben.

Jetzt hast du so etwas:

pthread_mutex_lock( &flag_guard_mutex );
my_local_state = my_shared_flag; // critical section
pthread_mutex_unlock( &flag_guard_mutex );

pthread_mutex_lock( &flag_guard_mutex ); // may alter my_shared_flag
my_shared_flag = ! my_shared_flag; // critical section
pthread_mutex_unlock( &flag_guard_mutex );

my_shared_flag muss nicht volatil sein, obwohl es nicht zwischenspeicherbar ist, weil

1. Ein anderer Thread hat Zugriff darauf.
2. Das heißt, ein Verweis darauf muss irgendwann (mit dem &Bediener) aufgenommen worden sein.
   • (Oder es wurde auf eine enthaltende Struktur verwiesen)
3. pthread_mutex_lock ist eine Bibliotheksfunktion.
4. Das heißt, der Compiler kann nicht sagen, ob er pthread_mutex_lockdiese Referenz irgendwie erhält.
5. Das heißt, der Compiler muss davon ausgehen, dass pthread_mutex_lockdas Shared Flag geändert wird !
6. Die Variable muss also aus dem Speicher neu geladen werden. volatile, obwohl in diesem Zusammenhang sinnvoll, ist irrelevant.

Dein Verständnis ist wirklich falsch.

Die Eigenschaft der flüchtigen Variablen lautet "Lesen von und Schreiben in diese Variable sind Teil des wahrnehmbaren Verhaltens des Programms". Das heißt, dieses Programm funktioniert (bei entsprechender Hardware):

int volatile* reg=IO_MAPPED_REGISTER_ADDRESS;
*reg=1; // turn the fuel on
*reg=2; // ignition
*reg=3; // release
int x=*reg; // fire missiles

Das Problem ist, dass dies nicht die Eigenschaft ist, die wir von threadsicherem irgendetwas wollen.

Ein thread-sicherer Zähler wäre beispielsweise nur (Linux-Kernel-ähnlicher Code, kenne das c ++ 0x-Äquivalent nicht):

atomic_t counter;

...
atomic_inc(&counter);

Dies ist atomar, ohne eine Gedächtnisbarriere. Sie sollten sie bei Bedarf hinzufügen. Das Hinzufügen von volatile würde wahrscheinlich nicht helfen, da es den Zugriff auf den Code in der Nähe nicht in Beziehung setzen würde (z. B. das Anhängen eines Elements an die Liste, die der Zähler zählt). Natürlich müssen Sie den Zähler nicht außerhalb Ihres Programms inkrementieren, und Optimierungen sind immer noch wünschenswert, z.

atomic_inc(&counter);
atomic_inc(&counter);

kann noch optimiert werden

atomically {
  counter+=2;
}

Wenn das Optimierungsprogramm intelligent genug ist (es ändert nichts an der Semantik des Codes).

Damit Ihre Daten in einer gleichzeitigen Umgebung konsistent sind, müssen zwei Bedingungen erfüllt sein:

1) Atomizität dh wenn ich einige Daten lese oder in den Speicher schreibe, werden diese Daten in einem Durchgang gelesen / geschrieben und können nicht unterbrochen oder konkurriert werden, z. B. aufgrund eines Kontextwechsels

2) Konsistenz , dh die Reihenfolge der Lese- / Schreib - ops werden muß gesehen das gleiche zwischen mehreren gleichzeitigen Umgebungen sein -, dass Threads, Maschinen usw.

volatile passt zu keinem der oben genannten Punkte - oder insbesondere enthält der c- oder c ++ - Standard, wie sich volatile verhalten soll, keinen der oben genannten Punkte.

In der Praxis ist dies sogar noch schlimmer, da einige Compiler (wie der Intel Itanium-Compiler) versuchen, ein Element des gleichzeitigen Zugriffssicherheitsverhaltens zu implementieren (dh durch Sicherstellen von Speicherzäunen). Es besteht jedoch keine Konsistenz zwischen den Compiler-Implementierungen, und der Standard verlangt dies nicht der Umsetzung in erster Linie.

Das Markieren einer Variablen als flüchtig bedeutet nur, dass Sie den Wert jedes Mal in den und aus dem Speicher leeren müssen, was in vielen Fällen Ihren Code nur verlangsamt, da Sie im Grunde Ihre Cache-Leistung beeinträchtigt haben.

c # und Java AFAIK beheben dies, indem sie die flüchtigen Bedingungen 1) und 2) einhalten. Dies gilt jedoch nicht für c / c ++ - Compiler.

Lesen Sie dies für eine eingehendere (wenn auch nicht unvoreingenommene) Diskussion zu diesem Thema

Die FAQ zu comp.programming.threads enthält eine klassische Erklärung von Dave Butenhof:

F56: Warum muss ich gemeinsam genutzte Variablen nicht als VOLATIL deklarieren?

Ich bin jedoch besorgt über Fälle, in denen sowohl der Compiler als auch die Thread-Bibliothek ihre jeweiligen Spezifikationen erfüllen. Ein konformer C-Compiler kann einem Register global eine gemeinsam genutzte (nichtflüchtige) Variable zuweisen, die gespeichert und wiederhergestellt wird, wenn die CPU von Thread zu Thread übergeben wird. Jeder Thread hat seinen eigenen privaten Wert für diese gemeinsam genutzte Variable, was wir von einer gemeinsam genutzten Variablen nicht erwarten.

In gewissem Sinne ist dies der Fall, wenn der Compiler genug über die jeweiligen Bereiche der Variablen und die Funktionen pthread_cond_wait (oder pthread_mutex_lock) weiß. In der Praxis werden die meisten Compiler nicht versuchen, Registerkopien globaler Daten während eines Aufrufs einer externen Funktion zu speichern, da es zu schwierig ist zu wissen, ob die Routine möglicherweise Zugriff auf die Adresse der Daten hat.

Ja, es stimmt, dass ein Compiler, der streng (aber sehr aggressiv) ANSI C entspricht, möglicherweise nicht mit mehreren Threads ohne Volatile arbeitet. Aber jemand sollte es besser reparieren. Da jedes SYSTEM (dh pragmatisch gesehen eine Kombination aus Kernel, Bibliotheken und C-Compiler), das keine POSIX-Speicherkohärenzgarantien bietet, nicht dem POSIX-Standard entspricht. Zeitraum. Das System kann NICHT verlangen, dass Sie flüchtige Variablen für gemeinsam genutzte Variablen verwenden, um ein korrektes Verhalten zu erzielen, da für POSIX nur die POSIX-Synchronisationsfunktionen erforderlich sind.

Wenn Ihr Programm bricht, weil Sie nicht flüchtig verwendet haben, ist das ein Fehler. Es ist möglicherweise kein Fehler in C oder ein Fehler in der Thread-Bibliothek oder ein Fehler im Kernel. Es handelt sich jedoch um einen SYSTEM-Fehler, und eine oder mehrere dieser Komponenten müssen funktionieren, um ihn zu beheben.

Sie möchten nicht flüchtig verwenden, da es auf jedem System, auf dem es einen Unterschied macht, erheblich teurer ist als eine richtige nichtflüchtige Variable. (ANSI C erfordert "Sequenzpunkte" für flüchtige Variablen bei jedem Ausdruck, während POSIX sie nur bei Synchronisationsvorgängen benötigt - eine rechenintensive Thread-Anwendung sieht bei Verwendung von flüchtigen Variablen wesentlich mehr Speicheraktivität, und schließlich ist es die Speicheraktivität, die verlangsamt dich wirklich.)

/ --- [Dave Butenhof] ----------------------- [butenhof@zko.dec.com] --- \
| Digital Equipment Corporation 110 Spit Brook Rd ZKO2-3 / Q18 |
| 603.881.2218, FAX 603.881.0120 Nashua NH 03062-2698 |
----------------- [Besseres Leben durch Parallelität] ---------------- /

Herr Butenhof behandelt in diesem Usenet-Beitrag einen Großteil des gleichen Themas :

Die Verwendung von "flüchtig" reicht nicht aus, um eine ordnungsgemäße Speichersichtbarkeit oder Synchronisation zwischen Threads sicherzustellen. Die Verwendung eines Mutex ist ausreichend, und a Mutex ist notwendig.

Wie Bryan erklärte, bewirkt die Verwendung von volatile nichts anderes, als den Compiler daran zu hindern, nützliche und wünschenswerte Optimierungen vorzunehmen, und bietet keinerlei Hilfe, um Code "threadsicher" zu machen. Sie können natürlich alles, was Sie wollen, als "flüchtig" deklarieren - es ist schließlich ein legales ANSI C-Speicherattribut. Erwarten Sie nur nicht, dass es Probleme mit der Thread-Synchronisierung für Sie löst.

All das gilt auch für C ++.

Dies ist alles, was "flüchtig" tut: "Hey Compiler, diese Variable könnte sich in jedem Moment (bei jedem Takt) ändern, selbst wenn KEINE LOKALEN ANWEISUNGEN darauf einwirken. Speichern Sie diesen Wert NICHT in einem Register."

Das ist es. Es teilt dem Compiler mit, dass Ihr Wert flüchtig ist. Dieser Wert kann jederzeit durch externe Logik (ein anderer Thread, ein anderer Prozess, der Kernel usw.) geändert werden. Es existiert mehr oder weniger ausschließlich, um Compiler-Optimierungen zu unterdrücken, die einen Wert in einem Register stillschweigend zwischenspeichern, der für JEDEN Cache von Natur aus unsicher ist.

Möglicherweise stoßen Sie auf Artikel wie "Dr. Dobbs", die als Allheilmittel für die Multithread-Programmierung flüchtig sind. Sein Ansatz ist nicht völlig unbegründet, aber er hat den grundlegenden Fehler, die Benutzer eines Objekts für seine Thread-Sicherheit verantwortlich zu machen, was tendenziell dieselben Probleme aufweist wie andere Verstöße gegen die Kapselung.

Gemäß meinem alten C-Standard ist „Was einen Zugriff auf ein Objekt mit einem flüchtig qualifizierten Typ ausmacht, ist implementierungsdefiniert“ . C-Compiler-Autoren hätten sich also für "flüchtig" entscheiden können, was "thread-sicherer Zugriff in einer Umgebung mit mehreren Prozessen" bedeutet . Aber sie haben es nicht getan.

Stattdessen wurden die Vorgänge, die erforderlich sind, um einen kritischen Abschnittsthread in einer Mehrkern-Umgebung mit gemeinsamem Speicher und mehreren Prozessen sicher zu machen, als neue implementierungsdefinierte Funktionen hinzugefügt. Befreit von der Anforderung, dass "flüchtig" atomaren Zugriff und Zugriffsreihenfolge in einer Umgebung mit mehreren Prozessen bereitstellen würde, priorisierten die Compiler-Autoren die Code-Reduktion gegenüber der von der historischen Implementierung abhängigen "flüchtigen" Semantik.

Dies bedeutet, dass Dinge wie "flüchtige" Semaphoren um kritische Codeabschnitte, die auf neuer Hardware mit neuen Compilern nicht funktionieren, möglicherweise einmal mit alten Compilern auf alter Hardware funktioniert haben und alte Beispiele manchmal nicht falsch sind, sondern nur alt.