Skip to content
Free planNo credit card requiredStart writing
AI for Research home
AI for Research home
Dashboard
Sign inGet started

Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 686 papers for “Linearizability”

Linearizability

Maurice Herlihy · Encyclopedia of Algorithms · 2008

Cited by 1

Parameterised linearizability

Yang, H, Cerone, A, Gotsman, A · Oxford University Research Archive (ORA) (University of Oxford) · 2014

Cited by 0Open access

Local Linearizability

Andreas Haas, Thomas A. Henzinger, Andreas Holzer et al. · arXiv (Cornell University) · 2015

The semantics of concurrent data structures is usually given by a sequential specification and a consistency condition. Linearizability is the most popular consistency condition due to its simplicity and general applicability. Nevertheless, for applications that do not require all guarantees offered by linearizability, recent research has focused on improving performance and scalability of concurrent data structures by relaxing their semantics. In this paper, we present local linearizability, a relaxed consistency condition that is applicable to container-type concurrent data structures like pools, queues, and stacks. While linearizability requires that the effect of each operation is observed by all threads at the same time, local linearizability only requires that for each thread T, the effects of its local insertion operations and the effects of those removal operations that remove values inserted by T are observed by all threads at the same time. We investigate theoretical and practical properties of local linearizability and its relationship to many existing consistency conditions. We present a generic implementation method for locally linearizable data structures that uses existing linearizable data structures as building blocks. Our implementations show performance and scalability improvements over the original building blocks and outperform the fastest existing container-type implementations.

Cited by 4Open access

R-linearizability: An Extension of Linearizability to Replicated Objects

Fran Cois, Fran��cois Pacull Alain S · 2007

The paper extends linearizability, a consistency criterion for concurrent systems, to the replicated context, where availability and performance are enhanced by using redundant objects. The mode of operation on sets of replicas and the consistency criterion of Rlinearizability are defined. An implementation of Rlinearizable replicated atoms (on which only read and write operations are defined) is described. It is realized in the virtually synchronous model, based on a group view mechanism. This framework provides reliable multicast primitives enabling a fault-tolerant implementation. 1 Introduction Two problems are of growing importance as distributed systems become larger, with more objects, more cooperation among users, and new patterns of connectivity: maintaining consistency and managing replication of shared objects. Maintaining consistency requires to control concurrent access by different processes to the objects and to ensure atomicity in the presence of failures. Replicatio...

Cited by 0

Efficient Linearizability Monitoring

Parosh Aziz Abdulla, Sofia Grahn, Bengt Jönsson et al. · Proceedings of the ACM on Programming Languages · 2025

This paper revisits the fundamental problem of monitoring the linearizability of concurrent stacks, queues, sets, and multisets. Given a history of a library implementing one of these abstract data types, the monitoring problem is to answer whether the given history is linearizable. For stacks, queues, and (multi)sets, we present monitoring algorithms with complexities ( n 2 ), ( n log n ), and ( n ), respectively, where n is the number of operations in the input history. For stacks and queues, our results hold under the standard assumption of data-independence , i.e., the behavior of the library is not sensitive to the actual values stored in the data structure. Past works to solve the same problems have cubic time complexity and (more seriously) have correctness issues: they either (i) lack correctness proofs or (ii) have unsound correctness proofs (we present counter-examples of the correctness proofs), or (iii) have unsound algorithms. Our improved complexity results rely on substantially different algorithms for which we provide detailed proofs of correctness. We have implemented our stack and queue algorithms in LiMo (Linearizability Monitor). We evaluate LiMo and compare it with the state-of-the-art tool Violin – whose correctness proofs we have found errors in – which checks for linearizability violations. Our experimental evaluation confirms that LiMo outperforms Violin regarding both efficiency and scalability.

Cited by 2Open access

Replication-Aware Linearizability

Constantin Enea, Süha Orhun Mutluergil, Gustavo Petri et al. · arXiv (Cornell University) · 2019

Geo-distributed systems often replicate data at multiple locations to achieve availability and performance despite network partitions. These systems must accept updates at any replica and propagate these updates asynchronously to every other replica. Conflict-Free Replicated Data Types (CRDTs) provide a principled approach to the problem of ensuring that replicas are eventually consistent despite the asynchronous delivery of updates. We address the problem of specifying and verifying CRDTs, introducing a new correctness criterion called Replication-Aware Linearizability. This criterion is inspired by linearizability, the de-facto correctness criterion for (shared-memory) concurrent data structures. We argue that this criterion is both simple to understand, and it fits most known implementations of CRDTs. We provide a proof methodology to show that a CRDT satisfies replication-aware linearizability which we apply on a wide range of implementations. Finally, we show that our criterion can be leveraged to reason modularly about the composition of CRDTs.

Cited by 3Open access

Efficient Linearizability Monitoring

Parosh Aziz Abdulla, Sofia Grahn, Bengt Jönsson et al. · ArXiv.org · 2025

This paper revisits the fundamental problem of monitoring the linearizability of concurrent stacks, queues, sets, and multisets. Given a history of a library implementing one of these abstract data types, the monitoring problem is to answer whether the given history is linearizable. For stacks, queues, and (multi)sets, we present monitoring algorithms with complexities $\mathcal{O}(n^2)$, $\mathcal{O}(n\; log\, n)$, and $\mathcal{O}{(n)}$, respectively, where $n$ is the number of operations in the input history. For stacks and queues, our results hold under the standard assumption of {\it data-independence}, i.e., the behavior of the library is not sensitive to the actual values stored in the data structure. Past works to solve the same problems have cubic time complexity and (more seriously) have correctness issues: they either (i) lack correctness proofs or (ii) the suggested correctness proofs are erroneous (we present counter-examples), or (iii) have incorrect algorithms. Our improved complexity results rely on substantially different algorithms for which we provide detailed proofs of correctness. We have implemented our stack and queue algorithms in LiMo (Linearizability Monitor). We evaluate LiMo and compare it with the state-of-the-art tool Violin -- whose correctness proofs we have found errors in -- which checks for linearizability violations. Our experimental evaluation confirms that LiMo outperforms Violin regarding both efficiency and scalability.

Cited by 0Open access

Aspect-oriented linearizability proofs

Soham Chakraborty, Thomas A. Henzinger, Ali Sezgin et al. · Logical Methods in Computer Science · 2015

Linearizability of concurrent data structures is usually proved by monolithic simulation arguments relying on the identification of the so-called linearization points. Regrettably, such proofs, whether manual or automatic, are often complicated and scale poorly to advanced non-blocking concurrency patterns, such as helping and optimistic updates. In response, we propose a more modular way of checking linearizability of concurrent queue algorithms that does not involve identifying linearization points. We reduce the task of proving linearizability with respect to the queue specification to establishing four basic properties, each of which can be proved independently by simpler arguments. As a demonstration of our approach, we verify the Herlihy and Wing queue, an algorithm that is challenging to verify by a simulation proof.

Cited by 25Open access

Linearizability with Ownership Transfer

Alexey Gotsman, Hongseok Yang · Logical Methods in Computer Science · 2013

Linearizability is a commonly accepted notion of correctness for libraries of concurrent algorithms. Unfortunately, it assumes a complete isolation between a library and its client, with interactions limited to passing values of a given data type. This is inappropriate for common programming languages, where libraries and their clients can communicate via the heap, transferring the ownership of data structures, and can even run in a shared address space without any memory protection. In this paper, we present the first definition of linearizability that lifts this limitation and establish an Abstraction Theorem: while proving a property of a client of a concurrent library, we can soundly replace the library by its abstract implementation related to the original one by our generalisation of linearizability. This allows abstracting from the details of the library implementation while reasoning about the client. We also prove that linearizability with ownership transfer can be derived from the classical one if the library does not access some of data structures transferred to it by the client.

Cited by 9Open access

Linearizability on Datalog Programs

Foto Afrati, Manolis Gergatsoulis, Francesca Toni · 2007

We study the problem of transforming database queries into a special class of database logic programs (Datalog programs), namely linear Datalog programs, whose clauses have at most one intentional atom in their bodies. In particular we investigate linearisability of (database queries corresponding to) piecewise linear Datalog programs and chain queries: a) We prove that piecewise linear Datalog programs can always be transformed into linear Datalog programs, by virtue of an algorithm which performs the transformation automatically. The algorithm relies upon conventional logic program transformation techniques. b) We identify a new class of linearisable chain queries, referred to as pseudoregular, and prove their linearisability constructively, by generating, for any given pseudo-regular chain query, the Datalog program corresponding to it. Keywords: Datalog programs, program transformation, program optimisation, linearisability, deductive databases, database queries. ? This researc...

Cited by 0

Linearizability of saturated polynomials

Lukáš Geyer · Indiana University Mathematics Journal · 2019

Brjuno and R\"ussmann proved that every irrationally indifferent fixed point of an analytic function with a Brjuno rotation number is linearizable, and Yoccoz proved that this is sharp for quadratic polynomials. Douady conjectured that this is sharp for all rational functions of degree at least 2, i.e., that non-M\"obius rational functions cannot have Siegel disks with non-Brjuno rotation numbers. We prove that Douady's conjecture holds for the class of polynomials for which the number of infinite tails of critical orbits in the Julia set equals the number of irrationally indifferent cycles. As a corollary, Douady's conjecture holds for the polynomials $P(z) = z^d + c$ for all $d > 1$ and all complex $c$.

Cited by 7Open access

Intermediate Jacobians and linearizability

Tudor Ciurca, Sho Tanimoto, Yuri Tschinkel · arXiv (Cornell University) · 2024

We develop an equivariant version of the formalism of intermediate Jacobian torsor obstructions, and apply it to conic bundles over rational surfaces, quadric surface bundles over $\mathbb P^1$, and Fano threefolds.

Cited by 0Open access

On Register Linearizability and Termination

Vassos Hadzilacos, Xing Hu, Sam Toueg · arXiv (Cornell University) · 2021

In a seminal work, Golab et al. showed that a randomized algorithm that works with atomic objects may lose some of its properties if we replace the atomic objects that it uses with linearizable objects. It was not known whether the properties that can be lost include the important property of termination (with probability 1). In this paper, we first show that, for randomized algorithms, termination can indeed be lost. Golab et al. also introduced strong linearizability, and proved that strongly linearizable objects can be used as if they were atomic objects, even for randomized algorithms: they preserve the algorithm's correctness properties, including termination. Unfortunately, there are important cases where strong linearizability is impossible to achieve. In particular, Helmi et al. MWMR registers do not have strongly linearizable implementations from SWMR registers. So we propose a new type of register linearizability, called write strong-linearizability, that is strictly stronger than linearizability but strictly weaker than strong linearizability. We prove that some randomized algorithms that fail to terminate with linearizable registers, work with write strongly-linearizable ones. In other words, there are cases where linearizability is not sufficient but write strong-linearizability is. In contrast to the impossibility result mentioned above, we prove that write strongly-linearizable MWMR registers are implementable from SWMR registers. Achieving write strong-linearizability, however, is harder than achieving just linearizability: we give a simple implementation of MWMR registers from SWMR registers and we prove that this implementation is linearizable but not write strongly-linearizable. Finally, we prove that any linearizable implementation of SWMR registers is necessarily write strongly-linearizable; this holds for shared-memory, message-passing, and hybrid systems.

Cited by 0Open access