Are the "modify" operators like +=, |=, &= etc atomic?
I know ++ is atomic (if you perform x++; in two different threads "simultaneously", you will always end up with x increased by 2, as opposed to x=x+1 with optimization switched off.)
What I wonder is whether variable |= constant, and the likes are thread-safe or do I have to protect them with a mutex?
(...or is it CPU-dependent? In this case, how is it on ARM?)
You know wrong. There is no guarantee that ++ is atomic. and neither is there for the compound assignment operators, or indeed for any C++ operation.
For the change in value to be visible across cores, a += (for instance) would have to load the value, add the increment and then store it. This means that the operation will not be atomic.
To ensure atomicity you'd need to put appropriate locking around the operation.
++ might be atomic on your compiler/platform, but in the c++ specs it is not defined to be atomic.
If you want to make sure to modify a value in an atomic way, you should use the appropiate methods, like Interlocked* on windows.
Same for all the other routines. If you want atomic operations, you should use the appropiate calls, not the standard ones.
No operator in C or C++ is guaranteed to be atomic. They might be on your platform, but you won't know for sure. Typically, the only operation that is atomic is the an instruction Test and Set, which is usually available on most modern CPUs in some form as the basis for implementing semaphores.
x++ is often implemented in 3 instructions: Read X into a register, Increment it, and Write it back to memory.
Your thread may be pre-empted in between any of those.
It's worth mentioning that these operators can be overloaded, so there can certainly be no general guarantee that they are atomic for all classes.
No, they're not atomic! If you need atomic operations on primitive types, and you're using linux, you can take a look here: http://gcc.gnu.org/onlinedocs/gcc-4.1.0/gcc/Atomic-Builtins.html and/or atomic.h...
Even if ++ is an atomic operation, that does not imply that two threads doing ++x will result in x being exactly two higher. You have to synchronize the threads somehow, or otherwise they won't necessarily see each other's changes.
It's both compiler and CPU dependent. Some instruction sets provide atomic instructions for these (on machine-sized ints).
However, there's no guarantee that you compiler will use those instructions and won't optimize your code in a non-threadsafe way. You need to either write routine in assembly or use a compiler specific technique (such as instrinsics) that provides atomicity (or use a library that uses one of those techniques).
Specifically on ARM: The ORR/ADD/AND instructions take two operands and place the result in a register. Either operand can be the same register as the result register, so they can used as an atomic |=, +=, &=.
Of course, the result is put in a register and the first operand must also come from a register, so you'll have to make sure the register loads are done atomically.