Свободное программирование: семантика порядка переупорядочения и памяти

Question

Я пытаюсь найти свои ноги в программировании без блокировки. Прочитав различные объяснения семантики упорядочения памяти, я хотел бы прояснить, что может произойти в результате возможного переупорядочения. Насколько я понял, инструкции могут быть переупорядочены компилятором (из-за оптимизации при компиляции программы) и ЦП (во время выполнения?).

Для расслабленной семантики cpp reference обеспечивает следующий пример:

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

Говорит, что при х и у, первоначально нуля код разрешено производить r1 r2 == == 42, потому что, хотя секвенируют -be before B в потоке 1 и C секвенируется до D в потоке 2, ничто не мешает D появляться до того, как A в порядке модификации y, а B появится до C в порядке модификации x. Как это могло случиться? Означает ли это, что C и D переупорядочиваются, поэтому порядок выполнения будет DABC? Разрешено ли переупорядочивать A и B?

Для семантики приобретает релиз есть следующий пример код:

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 
} 

мне интересно, что если бы мы использовали непринужденный заказ памяти вместо приобретают? Я думаю, значение data можно было прочитать до p2 = ptr.load(std::memory_order_relaxed), но как насчет p2?

И наконец, почему в этом случае хорошо использовать расслабленный порядок памяти?

template<typename T> 
class stack 
{ 
    std::atomic<node<T>*> head; 
public: 
    void push(const T& data) 
    { 
     node<T>* new_node = new node<T>(data); 

     // put the current value of head into new_node->next 
     new_node->next = head.load(std::memory_order_relaxed); 

     // now make new_node the new head, but if the head 
     // is no longer what's stored in new_node->next 
     // (some other thread must have inserted a node just now) 
     // then put that new head into new_node->next and try again 
     while(!head.compare_exchange_weak(new_node->next, new_node, 
             std::memory_order_release, 
             std::memory_order_relaxed)) 
      ; // the body of the loop is empty 
    } 
}; 

Я имею в виду как head.load(std::memory_order_relaxed) и head.compare_exchange_weak(new_node->next, new_node, std::memory_order_release, std::memory_order_relaxed).

Чтобы суммировать все вышесказанное, мой вопрос по существу, когда мне нужно заботиться о возможном переупорядочении, а когда нет?

Answer 1

Для # 1 компилятор может выдавать хранилище до y до загрузки с x (нет зависимостей), и даже если это не так, загрузка с x может быть отложена на уровне процессора/памяти.

Для # 2, p2 будет отличным от нуля, но ни * p2, ни данные не обязательно будут иметь значащее значение.

Для # 3 есть только один акт публикации неатомарных магазинов, сделанные этот поток, и это релиз

Вы всегда должны заботиться о переназначении, или, лучше, не принимают на себя никакой заказа: ни C++ ни аппаратное обеспечение не выполняет код сверху вниз, они только уважают зависимости.