Must I call atomic load/store explicitly?

Question

C++11 introduced the std::atomic<> template library. The standard specifies the store() and load() operations to atomically set / get a variable shared by more than one thread.

My question is are assignment and access operations also atomic?

Namely, is:

std::atomic<bool> stop(false);
...
void thread_1_run_until_stopped()
{
    if(!stop.load())
        /* do stuff */
}

void thread_2_set_stop()
{        
    stop.store(true);
}

Equivalent to:

void thread_1_run_until_stopped()
{
    if(!stop)
        /* do stuff */
}

void thread_2_set_stop()
{        
    stop = true;
}

`stop.load(std::memory_order_relaxed)` and `stop.store(true, std::memory_order_relaxed);` should be fine here, as Serge says. You just need the store to be seen promptly, and `relaxed` still guarantees that. You only need a stronger ordering if you need to synchronize other data. — Peter Cordes, Sep 02 '17 at 07:57

Andrew Tomazos · Accepted Answer · 2013-09-17T13:40:51.707

49

Are assignment and access operations for non-reference types also atomic?

Yes, they are. atomic<T>::operator T and atomic<T>::operator= are equivalent to atomic<T>::load and atomic<T>::store respectively. All the operators are implemented in the atomic class such that they will use atomic operations as you would expect.

I'm not sure what you mean about "non-reference" types? Not sure how reference types are relevant here.

edited Sep 17 '13 at 13:40

answered Sep 17 '13 at 13:35

Andrew Tomazos

58,923
32
156
267

11

Equivalent to the versions of load and store without a consistency control parameter, that is. – Ben Voigt Sep 17 '13 at 13:56
1

@user1131467 - thanks. Removed the 'reference', well, reference ;-) – bavaza Sep 17 '13 at 14:20
1

@BenVoigt All it means is that the most stringent memory order is used: `std::memory_order_seq_cst`. This prevents one from shooting oneself in the foot, but is possibly a premature pessimization. – Kuba hasn't forgotten Monica Aug 06 '14 at 00:52

Serge Rogatch · Answer 2 · 2017-09-02T09:09:23.517

You can do both, but the advantage of load()/store() is that they allow to specify memory order. It is important sometimes for performance, where you can specify std::memory_order_relaxed while atomic<T>::operator T and atomic<T>::operator= would use the most safe and slow std::memory_order_seq_cst. Sometimes it is important for correctness and readability of your code: although the default std::memory_order_seq_cst is most safe thus most likely to be correct, it is not immediately clear for the reader what kind of operation (acquire/release/consume) you are doing, or whether you are doing such operation at all (to answer: isn't relaxed order sufficient here?).

Must I call atomic load/store explicitly?

2 Answers2

Linked