std::memory_order

This page has been machine-translated from the English version of the wiki using Google Translate. The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. Click here for the English version of this page

[Bearbeiten] Konstanten

[Bearbeiten] Relaxed Ordnung

• Keine Bestellung von anderen Speicherzugriffe ist immer gewährleistet. Dies bedeutet, dass es nicht möglich ist, mehrere Threads mit dem atomaren variablen synchronisieren .

  Original:

  No ordering of other memory accesses is ensured whatsoever. This means that it is not possible to synchronize several threads using the atomic variable.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Liest und schreibt auf die atomare Variable selbst bestellt werden. Sobald ein Thread liest einen Wert, eine spätere Lese von dem selben Thread aus dem gleichen Objekt kann nicht ergeben einen früheren Wert .

  Original:

  Reads and writes to the atomic variable itself are ordered. Once a thread reads a value, a subsequent read by the same thread from the same object can not yield an earlier value.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

// Thread 1:
r1 = y.load(memory_order_relaxed);
x.store(r1, memory_order_relaxed);
// Thread 2:
r2 = x.load(memory_order_relaxed);
y.store(42, memory_order_relaxed);

[Bearbeiten] Release-Verbrauchen Bestellung

• Kein schreibt in der Writer-Thread kann nach dem atomaren Shop nachbestellt werden

  Original:

  No writes in the writer thread can be reordered after the atomic store

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Kein liest oder schreibt abhängig von dem Wert von atomaren Last empfangen, bevor die atomare Last nachbestellbar. "Abhängig von" bedeutet, dass die Adresse oder Wert aus dem Wert des atomaren Variable berechnet. Diese Form der Synchronisation zwischen Threads als "Abhängigkeit ordering" bekannt .

  Original:

  No reads or writes dependent on the value received from atomic load can be reordered before the atomic load. "Dependent on" means that the address or value is computed from the value of the atomic variable. This form of synchronization between threads is known as "dependency ordering".

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Die Synchronisation wird nur zwischen den Themen etabliert Loslassen und Konsum die gleiche atomare Variable. Andere Gewinde sehen unterschiedliche Reihenfolge der Speicherzugriffe als eine oder beide der synchronisierten Threads .

  Original:

  The synchronization is established only between the threads releasing and consuming the same atomic variable. Other threads can see different order of memory accesses than either or both of the synchronized threads.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Die Synchronisation ist transitiv. Das heißt, wenn wir die folgende Situation:

  Original:

  The synchronization is transitive. That is, if we have the following situation:

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Thema A veröffentlicht atomare Variable a .

  Original:

  Thread A releases atomic variable a.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Thema B verbraucht atomare Variable a .

  Original:

  Thread B consumes atomic variable a.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Atomic variable b ist abhängig von a .

  Original:

  Atomic variable b is dependent on a.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Thema B Versionen atomare Variable b .

  Original:

  Thread B releases atomic variable b.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Thema C verbraucht oder erwirbt atomare Variable b .

  Original:

  Thread C consumes or acquires atomic variable b.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

Dann wird nicht nur A und B oder B und C sind synchronisiert, aber A und C auch. Das heißt, alle Schreibvorgänge von dem Thread A, die vor der Veröffentlichung von eingeführt wurden a garantiert abgeschlossen werden, sobald Thema C stellt den Speicher, um b .

Original:

Then not only A and B or B and C are synchronized, but A and C also. That is, all writes by the thread A that were launched before the release of a are guaranteed to be completed once thread C observes the store to b.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Lassen Sequenz

[Bearbeiten] Release-Erwerben Bestellung

• Kein schreibt in der Writer-Thread kann nach dem atomaren Shop nachbestellt werden

  Original:

  No writes in the writer thread can be reordered after the atomic store

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Kein liest der Leser Thread kann vor der atomaren Belastung nachbestellt werden .

  Original:

  No reads in the reader thread can be reordered before the atomic load.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Die Synchronisation wird nur zwischen den Fäden hergestellt' und freisetzenden Erfassen dieselbe Ordnungszahl variabel. Andere Gewinde sehen unterschiedliche Reihenfolge der Speicherzugriffe als eine oder beide der synchronisierten Threads .

  Original:

  The synchronization is established only between the threads releasing and acquiring the same atomic variable. Other threads can see different order of memory accesses than either or both of the synchronized threads.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Die Synchronisation ist transitiv. Das heißt, wenn wir die folgende Situation:

  Original:

  The synchronization is transitive. That is, if we have the following situation:

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Thema A veröffentlicht atomare Variable a .

  Original:

  Thread A releases atomic variable a.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Thema B verbraucht atomare Variable a .

  Original:

  Thread B consumes atomic variable a.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Thema B Versionen atomare Variable b .

  Original:

  Thread B releases atomic variable b.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Thema C verbraucht oder erwirbt atomare Variable b .

  Original:

  Thread C consumes or acquires atomic variable b.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

Dann wird nicht nur A und B oder B und C sind synchronisiert, aber A und C auch. Das heißt, alle Schreibvorgänge von dem Thread A, die vor der Veröffentlichung von eingeführt wurden a garantiert abgeschlossen werden, sobald Thema C stellt den Speicher, um b .

Original:

Then not only A and B or B and C are synchronized, but A and C also. That is, all writes by the thread A that were launched before the release of a are guaranteed to be completed once thread C observes the store to b.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Sequenziell konsistenten Bestellung

• Kein schreibt in der Writer-Thread kann nach dem atomaren Shop nachbestellt werden

  Original:

  No writes in the writer thread can be reordered after the atomic store

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Kein liest der Leser Thread kann vor der atomaren Belastung nachbestellt werden .

  Original:

  No reads in the reader thread can be reordered before the atomic load.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• Die Synchronisation erfolgt zwischen allen atomare Operationen getaggt std::memory_order_seq_cst etabliert. Alle Threads mit solchen atomaren Operation sehen die gleiche Reihenfolge der Speicherzugriffe .

  Original:

  The synchronization is established between all atomic operations tagged std::memory_order_seq_cst. All threads using such atomic operation see the same order of memory accesses.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

[Bearbeiten] Beziehung mit volatil

[Bearbeiten] Beispiele

[Bearbeiten] std::memory_order_relaxed

#include <vector>
#include <iostream>
#include <thread>
#include <atomic>
 
std::atomic<int> cnt = ATOMIC_VAR_INIT(0);
 
void f()
{
    for(int n = 0; n < 1000; ++n) {
        cnt.fetch_add(1, std::memory_order_relaxed);
    }
}
 
int main()
{
    std::vector<std::thread> v;
    for(int n = 0; n < 10; ++n) {
        v.emplace_back(f);
    }
    for(auto& t : v) {
        t.join();
    }
    std::cout << "Final counter value is " << cnt << '\n';
}

Final counter value is 10000

[Bearbeiten] std::memory_order_release and std::memory_order_consume

#include <thread>
#include <atomic>
#include <cassert>
#include <string>
 
std::atomic<std::string*> ptr;
int data;
 
void producer()
{
    std::string* p  = new std::string("Hello");
    data = 42;
    ptr.store(p, std::memory_order_release);
}
 
void consumer()
{
    std::string* p2;
    while (!(p2 = ptr.load(std::memory_order_consume)))
        ;
    assert(*p2 == "Hello"); // never fires
    assert(data == 42); // may or may not fire
}
 
int main()
{
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}

[Bearbeiten] std::memory_order_release and memory_order_acquire

#include <thread>
#include <atomic>
#include <cassert>
#include <string>
 
std::atomic<std::string*> ptr;
int data;
 
void producer()
{
    std::string* p  = new std::string("Hello");
    data = 42;
    ptr.store(p, std::memory_order_release);
}
 
void consumer()
{
    std::string* p2;
    while (!(p2 = ptr.load(std::memory_order_acquire)))
        ;
    assert(*p2 == "Hello"); // never fires
    assert(data == 42); // never fires
}
 
int main()
{
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}

[Bearbeiten] std::memory_order_acq_rel

#include <thread>
#include <atomic>
#include <cassert>
#include <vector>
 
std::vector<int> data;
std::atomic<int> flag = ATOMIC_VAR_INIT(0);
 
void thread_1()
{
    data.push_back(42);
    flag.store(1, std::memory_order_release);
}
 
void thread_2()
{
    int expected=1;
    while (!flag.compare_exchange_strong(expected, 2, std::memory_order_acq_rel)) {
        expected = 1;
    }
}
 
void thread_3()
{
    while (flag.load(std::memory_order_acquire) < 2)
        ;
    assert(data.at(0) == 42); // will never fire
}
 
int main()
{
    std::thread a(thread_1);
    std::thread b(thread_2);
    std::thread c(thread_3);
    a.join(); b.join(); c.join();
}

[Bearbeiten] std::memory_order_seq_cst

#include <thread>
#include <atomic>
#include <cassert>
 
std::atomic<bool> x = ATOMIC_VAR_INIT(false);
std::atomic<bool> y = ATOMIC_VAR_INIT(false);
std::atomic<int> z = ATOMIC_VAR_INIT(0);
 
void write_x()
{
    x.store(true, std::memory_order_seq_cst);
}
 
void write_y()
{
    y.store(true, std::memory_order_seq_cst);
}
 
void read_x_then_y()
{
    while (!x.load(std::memory_order_seq_cst))
        ;
    if (y.load(std::memory_order_seq_cst)) {
        ++z;
    }
}
 
void read_y_then_x()
{
    while (!y.load(std::memory_order_seq_cst))
        ;
    if (x.load(std::memory_order_seq_cst)) {
        ++z;
    }
}
 
int main()
{
    std::thread a(write_x);
    std::thread b(write_y);
    std::thread c(read_x_then_y);
    std::thread d(read_y_then_x);
    a.join(); b.join(); c.join(); d.join();
    assert(z.load() != 0);  // will never happen
}