Атомарная операция "Сравнить и заменить" (CAS) и проблема ABA

CPU instruction to alter a value in memory only if it equals a given valueIn computer science, compare and swap (CAS) is an atomic instruction used in multithreading to achieve synchronization. It compares the contents of a memory location with a given value and, only if they are the same, modifies the contents of that memory location to a new given value. This is done as a single atomic operation. The atomicity guarantees that the new value is calculated based on up to date information; if the value had been updated by another thread in the meantime, the write would fail. The result of the operation must indicate whether it performed the substitution; this can be done either with a simple boolean response (this variant is often called compare and set), or by returning the value read from the memory location (not the value written to it).

Some CAS based algorithms are affected by and must handle the problem of a false positive match, or the ABA problem. It is possible that between the time the old value is read and the time CAS is attempted, some other processors or threads change the memory location two or more times such that it acquires a bit pattern which matches the old value. The problem arises if this new bit pattern, which looks exactly like the old value, has a different meaning: for instance, it could be a recycled address, or a wrapped version counter. A general solution to this is to use a double length CAS (DCAS). E. g., on a 32 bit system, a 64 bit CAS can be used. The second half is used to hold a counter. The compare part of the operation compares the previously read value of the pointer and the counter, with the current pointer and counter. If they match, the swap occurs the new value is written but the new value has an incremented counter. This means that if ABA has occurred, although the pointer value will be the same, the counter is exceedingly unlikely to be the same (for a 32 bit value, a multiple of 232 operations would have to have occurred, causing the counter to wrap and at that moment, the pointer value would have to also by chance be the same). An alternative form of this (useful on CPUs which lack DCAS) is to use an index into a freelist, rather than a full pointer, e. g. with a 32 bit CAS, use a 16 bit index and a 16 bit counter. However, the reduced counter lengths begin to make ABA possible at modern CPU speeds. One simple technique which helps alleviate this problem is to store an ABA counter in each data structure element, rather than using a single ABA counter for the whole data structure. A more complicated but more effective solution is to implement safe memory reclamation (SMR). This is in effect lock free garbage collection. The advantage of using SMR is the assurance a given pointer will exist only once at any one time in the data structure, thus the ABA problem is completely solved. (Without SMR, something like a freelist will be in use, to ensure that all data elements can be accessed safely (no memory access violations) even when they are no longer present in the data structure. With SMR, only elements actually currently in the data structure will be accessed).

CAS, and other atomic instructions, are sometimes thought to be unnecessary in uniprocessor systems, because the atomicity of any sequence of instructions can be achieved by disabling interrupts while executing it. However, disabling interrupts has numerous downsides. For example, code that is allowed to do so must be trusted not to be malicious and monopolize the CPU, as well as to be correct and not accidentally hang the machine in an infinite loop or page fault. Further, disabling interrupts is often deemed too expensive to be practical. Thus, even programs only intended to run on uniprocessor machines will benefit from atomic instructions, as in the case of Linux's futexes. In multiprocessor systems, it is usually impossible to disable interrupts on all processors at the same time. Even if it were possible, two or more processors could be attempting to access the same semaphore's memory at the same time, and thus atomicity would not be achieved. The compare and swap instruction allows any processor to atomically test and modify a memory location, preventing such multiple processor collisions. On server grade multi processor architectures of the 2010s, compare and swap is cheap relative to a simple load that is not served from cache. A 2013 paper points out that a CAS is only 1.15 times more expensive than a non cached load on Intel Xeon (Westmere EX) and 1.35 times on AMD Opteron (Magny Cours).

Compare and swap (and compare and swap double) has been an integral part of the IBM 370 (and all successor) architectures since 1970. The operating systems that run on these architectures make extensive use of this instruction to facilitate process (i. e., system and user tasks) and processor (i. e., central processors) parallelism while eliminating, to the greatest degree possible, the "disabled spinlocks" which had been employed in earlier IBM operating systems. Similarly, the use of test and set was also eliminated. In these operating systems, new units of work may be instantiated "globally", into the global service priority list, or "locally", into the local service priority list, by the execution of a single compare and swap instruction. This substantially improved the responsiveness of these operating systems. In the x86 (since 80486) and Itanium architectures this is implemented as the compare and exchange (CMPXCHG) instruction (on a multiprocessor the prefix must be used). As of 2013, most multiprocessor architectures support CAS in hardware, and the compare and swap operation is the most popular synchronization primitive for implementing both lock based and non blocking concurrent data structures.

Since CAS operates on a single pointer sized memory location, while most lock free and wait free algorithms need to modify multiple locations, several extensions have been implemented. Double compare and swap (DCAS) Compares two unrelated memory locations with two expected values, and if they're equal, sets both locations to new values. The generalization of DCAS to multiple (non adjacent) words is called MCAS or CASN. DCAS and MCAS are of practical interest in the convenient (concurrent) implementation of some data structures like deques or binary search trees. DCAS and MCAS may be implemented however using the more expressive hardware transactional memory present in some recent processors such as IBM POWER8 or in Intel processors supporting Transactional Synchronization Extensions (TSX). Double wide compare and swap Operates on two adjacent pointer sized locations (or, equivalently, one location twice as big as a pointer). On later x86 processors, the CMPXCHG8B and CMPXCHG16B instructions serve this role, although early 64 bit AMD CPUs did not support CMPXCHG16B (modern AMD CPUs do). Some Intel motherboards from the Core 2 era also hamper its use, even though the processors support it. These issues came into the spotlight at the launch of Windows 8.1 because it required hardware support for CMPXCHG16B. Single compare, double swap Compares one pointer but writes two. The Itanium's cmp8xchg16 instruction implements this, where the two written pointers are adjacent. Multi word compare and swap Is a generalisation of normal compare and swap. It can be used to atomically swap an arbitrary number of arbitrarily located memory locations. Usually, multi word compare and swap is implemented in software using normal double wide compare and swap operations. The drawback of this approach is a lack of scalability. Persistent compare and swap Is a combination of persist operation and the normal compare and swap. It can be used to atomically compare and swap a value and then persist the value, so there is no gap between concurrent visibility and crash visibility. The extension solves the read of non persistent write problem.

2003 discussion "Lock Free using cmpxchg8b " on Intel x86, with pointers to various papers and source code