Editing Linearizability

{{short description|Property of some operation(s) in concurrent programming}}
{{Duplication|date=November 2018|dupe=serializability|dupe2=atomicity (database systems)}}
[[File:Linearlizable Process.svg|thumb|In grey a linear sub-history, processes beginning in {{math|b}} do not have a linearizable history because {{math|b0}} or {{math|b1}} may complete in either order before {{math|b2}} occurs.]]

In [[concurrent programming]], an operation (or set of operations) is '''linearizable''' if it consists of an ordered list of [[Execution (computing)|invocation]] and response [[Event (computing)|events]], that may be extended by adding response events such that:

# The extended list can be re-expressed as a sequential history (is [[serializability|serializable]]). 
# That sequential history is a subset of the original unextended list.

Informally, this means that the unmodified list of events is linearizable [[if and only if]] its invocations were serializable, but some of the responses of the serial schedule have yet to return.<ref name=":0" />

In a concurrent system, processes can access a shared [[Object (computer science)|object]] at the same time. Because multiple processes are accessing a single object, a situation may arise in which while one process is accessing the object, another process changes its contents. Making a system linearizable is one solution to this problem. In a linearizable system, although operations overlap on a shared object, each operation appears to take place instantaneously. Linearizability is a strong correctness condition, which constrains what outputs are possible when an object is accessed by multiple processes concurrently. It is a safety property which ensures that operations do not complete unexpectedly or unpredictably. If a system is linearizable it allows a programmer to reason about the system.<ref>{{Cite journal|last1=Shavit|first1=Nir|last2=Taubenfel|first2=Gadi|year=2016|title=The Computability of Relaxed Data Structures: Queues and Stacks as Examples|url=http://www.faculty.idc.ac.il/gadi/MyPapers/2015ST-RelaxedDataStructures.pdf|journal=Distributed Computing|volume=29|issue=5|pages=396–407|doi=10.1007/s00446-016-0272-0|s2cid=16192696}}</ref>

== History of linearizability ==
Linearizability was first introduced as a [[consistency model]] by [[Maurice Herlihy|Herlihy]] and [[Jeannette Wing|Wing]] in 1987. It encompassed more restrictive definitions of atomic, such as "an atomic operation is one which cannot be (or is not) interrupted by concurrent operations", which are usually vague about when an operation is considered to begin and end.

An atomic object can be understood immediately and completely from its sequential definition, as a set of operations run in parallel which always appear to occur one after the other; no inconsistencies may emerge. Specifically, linearizability guarantees that the [[Invariant (computer science)|invariants]] of a system are ''observed'' and ''preserved'' by all operations: if all operations individually preserve an invariant, the system as a whole will.

== Definition of linearizability ==
A concurrent system consists of a collection of processes communicating through shared data structures or objects. Linearizability is important in these concurrent systems where objects may be accessed by multiple processes at the same time and a programmer needs to be able to reason about the expected results. An execution of a concurrent system results in a ''history'', an ordered sequence of completed operations.

A ''history'' is a sequence of ''invocations'' and ''responses'' made of an object by a set of [[Thread (computer science)|threads]] or processes. An invocation can be thought of as the start of an operation, and the response being the signaled end of that operation. Each invocation of a function will have a subsequent response. This can be used to model any use of an object. Suppose, for example, that two threads, A and B, both attempt to grab a lock, backing off if it's already taken. This would be modeled as both threads invoking the lock operation, then both threads receiving a response, one successful, one not.

{| border="1" cellspacing="0"
| A invokes ''lock''
| B invokes ''lock''
| A gets "failed" response
| B gets "successful" response
|}

A ''sequential'' history is one in which all invocations have immediate responses; that is the invocation and response are considered to take place instantaneously. A sequential history should be trivial to reason about, as it has no real concurrency; the previous example was not sequential, and thus is hard to reason about. This is where linearizability comes in.

A history is ''linearizable'' if there is a linear order <math>\sigma</math> of the completed operations such that:
# For every completed operation in <math>\sigma</math>, the operation returns the same result in the execution as the operation would return if every operation was completed one by one in order <math>\sigma</math>.
# If an operation op<sub>1</sub> completes (gets a response) before op<sub>2</sub> begins (invokes), then op<sub>1</sub> precedes op<sub>2</sub> in <math>\sigma</math>.<ref name=":0">{{Cite journal|author1=Herlihy, Maurice P.  |author2=Wing, Jeannette M.|year=1990|title=Linearizability: A Correctness Condition for Concurrent Objects|journal=ACM Transactions on Programming Languages and Systems|volume=12| issue = 3|pages=463–492|doi=10.1145/78969.78972|citeseerx=10.1.1.142.5315|s2cid=228785}}</ref>
In other words:
* its invocations and responses can be reordered to yield a sequential history;
* that sequential history is correct according to the sequential definition of the object;
* if a response preceded an invocation in the original history, it must still precede it in the sequential reordering.

(Note that the first two bullet points here match [[serializability]]: the operations appear to happen in some order. It is the last point which is unique to linearizability, and is thus the major contribution of Herlihy and Wing.)<ref name=":0" />

Let us look at two ways of reordering the locking example above.

{| border="1" cellspacing="0"
| A invokes ''lock''
| A gets "failed" response
| B invokes ''lock''
| B gets "successful" response
|}

Reordering B's invocation below A's response yields a sequential history. This is easy to reason about, as all operations now happen in an obvious order. Unfortunately, it doesn't match the sequential definition of the object (it doesn't match the semantics of the program): A should have successfully obtained the lock, and B should have subsequently aborted.

{| border="1" cellspacing="0"
| B invokes ''lock''
| B gets "successful" response
| A invokes ''lock''
| A gets "failed" response
|}

This is another correct sequential history. It is also a linearization! Note that the definition of linearizability only precludes responses that precede invocations from being reordered; since the original history had no responses before invocations, we can reorder it as we wish. Hence the original history is indeed linearizable.

An object (as opposed to a history) is linearizable if all valid histories of its use can be linearized. Note that this is a much harder assertion to prove.

=== Linearizability versus serializability ===
Consider the following history, again of two objects interacting with a lock:

{| border="1" cellspacing="0"
| A invokes lock
| A successfully locks
| B invokes unlock
| B successfully unlocks
| A invokes unlock
| A successfully unlocks
|}

This history is not valid because there is a point at which both A and B hold the lock; moreover, it cannot be reordered to a valid sequential history without violating the ordering rule. Therefore, it is not linearizable. However, under serializability, B's unlock operation may be moved to ''before'' A's original lock, which is a valid history (assuming the object begins the history in a locked state):

{| border="1" cellspacing="0"
| B invokes unlock
| B successfully unlocks
| A invokes lock
| A successfully locks
| A invokes unlock
| A successfully unlocks
|}

This reordering is sensible provided there is no alternative means of communicating between A and B. Linearizability is better when considering individual objects separately, as the reordering restrictions ensure that multiple linearizable objects are, considered as a whole, still linearizable.

=== Linearization points ===
This definition of linearizability is equivalent to the following:
* All function calls have a ''linearization point'' at some instant between their invocation and their response.
* All functions appear to occur instantly at their linearization point, behaving as specified by the sequential definition.

This alternative is usually much easier to prove. It is also much easier to reason about as a user, largely due to its intuitiveness. This property of occurring instantaneously, or indivisibly, leads to the use of the term ''atomic'' as an alternative to the longer "linearizable".<ref name=":0" />

In the examples below, the linearization point of the counter built on compare-and-swap is the linearization point of the first (and only) successful compare-and-swap update. The counter built using locking can be considered to linearize at any moment while the locks are held, since any potentially conflicting operations are excluded from running during that period.

== Primitive atomic instructions ==
Processors have [[Instruction (computer science)|instructions]] that can be used to implement [[Lock (computer science)|locking]] and [[lock-free and wait-free algorithms]]. The ability to temporarily inhibit [[interrupt]]s, ensuring that the currently running [[Process (computing)|process]] cannot be [[context switch]]ed, also suffices on a [[uniprocessor]]. These instructions are used directly by compiler and operating system writers but are also abstracted and exposed as bytecodes and library functions in higher-level languages:
* atomic read-write;
* atomic swap (the RDLK instruction in some [[Burroughs large systems#Multiple processors|Burroughs mainframes]], and the XCHG [[x86 instruction listings|x86 instruction]]);
* [[test-and-set]];
* [[fetch-and-add]];
* [[compare-and-swap]];
* [[load-link/store-conditional]].

Most [[central processing unit|processors]] include store operations that are not atomic with respect to memory. These include multiple-word stores and string operations. Should a high priority interrupt occur when a portion of the store is complete, the operation must be completed when the interrupt level is returned. The routine that processes the interrupt must not modify the memory being changed. It is important to take this into account when writing interrupt routines.

When there are multiple instructions which must be completed without interruption, a CPU instruction which temporarily disables interrupts is used. This must be kept to only a few instructions and the interrupts must be re-enabled to avoid unacceptable response time to interrupts or even losing interrupts. This mechanism is not sufficient in a multi-processor environment since each CPU can interfere with the process regardless of whether interrupts occur or not. Further, in the presence of an [[instruction pipeline]], uninterruptible operations present a security risk, as they can potentially be chained in an [[infinite loop]] to create a [[denial of service attack]], as in the [[Cyrix coma bug]].

The [[C programming language|C standard]] and [[SUSv3]] provide <code>sig_atomic_t</code> for simple atomic reads and writes; incrementing or decrementing is not guaranteed to be atomic.<ref>{{cite book|url=https://books.google.com/books?id=2SAQAQAAQBAJ&pg=PA428|title=The Linux Programming Interface|first=Michael|last=Kerrisk|date=7 September 2018|publisher=No Starch Press|via=Google Books|isbn=9781593272203}}</ref> More complex atomic operations are available in [[C11 (C standard revision)|C11]], which provides <code>stdatomic.h</code>. Compilers use the hardware features or more complex methods to implement the operations; an example is libatomic of GCC.

The [[ARM architecture|ARM instruction set]] provides <code>LDREX</code> and <code>STREX</code> instructions which can be used to implement atomic memory access by using [[Monitor (synchronization)|exclusive monitors]] implemented in the processor to track memory accesses for a specific address.<ref>{{cite web|title=ARM Synchronization Primitives Development Article|url=https://developer.arm.com/products/architecture/a-profile/docs/dht0008/latest/1-arm-synchronization-primitives}}</ref> However, if a [[context switch]] occurs between calls to <code>LDREX</code> and <code>STREX</code>, the documentation notes that <code>STREX</code> will fail, indicating the operation should be retried. In the case of 64-bit ARMv8-A architecture, it provides <code>LDXR</code> and <code>STXR</code> instructions for byte, half-word, word, and double-word size.<ref>{{Cite web |url=https://documentation-service.arm.com/static/5efa1989dbdee951c1ccdea1 |title=ARMv8-A Synchronization primitives |page=6 |accessdate=2023-12-14}}</ref>

== High-level atomic operations ==
The easiest way to achieve linearizability is running groups of primitive operations in a [[critical section]]. Strictly, independent operations can then be carefully permitted to overlap their critical sections, provided this does not violate linearizability. Such an approach must balance the cost of large numbers of [[lock (computer science)|locks]] against the benefits of increased parallelism.

Another approach, favoured by researchers (but not yet widely used in the software industry), is to design a linearizable object using the native atomic primitives provided by the hardware. This has the potential to maximise available parallelism and minimise synchronisation costs, but requires mathematical proofs which show that the objects behave correctly.

A promising hybrid of these two is to provide a [[transactional memory]] abstraction. As with critical sections, the user marks sequential code that must be run in isolation from other threads. The implementation then ensures the code executes atomically. This style of abstraction is common when interacting with databases; for instance, when using the [[Spring Framework]], annotating a method with @Transactional will ensure all enclosed database interactions occur in a single [[database transaction]]. Transactional memory goes a step further, ensuring that all memory interactions occur atomically. As with database transactions, issues arise regarding composition of transactions, especially database and in-memory transactions.

A common theme when designing linearizable objects is to provide an all-or-nothing interface: either an operation succeeds completely, or it fails and does nothing. ([[ACID]] databases refer to this principle as [[Atomicity (database systems)|atomicity]].) If the operation fails (usually due to concurrent operations), the user must retry, usually performing a different operation. For example:
* [[Compare-and-swap]] writes a new value into a location only if the latter's contents matches a supplied old value. This is commonly used in a read-modify-CAS sequence: the user reads the location, computes a new value to write, and writes it with a CAS (compare-and-swap); if the value changes concurrently, the CAS will fail and the user tries again.
* [[Load-link/store-conditional]] encodes this pattern more directly: the user reads the location with load-link, computes a new value to write, and writes it with store-conditional; if the value has changed concurrently, the SC (store-conditional) will fail and the user tries again.
* In a [[database transaction]], if the transaction cannot be completed due to a concurrent operation (e.g. in a [[deadlock]]), the transaction will be aborted and the user must try again.

== Examples of linearizability ==

=== Counters ===
To demonstrate the power and necessity of linearizability we will consider a simple counter which different processes can increment.

We would like to implement a counter object which multiple processes can access. Many common systems make use of counters to keep track of the number of times an event has occurred.

The counter object can be accessed by multiple processes and has two available operations.
# Increment - adds 1 to the value stored in the counter, return acknowledgement
# Read - returns the current value stored in the counter without changing it.
We will attempt to implement this counter object using [[shared register]]s.

Our first attempt which we will see is non-linearizable has the following implementation using one shared register among the processes.

==== Non-atomic ====
The naive, non-atomic implementation:

'''Increment:'''
# Read the value in the register R
# Add one to the value
# Writes the new value back into register R
'''Read:'''

Read register R

This simple implementation is not linearizable, as is demonstrated by the following example.

Imagine two processes are running accessing the single counter object initialized to have value 0:
# The first process reads the value in the register as 0.
# The first process adds one to the value, the counter's value should be 1, but before it has finished writing the new value back to the register it may become suspended, meanwhile the second process is running:
# The second process reads the value in the register, which is still equal to 0;
# The second process adds one to the value;
# The second process writes the new value into the register, the register now has value 1.
The second process is finished running and the first process continues running from where it left off:
# The first process writes 1 into the register, unaware that the other process has already updated the value in the register to 1.
In the above example, two processes invoked an increment command, however the value of the object only increased from 0 to 1, instead of 2 as it should have. One of the increment operations was lost as a result of the system not being linearizable.

The above example shows the need for carefully thinking through implementations of data structures and how linearizability can have an effect on the correctness of the system.

==== Atomic ====
To implement a linearizable or atomic counter object we will modify our previous implementation so '''each process P<small>i</small> will use its own register R<small>i</small>'''

Each process increments and reads according to the following algorithm:

'''Increment:'''
# Read value in register R<small>i</small>.
# Add one to the value.
# Write new value back into R<small>i</small>
'''Read:'''
# Read registers R<small>1,</small> R<small>2, ...</small> R<small>n</small>.
# Return the sum of all registers.
This implementation solves the problem with our original implementation. In this system the increment operations are linearized at the write step. The linearization point of an increment operation is when that operation writes the new value in its register R<small>i.</small> The read operations are linearized to a point in the system when the value returned by the read is equal to the sum of all the values stored in each register R<small>i.</small>

This is a trivial example. In a real system, the operations can be more complex and the errors introduced extremely subtle. For example, reading a [[64-bit]] value from memory may actually be implemented as two [[sequence|sequential]] reads of two [[32-bit]] memory locations. If a process has only read the first 32&nbsp;bits, and before it reads the second 32&nbsp;bits the value in memory gets changed, it will have neither the original value nor the new value but a mixed-up value.

Furthermore, the specific order in which the processes run can change the results, making such an error difficult to detect, reproduce and [[debug]].

=== Compare-and-swap ===
{{Main|Compare-and-swap}}
Most systems provide an atomic compare-and-swap instruction that reads from a memory location, compares the value with an "expected" one provided by the user, and writes out a "new" value if the two match, returning whether the update succeeded. We can use this to fix the non-atomic counter algorithm as follows:

:# Read the value in the memory location;
:# add one to the value;
:# use compare-and-swap to write the incremented value back;
:# retry if the value read in by the compare-and-swap did not match the value we originally read.

Since the compare-and-swap occurs (or appears to occur) instantaneously, if another process updates the location while we are in-progress, the compare-and-swap is guaranteed to fail.

=== Fetch-and-increment ===
{{Main|Fetch-and-increment}}
Many systems provide an atomic fetch-and-increment instruction that reads from a memory location, unconditionally writes a new value (the old value plus one), and returns the old value.
We can use this to fix the non-atomic counter algorithm as follows:

:# Use fetch-and-increment to read the old value and write the incremented value back.

Using fetch-and increment is always better (requires fewer memory references) for some algorithms—such as the one shown here—than compare-and-swap,<ref name="cond-sync">{{cite book| last1=Fich | first1=Faith | title=Proceedings of the twenty-third annual ACM symposium on Principles of distributed computing – PODC '04 | last2=Hendler | first2=Danny | last3=Shavit | first3=Nir | year=2004 | publisher=ACM | location=New York, NY | pages=80–87 | isbn=978-1-58113-802-3 |doi=10.1145/1011767.1011780| chapter=On the inherent weakness of conditional synchronization primitives | s2cid=9313205 }}</ref> even though Herlihy earlier proved that compare-and-swap is better for certain other algorithms that can't be implemented at all using only fetch-and-increment.
So [[CPU design]]s with both fetch-and-increment and compare-and-swap (or equivalent instructions) may be a better choice than ones with only one or the other.<ref name="cond-sync" />

=== Locking ===
{{Main|Lock (computer science)}}
Another approach is to turn the naive algorithm into a [[critical section]], preventing other threads from disrupting it, using a [[lock (computer science)|lock]]. Once again fixing the non-atomic counter algorithm:

:# Acquire a lock, excluding other threads from running the critical section (steps 2–4) at the same time;
:# read the value in the memory location;
:# add one to the value;
:# write the incremented value back to the memory location;
:# release the lock.

This strategy works as expected; the lock prevents other threads from updating the value until it is released. However, when compared with direct use of atomic operations, it can suffer from significant overhead due to lock contention. To improve program performance, it may therefore be a good idea to replace simple critical sections with atomic operations for [[non-blocking synchronization]] (as we have just done for the counter with compare-and-swap and fetch-and-increment), instead of the other way around, but unfortunately a significant improvement is not guaranteed and lock-free algorithms can easily become too complicated to be worth the effort.

== See also ==
* [[Atomicity (database systems)|Atomic transaction]]
* [[Consistency model]]
* [[ACID]]
* [[Read-copy-update]] (RCU)
* [[Read-modify-write]]
* [[Time of check to time of use]]

== References ==
{{reflist}}

== Further reading ==
* {{cite book | doi=10.1145/41625.41627 | year=1987 | last1=Herlihy | first1=Maurice P. | last2=Wing | first2=Jeannette M. | title=Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages - POPL '87 | chapter=Axioms for concurrent objects | pages=13–26 | isbn=978-0-89791-215-0| s2cid=16017451 | url=http://repository.cmu.edu/cgi/viewcontent.cgi?article=2597&context=compsci }}
* {{cite book | doi=10.1145/99164.99185 | year=1990 | last1=Herlihy | first1=Maurice P. | title=A methodology for implementing highly concurrent data structures | journal=ACM SIGPLAN Notices | volume=25 | issue=3 | pages=197–206 | isbn=978-0-89791-350-8| citeseerx=10.1.1.186.6400 }}
* {{cite journal | doi=10.1145/78969.78972 | title=Linearizability: A Correctness Condition for Concurrent Objects | year=1990 | last1=Herlihy | first1=Maurice P. | last2=Wing | first2=Jeannette M. | journal=ACM Transactions on Programming Languages and Systems | volume=12 | issue=3 | pages=463–492| citeseerx=10.1.1.142.5315 | s2cid=228785 }}
* {{cite web|author=Aphyr|title=Strong Consistency Models|url=https://aphyr.com/posts/313-strong-consistency-models|website=aphyr.com|publisher=Aphyr|access-date=13 April 2018}}

[[Category:Consistency models]]
[[Category:Transaction processing]]
[[Category:Concurrency control]]