必须在多大程度上使用原子类型来保证跨线程可见性？

Question

Given a structure like this:

struct foo {
    atomic_int refcount; /* atomic access */
    char* bar1;          /* read-only */
    char* bar2;          /* read-only */
};

Strictly speaking: is it be necessary to use atomic_intptr_t for bar1 and bar2 to guarantee cross-thread visibility of the non-atomic variables, granted that I use proper acquire/release semantics?

Answer 1

Taken abstractly, any memory operations that occur between the acquire/release operations on the atomic variable will behave as if you had acquired and released an abstract mutex type (POSIX, WinAPI, etc), since that's how these are generally implemented anyway. A major goal of atomic operations and a defined memory model is to define how non-atomic memory accesses are ordered around atomic accesses. So they should not need to be atomic.

If you never write to the pointers, then you only need a memory barrier after initialization of the struct to ensure that the initial values become visible in other threads. If in your critical section you mutate what the pointers refer to, the acquire/release semantics will ensure that those changes become visible as well.

Helpful reading (I'm not sure of any differences between C11 and C++11's memory model): http://en.cppreference.com/w/cpp/atomic/memory_order

http://bartoszmilewski.com/2008/12/01/c-atomics-and-memory-ordering/

EDIT: Added better link.

Answer 2

To be pedantic (which is a good thing when talking about memory models), there is nothing that mandates that changes ever become visible to other threads. All you are guaranteed is that what happens at a synchronization point: If your acquiring read reads a certain, new value, then you are guaranteed that all the effects of the thread that used a release-write to write that new value which came before the write in that thread have happened and are visible. But you don't actually have a guarantee that your acquiring-read will ever read the new value.

C++11 is mildly more specific about this and contains a "Note" that an "operation will become visible to all other threads in a finite period of time" (C++11, 1.10/25), but I don't see any analogous statement in C11.

(I've actually posted a comment to that effect on Herb Sutter's atomic talk .)