76 research outputs found
Memory-Anonymous Starvation-Free Mutual Exclusion: Possibility and Impossibility Results
In an anonymous shared memory system, all inter-process communications are
via shared objects; however, unlike in standard systems, there is no a priori
agreement between processes on the names of shared objects [14,15].
Furthermore, the algorithms are required to be symmetric; that is, the
processes should execute precisely the same code, and the only way to
distinguish processes is by comparing identifiers for equality. For such a
system, read/write registers are called anonymous registers. It is known that
symmetric deadlock-free mutual exclusion is solvable for any finite number of
processes using anonymous registers [1]. The main question left open in [14,15]
is the existence of starvation-free mutual exclusion algorithms for two or more
processes. We resolve this open question for memoryless algorithms, in which a
process that tries to enter its critical section does not use any information
about its previous attempts. Almost all known mutual exclusion algorithms are
memoryless. We show that (1) there is a symmetric memoryless starvation-free
mutual exclusion algorithm for two processes using anonymous
registers if and only if is odd; and (2) there is no symmetric memoryless
starvation-free mutual exclusion algorithm for processes using (any
number of) anonymous registers. Our impossibility result is the only example of
a system with fault-free processes, where global progress (i.e.,
deadlock-freedom) can be ensured, while individual progress to each process
(i.e., starvation-freedom) cannot. It complements a known result for systems
with failure-prone processes, that there are objects with lock-free
implementations but without wait-free implementations [2,5].Comment: DISC 2023 versio
Constant RMR Group Mutual Exclusion for Arbitrarily Many Processes and Sessions
Group mutual exclusion (GME), introduced by Joung in 1998, is a natural synchronization problem that generalizes the classical mutual exclusion and readers and writers problems. In GME a process requests a session before entering its critical section; processes are allowed to be in their critical sections simultaneously provided they have requested the same session.
We present a GME algorithm that (1) is the first to achieve a constant Remote Memory Reference (RMR) complexity for both cache coherent and distributed shared memory machines; and (2) is the first that can be accessed by arbitrarily many dynamically allocated processes and with arbitrarily many session names. Neither of the existing GME algorithms satisfies either of these two important properties. In addition, our algorithm has constant space complexity per process and satisfies the two strong fairness properties, first-come-first-served and first-in-first-enabled. Our algorithm uses an atomic instruction set supported by most modern processor architectures, namely: read, write, fetch-and-store and compare-and-swap
Contention-Free Complexity of Shared Memory Algorithms
AbstractWorst-case time complexity is a measure of the maximum time needed to solve a problem over all runs. Contention-free time complexity indicates the maximum time needed when a process executes by itself, without competition from other processes. Since contention is rare in well-designed systems, it is important to design algorithms which perform well in the absence of contention. We study the contention-free time complexity of shared memory algorithms using two measures: step complexity, which counts the number of accesses to shared registers; and register complexity, which measures the number of different registers accessed. Depending on the system architecture, one of the two measures more accurately reflects the elapsed time. We provide lower and upper bounds for the contention-free step and register complexity of solving the mutual exclusion problem as a function of the number of processes and the size of the largest register that can be accessed in one atomic step. We also present bounds on the worst-case and contention-free step and register complexities of solving the naming problem. These bounds illustrate that the proposed complexity measures are useful in differentiating among the computational powers of different primitive
Better Sooner Rather Than Later
This article unifies and generalizes fundamental results related to
-process asynchronous crash-prone distributed computing. More precisely, it
proves that for every , assuming that process failures occur
only before the number of participating processes bypasses a predefined
threshold that equals (a participating process is a process that has
executed at least one statement of its code), an asynchronous algorithm exists
that solves consensus for processes in the presence of crash failures
if and only if . In a very simple and interesting way, the "extreme"
case boils down to the celebrated FLP impossibility result (1985, 1987).
Moreover, the second extreme case, namely , captures the celebrated mutual
exclusion result by E.W. Dijkstra (1965) that states that mutual exclusion can
be solved for processes in an asynchronous read/write shared memory system
where any number of processes may crash (but only) before starting to
participate in the algorithm (that is, participation is not required, but once
a process starts participating it may not fail). More generally, the
possibility/impossibility stated above demonstrates that more failures can be
tolerated when they occur earlier in the computation (hence the title).Comment: 10 page
Sequentially consistent versus linearizable counting networks
We compare the impact of timing conditions on implementing sequentially consistent and linearizable counters using (uniform) counting networks in distributed systems. For counting problems in application domains which do not require linearizability but will run correctly if only sequential consistency is provided, the results of our investigation, and their potential payoffs, are threefold: • First, we show that sequential consistency and linearizability cannot be distinguished by the timing conditions previously considered in the context of counting networks; thus, in contexts where these constraints apply, it is possible to rely on the stronger semantics of linearizability, which simplifies proofs and enhances compositionality. • Second, we identify local timing conditions that support sequential consistency but not linearizability; thus, we suggest weaker, easily implementable timing conditions that are likely to be sufficient in many applications. • Third, we show that any kind of synchronization that is too weak to support even sequential consistency may violate it significantly for some counting networks; hence
The notion of Timed Registers and its application to Indulgent Synchronization
A new type of shared object, called timed register, is proposed and used to design indulgent timing-based algorithms.A timed register generalizes the notion of an atomic register as follows: if a process invokes two consecutive operations on the same timed register which are a read followed by a write, then the write operation is executed only if it is invoked at most d time units after the read operation, where d is defined as part of the read operation. In this context, a timing-based algorithm is an algorithm whose correctness relies on the existence of a bound such that any pair of consecutive constrained read and write operations issued by the same process on the same timed register are separated by at most time units. An indulgent algorithm is an algorithm that always guarantees the safety properties, and ensures the liveness property as soon as the timing assumptions are satisfied. The usefulness of this new type of shared object is demonstrated by presenting simple and elegant indulgent timing-based algorithms that solve the mutual exclusion, -exclusion, adaptive renaming, test&set, and consensus problems. Interestingly, timed registers are universal objects in systems with process crashes and transient timing failures (i.e., they allow building any concurrent object with a sequential specification). The paper also suggests connections with schedulers and contention managers
- …