We introduce GCAS, a natural generalization of the well-known compare-and-swap (CAS) object. Intuitively, GCAS just replaces the fixed equality test of CAS with a parametrized comparator chosen from {<, =, >}. To showcase the utility of GCAS, we present two space-efficient wait-free universal constructions for systems where the number of participating processes is unknown and may be infinite (the infinite-arrival model). The first has space-complexity linear in the number of processes that have participated so far, while the second has space-complexity linear in the point contention but assumes bounded concurrency. To the best of our knowledge, these are the first wait-free universal constructions that achieve this space complexity in the infinite-arrival model. To achieve space complexity linear in the point contention, our second universal construction uses a novel memory recycling scheme that works in the infinite-arrival model with bounded concurrency. The ideas behind this recycling scheme could be of more general use.

Motivated by recent distributed systems technology, Aguilera et al. introduced a hybrid model of distributed computing, called the message-and-memory model or m&m model for short. In this model, processes can communicate by message passing and also by accessing some shared memory (e.g., through some RDMA connections). We first consider the basic problem of implementing an atomic single-writer multi-reader (SWMR) register shared by all the processes in m&m systems. Specifically, we give an algorithm that implements such a register in m&m systems and show that it is optimal in the number of process crashes that it tolerates. This generalizes the well-known ABD implementation of an atomic SWMR register in a pure message-passing system. We then combine our register implementation for m&m systems with a randomized consensus algorithm of Aspnes and Herlihy, and obtain a randomized consensus algorithm for m&m systems that is also optimal in the number of process crashes that it can tolerate. Finally, we determine the minimum number of RDMA connections that is sufficient to implement a SWMR register, or solve randomized consensus, in an m&m system with t process crashes, for any given t .

It is well-known that, for deterministic algorithms, linearizable objects can be used as if they were atomic objects. As pointed out by Golab, Higham, and Woelfel, however, a randomized algorithm that works with atomic objects may lose some of its properties if we replace the atomic objects that it uses with objects that are only linearizable. It was not known whether the properties that can be lost include the all-important property of termination (with probability 1). In this paper, we first show that a randomized algorithm can indeed lose its termination property if we replace the atomic registers that it uses with linearizable ones.

Motivated by recent distributed systems technology, Aguilera et al. introduced a hybrid model of distributed computing, called message-and-memory model or m&m model for short [Marcos K. Aguilera et al., 2018]. In this model, processes can communicate by message passing and also by accessing some shared memory. We consider the basic problem of implementing an atomic single-writer multi-reader (SWMR) register shared by all the processes in m&m systems. Specifically, we give an algorithm that implements such a register in m&m systems and show that it is optimal in the number of process crashes that it can tolerate. This generalizes the well-known implementation of an atomic SWMR register in a pure message-passing system [Attiya et al., 1995].

A recent work showed that, for all n and k, there is a linearizable (n,k)-set agreement object O_L that is equivalent to the (n,k)-set agreement task [David Yu Cheng Chan et al., 2017]: given O_L, it is possible to solve the (n,k)-set agreement task, and given any algorithm that solves the (n,k)-set agreement task (and registers), it is possible to implement O_L. This linearizable object O_L, however, is not deterministic. It turns out that there is also a deterministic (n,k)-set agreement object O_D that is equivalent to the (n,k)-set agreement task, but this deterministic object O_D is not linearizable. This raises the question whether there exists a deterministic and linearizable (n,k)-set agreement object that is equivalent to the (n,k)-set agreement task. Here we show that in general the answer is no: specifically, we prove that for all n ≥ 4, every deterministic linearizable (n,2)-set agreement object is strictly stronger than the (n,2)-set agreement task. We prove this by showing that, for all n ≥ 4, every deterministic and linearizable (n,2)-set agreement object (together with registers) can be used to solve 2-consensus, whereas it is known that the (n,2)-set agreement task cannot do so. For a natural subset of (n,2)-set agreement objects, we prove that this result holds even for n = 3.

Since the early days of the shared memory model for distributed computing, researchers have sought a simple and precise characterization of an object's ability to implement other objects in a wait-free manner.

The set agreement power of a shared object O describes O's ability to solve set agreement problems: it is the sequence (n_1, n_2, ..., n_k, ...) such that, for every k >= 1, using O and registers one can solve the k-set agreement problem among at most n_k processes. It has been shown that the ability of an object O to implement other objects is not fully characterized by its consensus number the first component of its set agreement power) [1, 3, 14]. This raises the following natural question: is the ability of an object O to implement other objects fully characterized by its set agreement power? We prove that the answer is no: every level n >= 2 of Herlihy's consensus hierarchy has two objects that have the same set agreement power but are not equivalent, i.e., at least one cannot implement the other. We also show that every level n >= 2 of the consensus hierarchy contains a deterministic object O_n with some set agreement power (n_1, n_2, ..., n_k, ...) such that being able to solve the k-set agreement problems among n_k processes, for all k >= 1, is not enough to implement O_n.

We first prove that there are uncountably many objects with distinct computational powers. More precisely, we show that there is an uncountable set of objects such that for any two of them, at least one cannot be implemented from the other (and registers) in a wait-free manner. We then strengthen this result by showing that there are uncountably many linearizable objects with distinct computational powers. To do so, we prove that for all positive integers n and k, there is a linearizable object that is computationally equivalent to the k-set agreement task among n processes. To the best of our knowledge, these are the first linearizable objects proven to be computationally equivalent to set agreement tasks.

The problem. We consider the problem of implementing a consistent replicated object in a partially synchronous message passing distributed system susceptible to process and communication failures. The object is a generic shared resource, such as a data structure, a file, or a lock. The processes implementing the replicated object access it by applying operations to it at unpredictable times and potentially concurrently.1 The object should be linearizable: it should behave as if each operation applied to it takes effect at a distinct instant in time during the interval between its invocation and its response.

We define deterministic abortable (DA) objects, which guarantee that operations complete normally if executed solo, but may abort if executed concurrently with other operations. An operation that aborts has no effect on the object. This simple and attractive behavior is reminiscent of transactional memory, database transactions, and abortable mutual exclusion --- techniques in which a process can, under contention, ``bail out'' of the computation without leaving a trace.

We define quittable consensus, a natural variation of the consensus problem, where processes have the option to agree on “quit” if failures occur, and we relate this problem to the well-known problem of nonblocking atomic commit. We then determine the weakest failure detectors for these two problems in all environments, regardless of the number of faulty processes.

We introduce abortable and query-abortable objects, intended for asynchronous shared-memory systems with low contention. These objects behave like ordinary objects when accessed sequentially, but may abort operations when accessed concurrently. An aborted operation may or may not take effect, i.e., cause a state transition, and it returns no indication of which possibility occurred. Since this uncertainty is problematic, a query-abortable object supports a QUERY operation that each process can use to determine its last non-QUERY operation on the object that caused a state transition, and the response associated with this state transition. Query-abortable objects can easily implement obstruction-free objects (introduced by Herlihy, Luchangco and Moir) and pausable objects (introduced by Attiya, Guerraoui and Kouznetsov).

We investigate the complexity of greedy routing in uniform ring-based random graphs, a general model that captures many topologies that have been proposed for peer-to-peer and social networks. In this model the nodes form a ring; for each node u we independently draw the set of distances along the ring from u to its "long-range contacts" from a fixed distribution P (the same for all and connect u to the corresponding nodes as well as its ring successor. We prove that, for any distribution P, in a graph with n nodes and an expected number of long-range contacts per node constructed in this fashion, the expected number of steps for greedy routing is Ω((log2n)/lalog*n), for some constant a > 1. This improves an earlier lower bound of Ω((log2n)/llog log n) by Aspnes et al. and is very close to the upper bound of O((log2n)/l) achieved by greedy routing in Kleinberg's (one-dimensional) "small-world" networks, a particular instance of uniform ring-based random graphs.

We consider asynchronous multiprocessors where processes communicate only by reading or writing shared memory. We show how to implement consensus, all comparison primitives (such as CAS and TAS), and load-linked/store-conditional using only a constant number of remote memory references (RMRs), in both the cache-coherent and the distributed-shared-memory models of such multiprocessors. Our implementations are blocking, rather than wait-free: they ensure progress provided all processes that invoke the implemented primitive are live.

We determine the weakest failure detector to solve nonuniform consensus in any environment, i.e., regardless of the number of faulty processes. Together with previous results, this closes all aspects of the following question: What is the weakest failure detector to solve (uniform or nonuniform) consensus in any environment?

We present a scheme for evenly partitioning the key space in distributed hash tables among the participating nodes. The scheme is based on the multiple random choices paradigm [3, 19], and handles both node joins and leaves. It achieves, with high probability, a ratio of at most 4 between the loads of the most and least burdened nodes, in the face or arbitrary node arrivals and departures. Each join or leave operation incurs message cost that is, with high probability, Oh(log2n), where n is the number of nodes, and causes the relocation of keys from at most one node (for joins) or three nodes (for leaves). A version of our scheme is suitable for heterogeneous systems, where the capacities of nodes to serve keys can vary widely.

We determine the weakest failure detectors to solve several fundamental problems in distributed message-passing systems, for all environments -- i.e., regardless of the number and timing of crashes. The problems that we consider are: implementing an atomic register, solving consensus, solving quittable consensus (a variant of consensus in which processes have the option to decide 'quit' if a failure occurs), and solving non-blocking atomic commit.

We study the consensus problem, which requires multiple processes with different input values to agree on one of these values, in the context of asynchronous shared memory systems. Prior research focussed either on t-resilient solutions of this problem (which must be correct even if up to t processes crash) or on wait-free solutions (which must be correct despite the crash of any number of processes). In this paper, we show that these two forms of solvability are closely related. Specifically, for all $n > t \ge 2$ and all sets ${\mathcal{S}}$ of shared object types (that include simple read/write registers), there is a t-resilient solution to n-process consensus using objects of types in ${\mathcal{S}}$ if and only if there is a wait-free solution to (t + 1)-process consensus using objects of types in ${\mathcal{S}}$. Our proof of this equivalence uses another result derived in this paper, which is of independent interest. Roughly speaking, this result states that a wait-free solution to (n - 1)-process consensus is never necessary in designing a wait-free solution to n-process consensus, regardless of the types of objects available. More precisely, for all $n \ge 2$ and all sets ${\mathcal{S}}$ of shared object types (that include simple read/write registers), if there is a wait-free solution to n-process consensus that uses a wait-free solution to (n - 1)-process consensus and objects of types in ${\mathcal{S}}$, then there is a wait-free solution to n-process consensus that uses only objects of types in ${\mathcal{S}}$.

Group mutual exclusion is a natural problem, formulated by Joung in 1998, that generalises the classical mutual exclusion problem. In group mutual exclusion a process requests a “session” before entering its critical section; processes are allowed to be in the critical section simultaneously provided they have requested the same session. To rule out solutions that cause processes to delay each other even when they all request the same session, group mutual exclusion algorithms must satisfy a property called “concurrent entering”. Joung stated this property only informally. Keane and Moir later gave a precise statement of this property and devised a simple group mutual exclusion algorithm that satisfies it.

A wait-free hierarchy ACM Transactions on Programming Languages and Systems, 11 (1991), pp. 124--149; Proceedings of the 12th ACM Symposium on Principles of Distributed Computing, 1993, pp. 145--158] classifies object types on the basis of their strength in supporting wait-free implementations of other types. Such a hierarchy is robust if it is impossible to implement objects of types that it classifies as "strong" by combining objects of types that it classifies as "weak." We prove that if nondeterministic types are allowed, the only wait-free hierarchy that is robust is the trivial one, which lumps all types into a single level. In particular, the consensus hierarchy (the most closely studied wait-free hierarchy) is not robust. Our result implies that, in general, it is not possible to determine the power of a concurrent system that supports a given set of primitive object types by reasoning about the power of each primitive type in isolation.

In this paper we study the ability of shared object types to implement Consensus in asynchronous sharedmemory systems where at most one process may cresh.More specifically, we consider the following question: Let n z 3 and S be a set of object types that can be used to solve one-resilient Consensus among n processes.Can S always be used to solve one-resilient Consensus among n -1 processes?We prove that for n = 3 the answer is negative, even if S consists only of deterministic types.(This strengthens an earlier result by the first author proving the same fact for nondetermtnistic types.)lVe also prove that, in contrast, for n >3 the answer to the above question is affirmative. Background and overviewIn this paper we consider some questions concerning fault-tolerant implementations of Consensus in asynchronous shared-memory systems.In such systems, some number of processes communicate with each other by accessing shared typed objects.Processes take steps in a completely asynchronous manner.In one step, a process may invoke an operation on a shared object.Thk causes the object to atomically change its state and return a response to the process invoking the operation.The new state entered by the object and the response returned to the operation are determined by the specification of the type to which the object belongs.A process may crush -i.e., stop taking steps "Supportedby a CanadianCommonwealthScholarship.

A wait-free hierarchy [Her91, Jay93] classifies object types on the basis of their strength in supporting waitfree implementations of other types.(In the context of the present paper, an implementation may use any number of objects of the given types, as well as read/write registers.)Such a hierarchy is robust if it is impossible to implement objects of types that it classifies as "strong" by combining objects of types that it classifies as "weak".We prove that, if nondeterministic types are allowed, the only wait-free hierarchy that is robust is the trivial one, which lumps all types into a single level.In particular, the Consensus hierarchy (the most closely studied wait-free hierarchy) is not robust.Our result implies that, in general, it is not possible to determine the power of a concurrent system that supports a given set of primitive object types by reasoning about the power of each primitive type in isolation.

Projet REFLECS

We determine what information about failures is necessary and sufficient to solve Consensus in asynchronous distributed systems subject to crash failures. In Chandra and Toueg [1996], it is shown thatW, a failure detector that provides surprisingly little information about which processes have crashed, is sufficient to solve Consensus in asynchronous systems with a majority of correct processes. In this paper, we prove that to solve Consensus, any failure detector has to provide at least as much information as W. Thus, W is indeed the weakest failure detector for solving Consensus in asynchronous systems with a majority of correct processes.

It was shown by Yannakakis that a locking policy is not safe if and only if there exists a canonical non-serializable schedule of transactions running according to the rules of the policy in which all the transactions except one are executed serially [Yan82]. In the present paper, we study the generalization of this result to a dynamic database, that is, a database that may undergo insertions and deletions of entities. We illustrate the utility of this generalization by applying it to obtain correctness proofs of three locking policies that handle dynamic databases. Keywords: Concurrency Control, Correctness Issues Safe Locking Policies for Dynamic Databases 1 1 Introduction A locking policy is called safe if any concurrent execution of a set of transactions while locked according to that policy is guaranteed to be correct. Yannakakis showed that a locking policy is not safe if and only if there exists a canonical non-serializable schedule in which all transactions except one ...

Large knowledge bases that are intended for applications such as CAD, corporate repositories or process control will have to be shared by multiple users. For these systems to scale up, to give acceptable performance and to exhibit consistent behavior, it is mandatory to synchronize user transactions using a concurrency control algorithm. In this paper, we examine a novel concurrency control policy called Dynamic Directed Graph (or DDG) policy that effectively exploits the rich semantic structure of a knowledge base.

We seek two properties in such a hierarchy:(1) If a type T is at level N, then, for all types T',

We determine what information about failures is necessary and sufficient to solve Consensus in asynchronous distributed systems subject to crash failures.In [CT91], we proved that OVV, a failure

Article Free Access Share on Message-optimal protocols for byzantine agreement (extended abstract) Authors: Vassos Hadzilacos Computer Systems Research Institute, University of Toronto, 10 King's College Road, Toronto, Ontario M5S 1A4 CanadaComputer Systems Research Institute University of Toronto 10 King's College Road Toronto, Ontario M5S 1A4 Canada Computer Systems Research Institute, University of Toronto, 10 King's College Road, Toronto, Ontario M5S 1A4 CanadaComputer Systems Research Institute University of Toronto 10 King's College Road Toronto, Ontario M5S 1A4 CanadaView Profile , Joseph Y. Halpern IBM Almaden Research Center, Department K53/802, 650 Harry Road, San Jose, California IBM Almaden Research Center, Department K53/802, 650 Harry Road, San Jose, CaliforniaView Profile Authors Info & Claims PODC '91: Proceedings of the tenth annual ACM symposium on Principles of distributed computingJuly 1991 Pages 309–323https://doi.org/10.1145/112600.112626Published:01 July 1991Publication History 12citation266DownloadsMetricsTotal Citations12Total Downloads266Last 12 Months38Last 6 weeks5 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

We present an algorithm for the mutual-exclusion problem that satisfies the "first-come-firstserved" property and requires only five shared bits per participant.The algorithm works in a model of concurrency that does not assume atomic operations.

We propose a formal model of concurrency control in object bases. An object base is like a database except that information is represented in terms of "objects" that encapsulate both data and the procedures through which the data can be manipulated. The model generalises the classical model of database concurrency control: it allows for nested transactions (as opposed to flat transactions) which may issue arbitrary operations (as opposed to just read and write operations). We establish an analogue to the classical serialisability theorem and use it to derive simple proofs of correctness of two concurrency control algorithms for object bases, namely Nested Two-Phase Locking (Moss' algorithm) and Nested Timestamp Ordering (Reed's algorithm). Concurrency control in object bases can be viewed as a combination of intra-object and inter-object synchronisation. The former ensures that each object's own methods are executed in serialisable fashion; the latter ensures the compatibility of trans...

Reliable concurrent processing of transactions in a database system is examined. Since serializability, the conventional concurrency control correctness criterion, is not adequate in the presence of common failures, another theory of correctness is proposed, involving the concepts of commit serializability, recoverability, and resiliency.

Article Free Access Share on A knowledge-theoretic analysis of atomic commitment protocols Author: V. Hadzilacos Department of Computer Science and Computer Systems Research Institute, University of Toronto Department of Computer Science and Computer Systems Research Institute, University of TorontoView Profile Authors Info & Claims PODS '87: Proceedings of the sixth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systemsJune 1987Pages 129–134https://doi.org/10.1145/28659.28672Published:01 June 1987Publication History 40citation306DownloadsMetricsTotal Citations40Total Downloads306Last 12 Months22Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Publisher SiteeReaderPDF

Article Free Access Share on An operational model for database system reliability Author: Vassos Hadzilacos Harvard University, Cambridge, MA Harvard University, Cambridge, MAView Profile Authors Info & Claims PODS '83: Proceedings of the 2nd ACM SIGACT-SIGMOD symposium on Principles of database systemsMarch 1983 Pages 244–257https://doi.org/10.1145/588058.588086Online:21 March 1983Publication History 12citation276DownloadsMetricsTotal Citations12Total Downloads276Last 12 Months3Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Article Free Access Share on An algorithm for minimizing roll back cost Author: Vassos Hadzilacos Harvard University, Cambridge, MA Harvard University, Cambridge, MAView Profile Authors Info & Claims PODS '82: Proceedings of the 1st ACM SIGACT-SIGMOD symposium on Principles of database systemsMarch 1982 Pages 93–97https://doi.org/10.1145/588111.588128Online:29 March 1982Publication History 12citation246DownloadsMetricsTotal Citations12Total Downloads246Last 12 Months7Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF