Fetch-and-add

The motivation for having an atomic fetch-and-add is that operations that appear in programming languages as are not safe in a concurrent system, where multiple processes or threads are running concurrently (either in a multi-processor system, or preemptively scheduled onto some single-core systems). The reason is that such an operation is actually implemented as multiple machine instructions: • load into a register; • add to register; • store register value back into . When one process is doing and another is doing concurrently, there is a data race. They might both fetch and operate on that, then both store their results with the effect that one overwrites the other and the stored value becomes either or , not as might be expected. In uniprocessor systems with no kernel preemption supported, it is sufficient to disable interrupts before accessing a critical section. However, in multiprocessor systems (even with interrupts disabled) two or more processors could be attempting to access the same memory at the same time. The fetch-and-add instruction allows any processor to atomically increment a value in memory, preventing such multiple processor collisions. Maurice Herlihy (1991) proved that fetch-and-add has a finite consensus number, in contrast to the compare-and-swap operation. The fetch-and-add operation can solve the wait-free consensus problem for no more than two concurrent processes. ==Implementation==

The fetch-and-add instruction behaves like the following function. Crucially, the entire function is executed atomically: no process can interrupt the function mid-execution and hence see a state that only exists during the execution of the function. This code only serves to help explain the behaviour of fetch-and-add; atomicity requires explicit hardware support and hence can not be implemented as a simple high level function. using std::atomic; int fetchAndAdd(atomic* location, int inc) { return location->fetch_add(inc); } A mutual exclusion lock can be implemented using the ticket lock algorithm as: import std; using std::atomic; using std::memory_order; class Lock { private: atomic ticketNumber{0}; atomic turn{0}; public: void lock() { // Must be atomic, since many threads may ask for a lock simultaneously int myTurn = ticketNumber.fetch_add(1, memory_order::relaxed): while (turn.load(memory_order::acquire) != myTurn) { // Spin until lock is acquired } } void unlock() { // This need not be atomic, as only the possessor of the lock will execute this turn.fetch_add(1, memory_order::release); } }; ==Hardware and software support==

An atomic method for std::atomic appears in the C++11 standard. It is available as a proprietary extension to C in the Itanium ABI specification, and (with the same syntax) in GCC. x86 implementation In the x86 architecture, the instruction ADD with the destination operand specifying a memory location is a fetch-and-add instruction that has been there since the 8086 (it just wasn't called that then), and with the LOCK prefix, is atomic across multiple processors. However, it could not return the original value of the memory location (though it returned some flags) until the 486 introduced the XADD instruction. The following is a C implementation for the GCC compiler, for both 32- and 64-bit x86 Intel platforms, based on extended asm syntax: inline int fetchAndAdd(int* variable, int value) { asm volatile( "lock; xaddl %0, %1" : "+r" (value), "+m" (*variable) // input + output : // No input-only : "memory" ); return value; } History Fetch-and-add was introduced by the Ultracomputer project, which also produced a multiprocessor supporting fetch-and-add and containing custom VLSI switches that were able to combine concurrent memory references (including fetch-and-adds) to prevent them from serializing at the memory module containing the destination operand. ==See also==