Iratxe Soraluze

Specifying and implementing an eventual leader service for dynamic systems

The election of an eventual leader in an asynchronous system prone to process crashes is an important problem of fault-tolerant distributed computing. This problem is known as the implementation of the failure detector Omega. Nearly all papers that propose algorithms implementing such an eventual leader service consider a static system. In contrast this paper considers a dynamic system, i.e., a system in which processes can enter and leave. The paper has three contributions. It first proposes a specification of

Communication-efficient failure detection and consensus in omission environments

\Omega

Communication-efficient leader election in crash-recovery systems

suited to dynamic systems. Then, it presents and proves correct an algorithm implementing this specification. Finally, the paper discusses the notion of an eventual leader suited to dynamic systems. It introduces an additional property related to system stability. The design of an algorithm satisfying this last property remains an open challenging problem.

On the implementation of communication-optimal failure detectors

Failure detectors have been shown to be a very useful mechanism to solve the consensus problem in the crash failure model, for which a number of communication-efficient algorithms have been proposed. In this paper we deal with the definition, implementation and use of communication-efficient failure detectors in the general omission failure model, where processes can fail by crashing and by omitting messages when sending and/or receiving. We first define a new failure detector class for this model in terms of completeness and accuracy properties. Then we propose an algorithm that implements a failure detector of the proposed class in a communication-efficient way, in the sense that only a linear number of links are used to send messages forever. We also explain how the well-known consensus algorithm of Chandra and Toueg can be adapted in order to use the proposed failure detector.

Game-Console-Based Projects for Learning the Computer Input/Output Subsystem

Abstract: This work addresses the leader election problem in partially synchronous distributed systems where processes can crash and recover. More precisely, it focuses on implementing the Omega failure detector class, which provides a leader election functionality, in the crash-recovery failure model. The concepts of communication efficiency and near-efficiency for an algorithm implementing Omega are defined. Depending on the use or not of stable storage, the property satisfied by unstable processes, i.e., those that crash and recover infinitely often, varies. Two algorithms implementing Omega are presented. In the first algorithm, which is communication-efficient and uses stable storage, eventually and permanently unstable processes agree on the leader with correct processes. In the second algorithm, which is near-communication-efficient and does not use stable storage, processes start their execution with no leader in order to avoid the disagreement among unstable processes, that will agree on the leader with correct processes after receiving a first message from the leader.

Secure Failure Detection and Consensus in TrustedPals

Several algorithms implementing failure detectors have been proposed in the literature. In particular, we have proposed a family of communication-efficient ⋄P algorithms, i.e., algorithms using n links to carry messages forever, being n the number of processes in the system. Moreover, we have recently proposed a ⋄P algorithm that uses only C links, being C the number of correct processes. In this paper, we show that C is the minimum number of links required to implement ⋄P. We also show that, assuming that there is at least one incorrect process, C is optimal not only for ⋄P but also for ⋄S and Ω. We revisit our Reliable Broadcast based communication-optimal ⋄P algorithm, and we show that, regarding QoS measures, it performs better than the communication-efficient algorithms.

Secure failure detection in TrustedPals

The input/output (I/O) subsystem is an important topic within computer architecture (CA) because it determines how the computer interacts with its environment. For this reason, computer scientists and engineers must understand how the computer manages this interaction, which is usually taught in introductory CA courses. Of course, there are many different styles of teaching, ranging from purely theoretical to completely practical. The CA course considered in this paper has already applied a practical approach for some time. For the I/O subsystem, students must be able to describe what polling and interrupts are and handle them through low-level programming. However, programming at this level in operating system (OS)-driven computers is not possible without being familiar with the kernel and drivers, which is not usually the case for students in an introductory course. Fortunately, there are many bare and specialized embedded systems around that are not OS-driven. In this proposal, the Nintendo DS (NDS) console was used in a classroom setting. It proved to be an appropriate infrastructure for developing attractive and engaging projects and was useful in providing a better understanding of the mechanisms related to the I/O subsystem. At the same time, the teaching methods were altered to make the transition from classical, passive, lecture-based classes to an active project-based learning (PBL) approach. It has been a very rewarding experience to see students learning to control the NDS devices on their own. In addition to describing the implementation of the proposed changes in two subsequent school years, this paper also presents some data and conclusions.

Hierarchical classifiers based on neighbourhood criteria with adaptive computational cost

We present a modular redesign of TrustedPals, a smart card-based security framework for solving Secure Multiparty Computation (SMC). Originally, TrustedPals assumed a synchronous network setting and allowed to reduce SMC to the problem of fault-tolerant consensus among smart cards. We explore how to make TrustedPals applicable in environments with less synchrony and show how it can be used to solve asynchronous SMC. Within the redesign we investigate the problem of solving consensus in a general omission failure model augmented with failure detectors. To this end, we give novel definitions of both consensus and the class oP of failure detectors in the omission model, which we call ◇P(om), and show how to implement ◇P(om) and have consensus in such a system with very weak synchrony assumptions. The integration of failure detection and consensus into the TrustedPals framework uses tools from privacy enhancing techniques such as message padding and dummy traffic.

Communication-optimal eventually perfect failure detection in partially synchronous systems ☆

This paper presents a modular redesign of TrustedPals, a smartcard-based security framework for solving secure multiparty computation (SMC). TrustedPals allows to reduce SMC to the problem of fault-tolerant consensus between smartcards. Within the redesign we investigate the problem of solving consensus in a general omission failure model augmented with failure detectors. To this end, we give novel definitions of both consensus and the class of ⋄P failure detectors in the omission model and show how to implement ⋄P and have consensus in such a system with some weak synchrony assumptions. The integration of failure detection into the TrustedPals framework uses tools from privacy enhancing techniques such as message padding and dummy traffic.

An Evaluation of Efficient Leader Election Algorithms for Crash-Recovery Systems

Classifiers based on neighbourhood concept require a high computational cost when the Reference Patterns Set is large. In this paper, we propose the use of hierarchical classifiers to reduce this computational cost, maintaining the hit rate in the recognition of handwritten digits. The hierarchical classifiers reach the hit rate of the best individual classifier. We have used NIST Database to carry out the experimentation, and we have worked with two test sets: in Test 1 (SD3, SD19) the hit rate is 99.54%, with a speed-up of 40.6, and in Test 2 (SD7), the hit rate is 97.51% with a speed-up of 15.7.