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

[editar] Constantes

[editar] Relaxado ordenação

• Sem ordenação dos acessos à memória outros é assegurada qualquer. Isto significa que não é possível sincronizar vários segmentos usando a variável atómica.

  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.
• Lê e escreve para a variável atômica em si são ordenados. Uma vez que uma thread lê um valor, uma leitura posterior do mesmo segmento do mesmo objeto não pode produzir um valor anteriormente.

  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);

[editar] Lançamento-Consuma encomenda

• Não escreve no segmento de escritor pode ser reordenadas após a loja atômica

  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.
• Não lê ou escreve dependente do valor recebido de carga atômica podem ser reordenadas antes da carga atômica. "Dependente" significa que o endereço ou o valor é calculado a partir do valor da variável atómica. Esta forma de sincronização entre threads é conhecido como "ordenação dependência".

  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.
• A sincronização é estabelecida apenas entre os tópicos liberar e' consumindo a mesma variável atômica. Outros segmentos podem ver ordem diferente de acessos de memória do que um ou ambos os fios sincronizados.

  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.
• A sincronização é transitivo. Isto é, se temos a seguinte situação:

  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.

• Tópico A libera variável atômica 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.
• Tópico B consome variável atômica 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.
• Variável atômica b depende 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.
• Tópico B variável lançamentos atômica 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.
• Tópico C consome ou adquire variável atômica 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.

Então, não só A e B ou B e C são sincronizados, mas A e C também. Isto é, todas as escritas pelo segmento A, que foram lançados antes do lançamento de a são garantidos para ser concluída uma vez rosca C observa a loja para 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.

[editar] Solte seqüência

[editar] Solte-Adquirir encomenda

• Não escreve no segmento de escritor pode ser reordenadas após a loja atômica

  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.
• Não lê no segmento leitor podem ser reordenadas antes da carga atômica.

  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.
• A sincronização é estabelecida apenas entre os tópicos liberar e' adquirir a mesma variável atômica. Outros segmentos podem ver ordem diferente de acessos de memória do que um ou ambos os fios sincronizados.

  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.
• A sincronização é transitivo. Isto é, se temos a seguinte situação:

  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.

• Tópico A libera variável atômica 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.
• Tópico B consome variável atômica 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.
• Tópico B variável lançamentos atômica 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.
• Tópico C consome ou adquire variável atômica 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.

Então, não só A e B ou B e C são sincronizados, mas A e C também. Isto é, todas as escritas pelo segmento A, que foram lançados antes do lançamento de a são garantidos para ser concluída uma vez rosca C observa a loja para 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.

[editar] Sequencialmente consistente ordenação

• Não escreve no segmento de escritor pode ser reordenadas após a loja atômica

  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.
• Não lê no segmento leitor podem ser reordenadas antes da carga atômica.

  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.
• A sincronização é estabelecida entre todas as operações atômicas marcadas std::memory_order_seq_cst. Todos os segmentos usando operação atômica como ver a mesma ordem de acessos à memória.

  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.

[editar] Relacionamento com volátil

[editar] Exemplos

[editar] 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

[editar] 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();
}

[editar] 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();
}

[editar] 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();
}

[editar] 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
}