Ophir Rachman

Atomic Snapshots in O ( n log n ) Operations

The atomic snapshot object is an important primitive used for the design and verification of wait-free algorithms in shared-memory distributed systems. A snapshot object is a shared data structure partitioned into segments. Processors can either update an individual segment or instantaneously scan all segments of the object. This paper presents an implementation of an atomic snapshot object in which each high-level operation (scan or update) requires O(n log n) low-level operations on atomic read/write registers.

Atomic snapshots using lattice agreement

SummaryThesnapshot object is an important tool for constructing wait-free asynchronous algorithms. We relate the snapshot object to thelattice agreement decision problem. It is shown that any algorithm for solving lattice agreement can be transformed into an implementation of a snapshot object. The overhead cost of this transformation is only a linear number of read and write operations on atomic single-writer multi-reader registers. The transformation uses an unbounded amount of shared memory. We present a deterministic algorithm for lattice agreement that usedO (log2n) operations on 2-processorTest & Set registers, plusO (n) operations on atomic single-writer multi-reader registers. The shared objects are used by the algorithm in adynamic mode, that is, the identity of the processors that access each of the shared objects is determined dynamically during the execution of the algorithm. By a randomized implementation of 2-processorsTest & Set registers from atomic registers, this algorithm implies a randomized algorthm for lattice agreement that uses an expected number ofO (n) operations on (dynamic) atomic single-writer multi-reader registers. Combined with our transformation this yields implementations of atomic snapshots with the same complexity.

Randomized Consensus in Expected O(n²log n) Operations

We consider asynchronous shared memory distributed systems, and investigate coordination problems in this model. We provide a waitfree randomized consensus protocol that requires an expected O(n2 log n) atomic operations.

Efficient atomic snapshots using lattice agreement

The snapshot object is an important tool for the construction of wait-free asynchronous algorithms. We relate the snapshot object to the lattice agreement decision problem. It is shown that any algorithm for solving lattice agreement can be used to implement the snapshot object. Several new lattice agreement algorithms are presented. The most efficient is a lattice agreement algorithm (and hence, an implementation of snapshot objects) using O(log2n) operations on 2-processor Tesl&Set registers, plus a linear number of operations on atomic single-writer multi-reader registers.

Atomic snapshots in O(n log n) operations

The atomic snapshot object is an important primitive used for the design and veri- cation of wait-free algorithms in shared-memory distributed systems. A snapshot object is a shared data structure partitioned into segments. Processors can either update an individual segment or instantaneously scan all segments of the object. This paper presents an implementation of an atomic snapshot object in which each high-level operation (scan or update) requires O(n logn) low-level operations on atomic read/write registers.

Anomalies in the Wait-Free Hierarchy

We consider the hierarchy of wait-free shared objects, and show that this hierarchy does not express the computational power of shared objects. We prove that there are objects that are classified high in the hierarchy, yet, they can not implement objects that are classified much lower in the hierarchy. Our main result is: for any two levels k1≥k2 in the hierarchy, there are shared objects X1 and X2 that belong to k1 and k2, respectively, such that X1 can not implement X2. (We allow the specifications of the shared objects to be non deterministic.) This result implies not only that the current definition of the wait-free hierarchy does not express the computational power of shared objects, but also that there is no other hierarchy that does.

Linear test sequences for detecting functionally faulty RAM's

Abstract In this paper we deal with the detection of functional faults in RAMs. We present a fault model which consists of decoder faults and memory array faults. We rectify and extend previous definitions of decoder faults, and we refine previous definitions of two coupling faults. Three test sequences of length 9N, 13N and 17N are presented with proofs of increasing detection capabilities. Our test sequence of length 17N is capable of detecting all combinations of faults in our model.