5 research outputs found
Multi-writer consistency conditions for shared memory objects
Regularity is a shared memory consistency condition that has received considerable attention, notably in connection with quorum-based shared memory. Lamport's
original definition of regularity assumed a single-writer model, however, and is not
well defined when each shared variable may have multiple writers. In this thesis, we
address this need by formally extending the notion of regularity to a multi-writer
model. We have shown that the extension is not trivial. While there exist various
ways to extend the single-writer definition, the resulting definitions will have different
strengths. Specifically, we give several possible definitions of regularity in the presence
of multiple writers. We then present a quorum-based algorithm to implement each of
the proposed definitions and prove them correct. We study the relationships between
these definitions and a number of other well-known consistency conditions, and give
a partial order describing the relative strengths of these consistency conditions. Finally, we provide a practical context for our results by studying the correctness of two
well-known algorithms for mutual exclusion under each of our proposed consistency
conditions
Robust Emulations of Shared Memory in a Crash-Recovery Model
A shared memory abstraction can be robustly emulated over an asynchronous message passing system where any process can fail by crashing and possibly recover (crash-recovery model), by having (a) the processes exchange messages to synchronize their read and write operations and (b) log key information on their local stable storage. This paper extends the existing atomicity consistency criterion defined for multi-writer/multi-reader shared memory in a crash-stop model, by providing two new criteria for the crash-recovery model. We introduce lower bounds on the log-complexity for each of the two corresponding types of robust shared memory emulations. We demonstrate that our lower bounds are tight by providing algorithms that match them. Besides being optimal, these algorithms have the same message and time complexity as their most efficient counterpart we know of in the crash-stop model