Atomic action - mutex

I heard that t开发者_Go百科here is something known as "atomic action" which is faster then using a mutex with critical section. Does somebody know what is it, and how do I use it?

An atomic operation is an operation where the CPU reads and writes memory during the same bus access, this prevents other CPUs or system devices from modifying the memory simultaneously. E.g. a "test and set" operation, which could do "read memory at location X, if it is 0 set it to 1, return an indicator telling whether the value was set" without any chance of simultaneous access.

Wikipedia's http://en.wikipedia.org/wiki/Linearizability describes atomic operations.

If you're on windows, have a look at e.g. InterlockedTestExchange or InterlockedIncrement which are wrappers for atomic operations.

EDIT: Sample usage

A spinlock could be implemented using a test-and-set atomic operation:

while (test_and_set(&x) == 1) ;

This will keep looping until the current thread is the one that sets x to 1. If all other threads treat x in the same way its effect is the same as a mutex.

Atomic action only refers to the fact that an action will be done atomically uninterrupted by a co-running thread/processes.

What you are probably looking for are atomic built-ins in compilers. For example GCC provides this set: http://gcc.gnu.org/onlinedocs/gcc-4.5.1/gcc/Atomic-Builtins.html

These are usually implemented very efficiently using CPU support.

It is a tradeoff. As other posters have stated, an atomic operation is "try to grab this flag and return true on success". It is fast, but there are downsides.

A proper mutex blocks the threads that need to get into the critical section. With only atomic operations the waiting threads have to loop until they get the flag - this wastes CPU cycles. Another downside is that mutexes guarantee fair access - usually by just queueing the waiting processes in a FIFO queue. With spinlocks, there's a risk of resource starvation.

So, the bare atomic operations are faster but only when there's not too many threads trying to grab the critical section.

Since a GCC-specific answer was given, here's the VC++-specific link -- all of the intrinsics listed that begin with _Interlocked are relevant: http://msdn.microsoft.com/en-us/library/hd9bdb82.aspx. Also note that there are more intrinsics available for x64 than for x86: http://msdn.microsoft.com/en-us/library/azcs88h2.aspx.

Critical section implementation (shurely in windows) uses atomic variable to detect is a critical section (cs) captured by another thread or not, and enters kernel-side synchronization primitive only if real collision occurs. So if you need to protect a small piece of code and collision probability is small enough, critical section is a good solution. However, if the protected code does nothing except of incrementing/decrementing or testing and modifying a single variable then it's the right case to use atomic operation.

There is also possible to protect by atomics more complicated code (google "lock free structures" and "transactional memory" for more info)

It is interesting but very complicated stuff and may not be recommended if some simple solution (like critical section) also works.