Object replication in a distributed system

PhD ThesisA number of techniques have been proposed for the construction of fault—tolerant applications. One of these techniques is to replicate vital system resources so that if one copy fails sufficient copies may still remain operational to allow the application to continue to function. Interactions with replicated resources are inherently more complex than non—replicated interactions, and hence some form of replication transparency is necessary. This may be achieved by employing replica consistency protocols to mask replica failures and maintain consistency of state between functioning replicas. To achieve consistency between replicas it is necessary to ensure that all replicas receive the same set of messages in the same order, despite failures at the senders and receivers. This can be accomplished by making use of order preserving reliable communication protocols. However, we shall show how it can be more efficient to use unordered reliable communication and to impose ordering at the application level, by making use of syntactic knowledge of the application. This thesis develops techniques for replicating objects: in general this is harder than replicating data, as objects (which can contain data) can contain calls on other objects. Handling replicated objects is essentially the same as handling replicated computations, and presents more problems than simply replicating data. We shall use the concept of the object to provide transparent replication to users: a user will interact with only a single object interface which hides the fact that the object is actually replicated. The main aspects of the replication scheme presented in this thesis have been fully implemented and tested. This includes the design and implementation of a replicated object invocation protocol and the algorithms which ensure that (replicated) atomic actions can manipulate replicated objects.Research Studentship, Science and Engineering Research Council. Esprit Project 2267 (Integrated Systems Architecture)

Exploração de algoritmos de consenso no Quorum

As blockchain technology matures, more industries are becoming interested in evaluating if the technology can answer their needs for decentralized systems that guarantee data immutability and traceability. Quorum is a blockchain platform that accommodates enterprise use-cases by extending Ethereum to support private transactions and a higher transaction throughput. To achieve this, Quorum replaced Ethereum’s proof-of-stake consensus mechanism with proof-of-authority ones, supporting four different algorithms: Raft, Clique, IBFT 1.0, and QBFT. This work explores Quorum’s consensus algorithms and how they affect performance and fault-tolerance, in order to assess the best use cases for each and what should drive their choice. A GoQuorum network was set up, and benchmarks were run against this system under different scenarios while only changing the consensus algorithm for each scenario. Results showed that Raft is the most performant consensus algorithm in Quorum in both private and public transactions. Additionally, QBFT achieved the same performance as IBFT, and Clique was the worst performer across the board, particularly due to having high resource-usage. Regarding fault-tolerance, it was found that bringing validator nodes down at random, when the network has high-availability, had no impact on networks under any of the consensus algorithms.Com blockchain a entrar numa fase de maturidade, cada vez mais indústrias procuram avaliar se esta tecnologia responde às suas necessidades de sistemas distribuídos que garantam a imutabilidade e rastreabilidade dos seus dados. Quorum é uma plataforma blockchain que procura acomodar os casos de uso destas empresas ao extender Ethereum para suportar transações privadas e um maior número de transações por segundo. Para esse efeito, o Quorum substituiu o mecanismo de consenso proof-ofstake do Ethereum por um mecanismo de proof-of-authority, onde quatro algoritmos são suportados: Raft, Clique, IBFT 1.0, e QBFT. Este trabalho explora os algoritmos de consenso suportados pelo Quorum de modo a determinar como estes afetam o desempenho e tolerância a falhas das redes, e consequentemente perceber os melhores casos de uso para estes algoritmos e que fatores ter em conta aquando a sua escolha. Foi criada uma rede de GoQuorum, e vários testes de desempenho foram corridos contra a rede sob diferentes cenários, onde para cada cenário a única variável foi o algoritmo de consenso. Os resultados mostraram que o Raft foi o algoritmo de consenso com melhor desempenho, tanto em transações públicas como privadas. Adicionalmente, o QBFT e o IBFT atingiram o mesmo desempenho, e o Clique o pior de todos, particularmente pelo seu alto uso de recursos do sistema. Quanto a tolerância a falhas, foi concluído que trazer nós validadores abaixo aleatoriamente enquanto o sistema está configurado com alta disponibilidade não tem impacto nas redes, independentemente do algoritmo de consenso utilizado

Middleware support for locality-aware wide area replication

technical reportCoherent wide-area data caching can improve the scalability and responsiveness of distributed services such as wide-area file access, database and directory services, and content distribution. However, distributed services differ widely in the frequency of read/write sharing, the amount of contention between clients for the same data, and their ability to make tradeoffs between consistency and availability. Aggressive replication enhances the scalability and availability of services with read-mostly data or data that need not be kept strongly consistent. However, for applications that require strong consistency of writeshared data, you must throttle replication to achieve reasonable performance. We have developed a middleware data store called Swarm designed to support the widearea data sharing needs of distributed services. To support the needs of diverse distributed services, Swarm provides: (i) a failure-resilient proximity-aware data replication mechanism that adjusts the replication hierarchy based on observed network characteristics and node availability, (ii) a customizable consistency mechanism that allows applications to specify allowable consistency-availability tradeoffs, and (iii) a contention-aware caching mechanism that monitors contention between replicas and adjusts its replication policies accordingly. On a 240-node P2P file sharing system, Swarm's proximity-aware caching and replica hierarchy maintenance mechanisms improve latency by 80%, reduce WAN bandwidth consumed by 80%, and limit the impact of high node churn (5 node deaths/sec) to roughly one-fifth that of random replication. In addition, Swarm's contention-aware caching mechanism outperforms RPCs and static caching mechanisms at all levels of contention on an enterprise service workload

R2PC: fault-tolerance made easy

Fault-tolerance is a concept that is becoming more and more important as computers are increasingly being used in application areas such as process control, air-traffic control and communication systems. However, the construction of fault-tolerant software remains a very difficult task, as it requires extensive knowledge and experience on the part of the designers of the system. The basics of the Remote Procedure Call (RPC) protocol and its many variants are a fundamental mechanism that provides the adequate level of abstraction for the construction of distributed applications and release the programmers from the burden of dealing with low level networking protocols. However, the standard definition of the protocol does not provide us with semantics that are sufficiently transparent to deal with unexpected hardware and software faults, i.e. the programmer has to deal with possible problems that may occur. To deal with this problem, different reliable variations of the RPC protocol have been defined. This dissertation introduces a new reliable protocol - R2PC - with the following characteristics. • Symmetric treatment of client and server processes. • Use of concurrently processed nested calls in stateful servers. • The achievement of failure transparency at the application level

Automatic Distributed Code Generation from Formal Models of Asynchronous Concurrent Processes

International audienceFormal process languages inheriting the concurrency and communication features of process algebras are convenient formalisms to model distributed applications, especially when they are equipped with formal verification tools (e.g., model-checkers) to help hunting for bugs early in the development process. However, even starting from a fully verified formal model, bugs are likely to be introduced while translating (generally by hand) the concurrent model —which relies on high-level and expressive communication primitives— into the distributed implementation —which often relies on low-level communication primitives. In this paper, we present DLC, a compiler that enables distributed code to be generated from models written in a formal process language called LNT, which is equipped with a rich verification toolbox named CADP. The generated code can be either executed in an autonomous way (i.e., without requiring additional code to be defined by the user), or connected to external software through user-modifiable C functions. We present an experiment where DLC generates a distributed implementation from the LNT model of the Raft consensus algorithm