C++11 Atomic memory order with non-atomic variables

Question

I am unsure about how the memory ordering guarantees of atomic variables in c++11 affect operations to other memory.

Let's say I have one thread which periodically calls the write function to update a value, and another thread which calls read to get the current value. Is it guaranteed that the effects of d = value; will not be seen before effects of a = version;, and will be seen before the effects of 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

The rule is that, given a write thread that executes once, and nothing else that modifies a, b or d,

• You can read a and b from a different thread at any time, and
• if you read b and see version stored in it, then
  • You can read d; and
  • What you read will be value.

Note that whether the second part is true depends on the memory ordering; it is true with the default one (memory_order_seq_cst).