Les services Web tolérants aux fautes sont des composants avec une grande résilience aux défaillances qui résultent de différentes fautes imprévues, par exemple des bugs logiciels ou crash de machine. Comme il est impossible de prévoir l'apparition d'éventuelles fautes, de nombreuses stratégies consistent à dupliquer, d'une manière passive ou active, les composants critiques (eg. services Web) qui interagissent durant une exécution d'application distribuée (eg. composition). La capacité d'une application à continuer l exécution en présence de défaillances de composants référé a la Tolérance aux Fautes (TF). La duplication est la solution largement utilisée pour rendre les composants tolérants aux fautes. La TF peut être assurée à travers la réplication ou la diversité. Nous nous intéressons particulièrement dans cette thèse à la diversité, et nous montrons comment un ensemble de services Web sémantiquement équivalents qui fournissent la même fonctionnalité (eg. prévisions météo), mais qui l'implémentent différemment, collaborent pour rendre un service Web TF. Nous illustrons les limites de la réplication (présence de fautes répliquées), et proposons la diversité comme une solution alternative. En effet, la littérature a révélé un intérêt limité dans l'utilisation de la diversité pour rendre les services Web tolérants aux fautes / Fault Tolerant Web services are components with higher resilience to failures that result out of various unexpected faults for instance software bugs and machine crashes. Since it is impractical to predict the potential occurrence of a fault, a widely used strategy consists of duplicating, in a passive or active way, critical components (e.g., Web services) that interact during a distributed application execution (e.g., composition). The ability of this application to continue operation despite component failures is referred to as Fault Tolerance (FT). Duplication is usually put forward as a solution to make these components fault tolerant. It is achieved through either replication or diversity. In this thesis, we are particularly interested in diversity, and we show how semantically similar Web services, i.e., offer same functionality (e.g., Weather Forecast) but implement this functionality differently in terms of business logic and technical resources, collaborate together to make web services fault tolerant. We illustrate the limitations of replication (e.g., presence of replicated faults) and suggests diversity as an alternative solution. Our literature review revealed a limited interest in diversity for FT Web services

Les grappes de PCs constituent des architectures distribuées dont l'adoption se répand à cause de leur faible coût mais aussi de leur extensibilité en termes de noeuds. Notamment, l'augmentation du nombre des noeuds est à l'origine d'un nombre croissant de pannes par arrêt qui mettent en péril l'exécution d'applications distribuées. L'absence de solutions efficaces et portables confine leur utilisation à des applications non critiques ou sans contraintes de temps.MoLOToF est un modèle de tolérance aux pannes de niveau applicatif et fondée sur la réalisation de sauvegardes. Pour faciliter l'ajout de la tolérance aux pannes, il propose une structuration de l'application selon des squelettes tolérants aux pannes, ainsi que des collaborations entre le programmeur et le système de tolérance des pannes pour gagner en efficacité. L'application de MoLOToF à des familles d'algorithmes parallèles SPMD et Maître-Travailleur a mené aux frameworks FT-GReLoSSS et ToMaWork respectivement. Chaque framework fournit des squelettes tolérants aux pannes adaptés aux familles d'algorithmes visées et une mise en oeuvre originale. FT-GReLoSSS est implanté en C++ au-dessus de MPI alors que ToMaWork est implanté en Java au-dessus d'un système de mémoire partagée virtuelle fourni par la technologie JavaSpaces. L'évaluation des frameworks montre un surcoût en temps de développement raisonnable et des surcoûts en temps d'exécution négligeables en l'absence de tolérance aux pannes. Les expériences menées jusqu'à 256 noeuds sur une grappe de PCs bi-coeurs, démontrent une meilleure efficacité de la solution de tolérance aux pannes de FT-GReLoSSS par rapport à des solutions existantes de niveau système (LAM/MPI et DMTCP). / PC clusters are distributed architectures whose adoption spreads as a result of their low cost but also their extensibility in terms of nodes. In particular, the increase in nodes is responsable for the increase of fail-stop failures which jeopardize distributed applications. The absence of efficient and portable solutions limits their use to non critical applications or without time constraints. MoLOToF is a model for application-level fault tolerance based on checkpointing. To ease the addition of fault tolerance, it proposes to structure applications using fault-tolerant skeletons as well as collaborations between the programmer and the fault tolerance system to gain in efficiency. The application of MoLOToF on SPMD and Master-Worker families of parallel algorithms lead to FT-GReLoSSS and ToMaWork frameworks respectively. Each framework provides fault-tolerant skeletons suited to targeted families of algorithms and an original implementation. FT-GReLoSSS uses C++ on top of MPI while ToMaWork uses Java on top of virtual shared memory system provided by JavaSpaces technology. The frameworks' evaluation reveals a reasonable time development overhead and negligible runtime overheads in absence of fault tolerance. Experiments up to $256$ nodes on a dualcore PC cluster, demonstrate a better efficiency of FT-GReLoSSS' fault tolerance solution compared to existing system-level solutions (LAM/MPI and DMTCP)

L'importance croissante des systèmes électroniques embarqués implique de les rendre de plus en plus sûrs. En effet, certains systèmes tels que les systèmes mécatroniques fonctionnent dans des conditions environnementales sévères les exposants à des erreurs dues aux perturbations. Ainsi, les concepteurs doivent considérer ces erreurs avec attention pour élaborer des remèdes adaptés. Dans ce travail, un intérêt particulier est porté sur la sûreté de fonctionnement des architectures de processeur. Le paradigme du processeur à pile a été choisi puisqu'il présente un bon compromis entre simplicité et efficacité. L'approche que nous avons proposée, évaluée et validée, est basée sur le développement et l'exploitation d'un émulateur logiciel du processeur. La sûreté de fonctionnement est assurée par une exploitation mixte de techniques de protection : une détection matérielle d'erreurs et une correction logicielle. La technique de correction est implantée dans des benchmarks et est validée dans l'émulateur à travers une simulation de différents scenarii d’apparition d’erreurs. Divers paramètres sont évalués tels que la capacité de correction et le surcoût temporel. Cette technique de correction est indépendante de l'application et des moyens de détection, ce qui confirme l'aspect méthodologique de la démarche. Par ailleurs, dans le cadre de la collaboration sollicitée par le projet CIM'Tronic, nous avons fait converger nos travaux avec ceux de l'équipe du CRAN de Nancy/A3SI de Metz en appliquant l'approche du flux informationnel sur le jeu d’instructions du processeur. Nous avons montré la capacité de cette approche d'évaluer la fiabilité de l'ensemble processeur/application / Nowadays, embedded systems are becoming increasingly attractive for many applications. Furthermore, these systems should be more and more dependable. Indeed, systems such as mechatronic or automatically controlled ones often work in harsh environmental conditions making them more prone to errors due to disturbances. Thus, designers should consider ways to protect them against such errors. In this work, a special interest is dedicated to processor architecture dependability as we consider processor-based systems. The stack computer philosophy has been chosen for the processor architecture in order to achieve a good trade-off between simplicity and effectiveness. Our approach to introduce and evaluate the dependability is based on the development and the use of a software emulator of the processor to be designed. Dependability of the processor is ensured through the collaborative use of hardware and software protection techniques: hardware error detection means and software error correction means. The correction technique is implemented in benchmarks and is validated on the emulator through a simulation of various scenarios of errors appearance. Different parameters are evaluated such as correction capability and time overhead. This correction technique is independent from the target application and from the detection means, what confirms the methodological aspect of our approach. Otherwise, as requested by the CIM’tronic project, we integrated our work with the CRAN Nancy/A3SI Metz one by applying the information flow approach on the processor instruction set. We showed the ability of this approach to evaluate the whole processor/application dependability

Ce document présente les travaux de recherche que j'ai menés sur la problématique de la tolérance aux fautes dans les architectures et systèmes distribués entre 1987 et 1998. Comment concilier efficacité et tolérance aux fautes dans des systèmes construits à partir de composants standard tout en assurant la transparence de la tolérance aux fautes pour les applications ? Cette problématique a été abordée dans le contexte de la conception du système distribué Gothic, d'une architecture multiprocesseur à mémoire partagée tolérante aux fautes, d'une architecture multiprocesseur à mémoire partagée extensible (COMA) à haute disponibilité puis d'un système de mémoire partagée répartie. Le document présente ma démarche dans la conduite de ces travaux, les résultats obtenus et leur validation expérimentale.

.

Aujourd'hui les systèmes embarqués sont partout et requièrent de plus en plus de puissance de calcul. Mais, l'évolution des technologies a un impact négatif sur la fiabilité. En particulier, il est prévu une hausse du nombre de fautesf intermittentes dans les technologies à venir. Cependant, nous ne bénéficions pas d'étude expérimentale détaillée pour ce type de faute. Or, pour tenter de se prémunir de ces fautes, il est important de comprendre leur comportement, ainsi que leur impact sur le système et les applications. Pour cela, nous avons défini une plateforme expérimentale capable d'observer des erreurs intermittentes. Nous avons ainsi, pu confirmer que les erreurs intermittentes peuvent être observées très tôt avant la période d'usure du circuit. De plus, ces erreurs apparaissent en rafale et seul l'arrêt des processeurs semble les stopper. Nous confirmons ainsi, qu'il est nécessaire de mettre en place des méthodes de détection en ligne des erreurs intermittentes dans les circuits intégrés très submicroniques. Cependant, aucune solution proposée dans la littérature ne convient à la fois aux erreurs intermittentes et aux architectures multiprocesseur. Ainsi, nous avons développé une méthode de test périodique répondant à ces contraintes. En particulier, nous avons montré que le test ne doit pas nécessairement être prioritaire devant les applications. Cela nous a permis de conclure qu'une politique d'ordonnancement des tests pseudo-périodiques, prenant en compte les processeurs au repos et la priorité des tâches, offrent le meilleur compromis entre performance et probabilité de détection.

Les DRAMs sont des mémoires fréquemment utilisées dans les systèmes aéronautiques et spatiaux. Leur tenue aux radiations doit être connue pour satisfaire les exigences de fiabilité des applications critiques. Ces évaluations sont traditionnellement faites en accélérateur de particules. Cependant, les composants se complexifient avec l'intégration technologique. De nouveaux effets apparaissent, impliquant l'augmentation des temps et des coûts de test. Il existe une solution complémentaire, le laser impulsionnel, qui déclenche des effets similaires aux particules. Grâce à ces deux moyens de test, il s'est agi d'étudier les principaux modes de défaillance des DRAMs liés aux radiations : les SEUs (Single Event Upset) dans les plans mémoire, et les SEFIs (Single Event Functional Interrupt) dans les circuits périphériques. L'influence des motifs de test sur les sensibilités SEUs et SEFIs selon la technologie utilisée a ainsi été démontrée. L'étude a de plus identifié l'origine des SEFIs les plus fréquents. En outre, des techniques de test laser ont été développées pour quantifier les surfaces sensibles des différents effets. De ces travaux a pu être dégagée une nouvelle méthodologie de test destinée à l'industrie. Son objectif est d'optimiser l'efficacité et le coût des caractérisations, grâce à l'utilisation de l'outil laser de façon complémentaire aux accélérateurs de particules. Enfin, une nouvelle solution de tolérance aux fautes est proposée : basée sur la propriété des cellules DRAMs d'être immune aux radiations lorsqu'elles sont déchargées, cette technique permet la correction de tous les bits d'un mot logique.

Nous proposons une méthodologie de conception pour les systèmes de commande tolérants aux fautes en partant d'un modèle de base exhaustif pour le système complexe à superviser. En pratique, la modélisation exhaustive est réalisée grâce à un automate hybride enrichi par des paramètres quantifiant les défaillances possibles. Ceci permet de modéliser les défaillances partielles. Dans la phase hors ligne, ce système complexe est transformé en un système discret abstrait et exploitable selon des techniques dédiées. Un superviseur est alors construit selon les objectifs de fonctionnement.Lors du fonctionnement du système, l'occurrence d'une défaillance se traduit par l'invalidation de plusieurs comportements dans le modèle abstrait et l'introduction d'incertitudes. Par la suite, les modules de diagnostic et d'identification (qui ne rentrent pas dans l'objet de notre thèse) réduisent de façon progressive le modèle hybride au cours du temps. Afin de pouvoir mettre à jour le modèle discret abstrait, on a développé des algorithmes de calcul d'atteignabilité, de vérification et de génération de régions stabilisées.Pour pouvoir superviser un tel système, l'utilisation de méthodologies d'abstraction est nécessaire afin de transformer le modèle bas niveau exhaustif en un modèle discret approprié. Nous réalisons cette abstraction en proposant des algorithmes qui tiennent compte du contexte d'utilisation (objectifs, contraintes...). Lorsqu'une défaillance est détectée, la reconfiguration est déclenchée en essayant, au fur et à mesure de l'enrichissement du modèle abstrait, de réduire le fonctionnement du système défaillant dans un des schémas prédéfinis

State machine replication (SMR) is a software technique for tolerating failures using commodity hardware. The critical service to be made fault-tolerant is modeled by a state machine. Several, possibly different, copies of the state machine are then deployed on different nodes. Clients of the service access the replicas through a SMR protocol which ensures that, despite concurrency and failures, replicas perform client requests in the same order. Two objectives underly the design and implementation of a SMR protocol: robustness and performance. Robustness conveys the ability to ensure availability (liveness) and one-copy semantics (safety) despite failures and asynchrony. On the other hand, performance measures the time it takes to respond to a request (latency) and the number of requests that can be processed per time unit (throughput). In this thesis, we present two contributions to state machine replication. The first contri- bution is LCR, a uniform total order broadcast (UTO-broadcast) protocol that is throughput optimal in failure-free periods. LCR can be used to totally order the requests received by a replicated state machine. LCR has been designed for small clusters of homogeneous machines interconnected by a local area network. It relies on a perfect failure detector and tolerates the crash failures of all but one replicas. It is based on a ring topology and only relies on point-to-point inter-process communication. We benchmark an implementation of LCR against two of the most widely used group communication packages and show that LCR provides higher throughput than them, over a large number of setups. The second contribution is Abstract, a new abstraction to simplify the design, proof and implementation of SMR protocols. Abstract focuses on the most robust class of SMR protocols, i.e. those tolerating arbitrary (client and replica) failures. Such protocols are called Byzantine Fault Tolerant (BFT) protocols. We treat a BFT protocol as a composition of instances of our abstraction. Each instance is developed and analyzed independently. To illustrate our approach, we first show how, with our abstraction, the benefits of a BFT protocol like Zyzzyva could have been developed using less than 24% of the actual code of Zyzzyva. We then present Aliph, a new BFT protocol that outperforms previous BFT protocols both in terms of latency (by up to 30%) and throughput (by up to 360%).

Ce travail se place dans le cadre du calcul haute performance sur des plateformes d'exécution de grande taille telles que les grilles de calcul. Les grilles de calcul sont notamment caractérisées par (1) des changements fréquents des conditions d'exécution et, en particulier, par (2) une probabilité importante de défaillance due au grand nombre de composants. Pour exécuter une application efficacement dans un tel environnement, il est nécessaire de prendre en compte ces paramètres. Nos travaux de recherche reposent sur la représentation abstraite de l'application sous forme d'un graphe de flot de données de l'environnement de programmation parallèle et distribuée Athapascan/Kaapi. Nous utilisons cette représentation abstraite pour apporter des solutions aux problèmes (1) de reconfiguration dynamique et (2) de tolérance aux fautes. - Tout d'abord, nous proposons un mécanisme de reconfiguration dynamique qui gère, de manière transparente pour le programmeur de la reconfiguration, les problèmes d'accès concurrents sur l'état de l'application et la cohérence mutuelle des états en cas de reconfiguration distribuée. - Ensuite, nous présentons un protocole de tolérance aux fautes original qui permet d'effectuer une reprise partielle de l'application en cas de panne. Pour cela, il détermine l'ensemble des tâches de calcul strictement nécessaires à la reprise de l'application. Ces contributions sont évaluées en utilisant les logiciels Kaapi et X-Kaapi sur la plateforme de calcul Grid'5000.