C++ 11 Атомный порядок памяти с неатомными переменными

Question

Я не уверен, как гарантии упорядочения памяти для атомных переменных в C++ 11 влияют на операции в другой памяти.

Предположим, у меня есть один поток, который периодически вызывает функцию записи, чтобы обновить значение, и другой поток, который вызывает чтение, чтобы получить текущее значение. Гарантировано ли, что эффекты d = value; не будут видны до эффектов a = version; и будут видны до эффектов b = version;?

atomic<int> a {0}; 
atomic<int> b {0}; 
double d; 

void write(int version, double value) { 
    a = version; 
    d = value; 
    b = version; 
} 

double read() { 
    int x,y; 
    double ret; 
    do { 
     x = b; 
     ret = d; 
     y = a; 
    } while (x != y); 
    return ret; 
} 

Answer 1

Это гарантирует, что эффекты d = value; не будут рассматриваться до того воздействия a = version;, и будет видно, до эффектов b = version;?

Да, это так. Это связано с тем, что секвенциальный барьер согласованности подразумевается при чтении или записи переменной atomic<>.

Вместо того чтобы хранить version тег в два атомных переменные перед изменением значения и после этого, вы можете увеличивать одного атомных переменные до и после изменения:

atomic<int> a = {0}; 
double d; 

void write(double value) 
{ 
    a = a + 1; // 'a' become odd 
    d = value; //or other modification of protected value(s) 
    a = a + 1; // 'a' become even, but not equal to the one before modification 
} 

double read(void) 
{ 
    int x; 
    double ret; 
    do 
    { 
     x = a; 
     ret = value; // or other action with protected value(s) 
    } while((x & 2) || (x != a)); 
    return ret; 
} 

Это известно как seqlock в ядро Linux: http://en.wikipedia.org/wiki/Seqlock

Answer 2

Ваш объект d записывается и считывается двумя потоками, и это не атомная. Это небезопасно, как это было предложено в стандарте С ++ на многопоточности:

1,10/4 Два выражения оценки конфликт, если один из них изменяет ячейку памяти, а другой доступ или изменяет ту же ячейку памяти.

1,10/21 Выполнение программы содержит гонки данных, если она не содержит два противоречивых действий в разных потоках, по меньшей мере, один из , который не является атомным, и ни происходит до другого. Любая такая гонка данных приводит к неопределенному поведению.

Важны редактировать:

В вашем неатомарном случае, вы не имеете никаких гарантий относительно упорядочения между чтением и записью. У вас даже нет гарантии, что читатель прочитает значение, написанное автором (это short article explains the risk для неатомных переменных).

Тем не менее, заканчивает цикл вашего читателя на основе теста окружающих атомарных переменных, для которых есть сильные гарантии. Если предположить, что version никогда не повторяется между писателем различными вызовами, и учитывая обратный порядок, в котором вы aquire их значение:

• порядок d чтения по сравнению с d записи не может быть неудачным, если два атомарных равны ,
• Аналогично, значение чтения не может быть непоследовательным, если две атомы равны.

Это означает, что в случае неблагоприятного состояния гонки на вашем неатомном, благодаря петле, вы закончите чтение последних value.

Answer 3

Правило гласит, что, учитывая write поток, который выполняется один раз, и больше ничего, что изменяет a, b или d,

• Вы можете прочитать a и b из другого потока в любой момент времени, и
• если вы читаете b и увидеть version хранящуюся в нем, то
  • вы можете прочитать d; и
  • То, что вы прочтете, будет value.

Обратите внимание, что ли вторая часть действительно зависит от порядка памяти; это верно по умолчанию (memory_order_seq_cst).