The notion of an anonymous shared memory (recently introduced in PODC 2017) considers that processes use different names for the same memory location. As an example, a location name A used by a process p and a location name B = A used by another process q can correspond to the very same memory location X, and similarly for the names B used by p and A used by q which may (or may not) correspond to the same memory location Y = X. Hence, there is permanent disagreement on the location names among processes. In this context, the PODC paper presented -among other results-a symmetric deadlock-free mutual exclusion (mutex) algorithm for two processes and a necessary condition on the size m of the anonymous memory for the existence of a symmetric deadlock-free mutex algorithm in an n-process system. This condition states that m must be greater than 1 and belong to the set M (n) = {m : ∀ ℓ : 1 < ℓ ≤ n : gcd(ℓ, m) = 1} (symmetric means that, while each process has its own identity, process identities can only be compared with equality).The present paper answers several open problems related to symmetric deadlock-free mutual exclusion in an n-process system (n ≥ 2) where the processes communicate through m registers. It first presents two algorithms. The first considers that the registers are anonymous read/write atomic registers and works for any m greater than 1 and belonging to the set M (n). Hence, it shows that this condition on m is both necessary and sufficient. The second algorithm considers that the registers are anonymous read/modify/write atomic registers. It assumes that m ∈ M (n). These algorithms differ in their design principles and their costs (measured as the number of registers which must contain the identity of a process to allow it to enter the critical section). The paper also shows that the condition m ∈ M (n) is necessary for deadlock-free mutex on top of anonymous read/modify/write atomic registers. It follows that, when m > 1, m ∈ M (n) is a tight characterization of the size of the anonymous shared memory needed to solve deadlock-free mutex, be the anonymous registers read/write or read/modify/write.

This paper presents a simple and efficient reliable broadcast algorithm for asynchronous message-passing systems made up of n processes, among which up to [Formula: see text] may behave arbitrarily (Byzantine processes). This algorithm requires two communication steps and n2 − 1 messages. When compared to Bracha’s algorithm, which is resilience optimal ([Formula: see text]) and requires three communication steps and [Formula: see text] messages, the proposed algorithm shows an interesting tradeoff between communication efficiency and t-resilience.

Abstract-This paper is on homonymous distributed systems where processes are prone to crash failures and have no initial knowledge of the system membership ("homonymous" means that several processes may have the same identifier). New classes of failure detectors suited to these systems are first defined. Among them, the classes HΩ and HΣ are introduced that are the homonymous counterparts of the classes Ω and Σ, respectively. (Recall that the pair Ω, Σ defines the weakest failure detector to solve consensus.) Then, the paper shows how HΩ and HΣ can be implemented in homonymous systems without membership knowledge (under different synchrony requirements). Finally, two algorithms are presented that use these failure detectors to solve consensus in homonymous asynchronous systems where there is no initial knowledge of the membership. One algorithm solves consensus with HΩ, HΣ , while the other uses only HΩ, but needs a majority of correct processes.Observe that the systems with unique identifiers and anonymous systems are extreme cases of homonymous systems from which follows that all these results also apply to these systems. Interestingly, the new failure detector class HΩ can be implemented with partial synchrony, while the analogous class AΩ defined for anonymous systems can not be implemented (even in synchronous systems). Hence, the paper provides us with the first proof showing that consensus can be solved in anonymous systems with only partial synchrony (and a majority of correct processes).

Wait-freedom and obstruction-freedom have received a lot of attention in the literature. These are symmetric progress conditions in the sense that they consider all processes as being "equal". Wait-freedom has allowed to rank the synchronization power of objects in presence of process failures, while (the weaker) obstruction-freedom allows for simpler and more efficient object implementations.This paper introduces the notion of asymmetric progress conditions. Given an object O in a shared memory system of n processes, we say that O satisfies (y, x