4,209 research outputs found
Anonymous Obstruction-free -Set Agreement with Atomic Read/Write Registers
The -set agreement problem is a generalization of the consensus problem.
Namely, assuming each process proposes a value, each non-faulty process has to
decide a value such that each decided value was proposed, and no more than
different values are decided. This is a hard problem in the sense that it
cannot be solved in asynchronous systems as soon as or more processes may
crash. One way to circumvent this impossibility consists in weakening its
termination property, requiring that a process terminates (decides) only if it
executes alone during a long enough period. This is the well-known
obstruction-freedom progress condition. Considering a system of {\it
anonymous asynchronous} processes, which communicate through atomic {\it
read/write registers only}, and where {\it any number of processes may crash},
this paper addresses and solves the challenging open problem of designing an
obstruction-free -set agreement algorithm with atomic registers
only. From a shared memory cost point of view, this algorithm is the best
algorithm known so far, thereby establishing a new upper bound on the number of
registers needed to solve the problem (its gain is with respect to the
previous upper bound). The algorithm is then extended to address the repeated
version of -set agreement. As it is optimal in the number of atomic
read/write registers, this algorithm closes the gap on previously established
lower/upper bounds for both the anonymous and non-anonymous versions of the
repeated -set agreement problem. Finally, for 1 \leq x\leq k
\textless{} n, a generalization suited to -obstruction-freedom is also
described, which requires atomic registers only
Fault-Tolerant Consensus in Unknown and Anonymous Networks
This paper investigates under which conditions information can be reliably
shared and consensus can be solved in unknown and anonymous message-passing
networks that suffer from crash-failures. We provide algorithms to emulate
registers and solve consensus under different synchrony assumptions. For this,
we introduce a novel pseudo leader-election approach which allows a
leader-based consensus implementation without breaking symmetry
Eventual election of multiple leaders for solving consensus in anonymous systems
In classical distributed systems, each process has a unique identity. Today, new distributed systems have emerged where a unique identity is not always possible to be assigned to each process. For example, in many sensor networks a unique identity is not possible to be included in each device due to its small storage capacity, reduced computational power, or the huge number of devices to be identified. In these cases, we have to work with anonymous distributed systems where processes cannot be identified. Consensus cannot be solved in classical and anonymous asynchronous distributed systems where processes can crash. To bypass this impossibility result, failure detectors are added to these systems. It is known that ? is the weakest failure detector class for solving consensus in classical asynchronous systems when amajority of processes never crashes. Although A? was introduced as an anonymous version of ?, to find the weakest failure detector in anonymous systems to solve consensus when amajority of processes never crashes is nowadays an open question. Furthermore, A? has the important drawback that it is not implementable. Very recently, A? has been introduced as a counterpart of ? for anonymous systems. In this paper, we show that the A? failure detector class is strictly weaker than A? (i.e., A? provides less information about process crashes than A?). We also present in this paper the first implementation of A? (hence, we also show that A? is implementable), and, finally, we include the first implementation of consensus in anonymous asynchronous systems augmented with A? and where a majority of processes does not crash
Building Regular Registers with Rational Malicious Servers and Anonymous Clients
The paper addresses the problem of emulating a regular register in a synchronous distributed system where clients invoking and operations are anonymous while server processes maintaining the state of the register may be compromised by rational adversaries (i.e., a server might behave as rational malicious Byzantine process). We first model our problem as a Bayesian game between a client and a rational malicious server where the equilibrium depends on the decisions of the malicious server (behave correctly and not be detected by clients vs returning a wrong register value to clients with the risk of being detected and then excluded by the computation). We prove such equilibrium exists and finally we design a protocol implementing the regular register that forces the rational malicious server to behave correctly
- …