1,641 research outputs found
Complexity of Multi-Value Byzantine Agreement
In this paper, we consider the problem of maximizing the throughput of
Byzantine agreement, given that the sum capacity of all links in between nodes
in the system is finite. We have proposed a highly efficient Byzantine
agreement algorithm on values of length l>1 bits. This algorithm uses error
detecting network codes to ensure that fault-free nodes will never disagree,
and routing scheme that is adaptive to the result of error detection. Our
algorithm has a bit complexity of n(n-1)l/(n-t), which leads to a linear cost
(O(n)) per bit agreed upon, and overcomes the quadratic lower bound
(Omega(n^2)) in the literature. Such linear per bit complexity has only been
achieved in the literature by allowing a positive probability of error. Our
algorithm achieves the linear per bit complexity while guaranteeing agreement
is achieved correctly even in the worst case. We also conjecture that our
algorithm can be used to achieve agreement throughput arbitrarily close to the
agreement capacity of a network, when the sum capacity is given
An approach to rollback recovery of collaborating mobile agents
Fault-tolerance is one of the main problems that must be resolved to improve the adoption of the agents' computing paradigm. In this paper, we analyse the execution model of agent platforms and the significance of the faults affecting their constituent components on the reliable execution of agent-based applications, in order to develop a pragmatic framework for agent systems fault-tolerance. The developed framework deploys a communication-pairs independent check pointing strategy to offer a low-cost, application-transparent model for reliable agent- based computing that covers all possible faults that might invalidate reliable agent execution, migration and communication and maintains the exactly-one execution property
Recommended from our members
Fault tolerance via diversity for off-the-shelf products: A study with SQL database servers
If an off-the-shelf software product exhibits poor dependability due to design faults, then software fault tolerance is often the only way available to users and system integrators to alleviate the problem. Thanks to low acquisition costs, even using multiple versions of software in a parallel architecture, which is a scheme formerly reserved for few and highly critical applications, may become viable for many applications. We have studied the potential dependability gains from these solutions for off-the-shelf database servers. We based the study on the bug reports available for four off-the-shelf SQL servers plus later releases of two of them. We found that many of these faults cause systematic noncrash failures, which is a category ignored by most studies and standard implementations of fault tolerance for databases. Our observations suggest that diverse redundancy would be effective for tolerating design faults in this category of products. Only in very few cases would demands that triggered a bug in one server cause failures in another one, and there were no coincident failures in more than two of the servers. Use of different releases of the same product would also tolerate a significant fraction of the faults. We report our results and discuss their implications, the architectural options available for exploiting them, and the difficulties that they may present
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
- âŠ