C11 Speicher Zaun Verwendung

Question

Selbst für ein einfaches 2-Faden-Kommunikation Beispiel, ich habe Schwierigkeiten, diese atomaren und memory_fence im C11-Stil zum Ausdruck bringen richtige Speicherordnung zu erhalten:

gemeinsam genutzter Daten:

volatile int flag, bucket; 

Gewinde

Produzent:

while (true) { 
    int value = producer_work(); 
    while (atomic_load_explicit(&flag, memory_order_acquire)) 
     ; // busy wait 
    bucket = value; 
    atomic_store_explicit(&flag, 1, memory_order_release); 
} 

Verbraucher dre Anzeige:

while (true) { 
    while (!atomic_load_explicit(&flag, memory_order_acquire)) 
     ; // busy wait 
    int data = bucket; 
    atomic_thread_fence(/* memory_order ??? */); 
    atomic_store_explicit(&flag, 0, memory_order_release); 
    consumer_work(data); 
} 

Soweit ich oben Code zu verstehen, Shop-in-Eimer richtig wäre bestellen -> Flag-Speicher -> Flag-Last -> Last-from-Eimer. Ich denke jedoch, dass es zwischen dem Load-from-Bucket und dem Bucket einen neuen Zustand mit neuen Daten gibt. Um eine Order zu erzwingen, die dem Bucket-Read folgt, würde ich einen expliziten atomic_thread_fence() zwischen dem Bucket-Read und dem folgenden Atomic_store benötigen. Leider scheint es kein memory_order Argument zu geben, um irgendetwas auf vorhergehenden Lasten zu erzwingen, nicht einmal die memory_order_seq_cst.

Eine wirklich schmutzige Lösung könnte sein, die bucket im Consumer-Thread mit einem Dummy-Wert neu zuzuordnen: das widerspricht dem Consumer Read-Only-Konzept.

In der älteren C99/GCC-Welt konnte ich die traditionelle __sync_synchronize() verwenden, die meiner Meinung nach stark genug wäre.

Was wäre die bessere C11-Lösung, um diese sogenannte Anti-Abhängigkeit zu synchronisieren?

(Natürlich Ich bin mir bewusst, dass ich besser, solche Low-Level-Codierung vermeiden sollte und Nutzung stehen zur Verfügung geordnete Konstrukte, aber ich würde ... verstehen mag)

Answer 1

Um eine Reihenfolge nach dem Bucket-Read zu erzwingen, würde ich vermutlich eine explizite atomic_thread_fence() zwischen dem Bucket-Read und dem folgenden Atomic_store benötigen.

Ich glaube nicht, der atomic_thread_fence() Aufruf notwendig: das Flag-Update hat Release Semantik, von einem der vorhergehenden Lade- oder Speicheroperationen zu verhindern über sie neu geordnet werden. Siehe die formale Definition von Herb Sutter:

Eine Zuschreibung Release führt schließlich liest und schreibt vom selben Thread, der es in der Programmreihenfolge vorangestellt werden.

Dies soll das Lesen von bucket vor einem neu geordnet verhindern, nachdem die flag Update auftreten, unabhängig davon, wo der Compiler data speichern wählt.

Das hat mich auf Ihre Kommentare über andere Antwort bringt:

Die volatile stellt sicher, dass es ld/st Operationen erzeugt, die anschließend mit Zäunen können bestellt werden. Daten sind jedoch eine lokale Variable, nicht flüchtig. Der Compiler wird es wahrscheinlich registerieren und eine Speicheroperation vermeiden. Dadurch bleibt die Last aus dem zu bestellenden Bucket mit dem nachfolgenden Flag-Reset.

Es wäre das scheint kein Problem dar, wenn die bucket Lese kann nicht über die Schreibfreigabe flag neu geordnet werden, so sollte volatile nicht notwendig sein (obwohl es wahrscheinlich nicht, es zu haben tut nicht weh, entweder). Es ist auch nicht notwendig, da die meisten Funktionsaufrufe (in diesem Fall atomic_store_explicit(&flag)) als Speicherbarrieren für die Kompilierung dienen. Der Compiler würde das Lesen einer globalen Variablen nach einem nicht inlinierten Funktionsaufruf nicht neu anordnen, da diese Funktion die gleiche Variable ändern könnte.

Ich würde auch mit @MaximYegorushkin zustimmen, dass Sie Ihre busy-waiting mit pause Anweisungen beim Targeting kompatibler Architekturen verbessern können. GCC und ICC scheinen beide _mm_pause(void) intrinsisch zu haben (wahrscheinlich äquivalent zu __asm__ ("pause;")).

Answer 2

Ich stimme mit dem, was @MikeStrobel sagt in sein Kommentar.

Sie brauchen nicht atomic_thread_fence() hier, weil Ihre kritischen Abschnitte mit erwerben beginnen und mit Release-Semantik enden. Daher können Lesevorgänge in Ihren kritischen Abschnitten nicht vor dem Erwerb neu geordnet werden, und nach der Veröffentlichung werden Schreibvorgänge durchgeführt. Und deshalb ist volatile hier auch nicht notwendig.

Außerdem sehe ich keinen Grund, warum (pthread) Spinlock hier nicht verwendet wird. spinlock hat eine ähnliche beschäftigt Spin für Sie, aber es nutzt auch pause instruction:

Die Pause intrinsische in verwendet wird Spin-Warteschleifen mit den Prozessoren Implementierung dynamischer Ausführung (insbesondere Out-of-Order-Ausführung). In der Spin-Wait-Schleife verbessert die innewohnende Pause die Geschwindigkeit, mit der der Code die Freigabe der Sperre erkennt und einen besonders signifikanten Leistungsgewinn liefert. Die Ausführung des nächsten Befehls wird um eine implementierungsspezifische Zeit verzögert. Die PAUSE-Anweisung ändert den Architekturzustand nicht. Für die dynamische Planung reduziert der PAUSE-Befehl den Nachteil des Verlassens der Spin-Schleife.

Answer 3

Direkte Antwort:

, dass Ihr Geschäft ist ein memory_order_release Betrieb bedeutet, dass der Compiler einen Speicher Zaun für Speicherbefehl vor dem Laden der Flagge zu emittieren hat.Dies ist erforderlich, um sicherzustellen, dass andere Prozessoren den endgültigen Status der freigegebenen Daten sehen, bevor sie mit der Interpretation beginnen. Nein, Sie müssen keinen zweiten Zaun hinzufügen.

---

Lange Antwort:

Wie oben erwähnt, was passiert ist, dass der Compiler Ihre atomic_... Anweisungen in Kombinationen von Zäunen und Speicherzugriffe transformiert; die grundlegende Abstraktion ist nicht die atomare Last, es ist der Erinnerungszaun. So funktionieren die Dinge, auch wenn die neuen C++ - Abstraktionen dazu verleiten, anders zu denken. Und ich persönlich finde Gedächtniszäune viel leichter nachzudenken als die angestrebten Abstraktionen in C++.

Aus Hardware-Sicht, was Sie sicherstellen müssen, ist die relative Bestellung Ihrer Ladungen und speichert, i. e. dass der Schreibvorgang in den Bucket abgeschlossen wird, bevor das Flag in den Producer geschrieben wird, und dass das Flag load einen Wert liest, der älter ist als der Ladevorgang des Buckets im Consumer.

das gesagt ist, was Sie wirklich brauchen, ist dies:

//producer 
while(true) { 
    int value = producer_work(); 
    while (flag) ; // busy wait 
    atomic_thread_fence(memory_order_acquire); //ensure that value is not assigned to bucket before the flag is lowered 
    bucket = value; 
    atomic_thread_fence(memory_order_release); //ensure bucket is written before flag is 
    flag = true; 
} 

//consumer 
while(true) { 
    while(!flag) ; // busy wait 
    atomic_thread_fence(memory_order_acquire); //ensure the value read from bucket is not older than the last value read from flag 
    int data = bucket; 
    atomic_thread_fence(memory_order_release); //ensure data is loaded from bucket before the flag is lowered again 
    flag = false; 
    consumer_work(data); 
} 

Beachten Sie, dass die Etiketten „Erzeuger“ und „Verbraucher“ sind irreführend hier, weil wir zwei Prozesse spielen Ping-Pong haben, jeder Hersteller zu werden und Verbraucher der Reihe nach; es ist nur, dass ein Thread nützliche Werte erzeugt, während die andere „Löcher“ erzeugt in nützliche Werte zu schreiben ...

atomic_thread_fence() alles, was Sie brauchen, und da es unter den an die Assembler-Anweisungen direkt übersetzt atomic_... Abstraktionen, es ist garantiert der schnellste Weg.