Lásaro J. Camargos

Sprint: a middleware for high-performance transaction processing

Sprint is a middleware infrastructure for high performance and high availability data management. It extends the functionality of a standalone in-memory database (IMDB) server to a cluster of commodity shared-nothing servers. Applications accessing an IMDB are typically limited by the memory capacity of the machine running the IMDB. Sprint partitions and replicates the database into segments and stores them in several data servers. Applications are then limited by the aggregated memory of the machines in the cluster. Transaction synchronization and commitment rely on total-order multicast. Differently from previous approaches, Sprint does not require accurate failure detection to ensure strong consistency, allowing fast reaction to failures. Experiments conducted on a cluster with 32 data servers using TPC-C and a micro-benchmark showed that Sprint can provide very good performance and scalability.

Multicoordinated Paxos

Classic Paxos is a round-based distributed consensus algorithm. Normally, proposals are sent to the round leader and decided in two communication steps more. Fast Paxos extends Classic Paxos by allowing also fast rounds, in which a decision can be learned in two communication steps without relying on a leader but requiring bigger quorums. We extend Fast Paxos and allow yet another sort of round with multiple quorums of coordinators. Such new rounds have the same expected latency and quorum size requirements as classic rounds but do not rely on a single leader, providing better availability and allowing load balance. Fast rounds and ours have a different liveness requirement: the absence of collisions—which may happen if different values are proposed concurrently. However, collisions are inherently more expensive in fast rounds. We apply our algorithm to Generalized Consensus, a generalization of agreement problems that can use the application semantics to avoid

A Primary-Backup Protocol for In-Memory Database Replication

The paper presents a primary-backup protocol to manage replicated in-memory database systems (IMDBs). The protocol exploits two features of IMDBs: coarse-grain concurrency control and deferred disk writes. Primary crashes are quickly detected by backups and a new primary is elected whenever the current one is suspected to have failed. False failure suspicions are tolerated and never lead to incorrect behavior. The protocol uses a consensus-like algorithm tailor-made for our replication environment. Under normal circumstances (i.e., no failures or false suspicions), transactions can be committed after two communication steps, as seen by the applications. Performance experiments have shown that the protocol has very low overhead and scales linearly with the number of replicas

Multicoordinated Agreement Protocols for Higher Availabilty

Adaptability and graceful degradation are important features in distributed systems. Yet, consensus and other agreement protocols, basic building blocks of reliable distributed systems, lack these features and must perform expensive reconfiguration even in face of single failures. In this paper we describe multicoordinated mode of execution for agreement protocols that has improved availability and tolerates failures in a graceful manner. We exemplify our approach by presenting a generic broadcast algorithm. Our protocol can adapt to environment changes by switching to different execution modes. Finally, we show how our algorithm can solve the generalized consensus and its many instances (e.g., consensus and atomic broadcast).

Optimal and practical WAB-based consensus algorithms

In this paper we introduce two new WAB-based consensus algorithms for the crash-recovery model. The first one, B*-Consensus, is resilient to up to f < n/2 permanent faults, and can solve consensus in three communication steps. R*-Consensus, our second algorithm, is f < n/3 resilient, and can solve consensus in two communication steps. These algorithms are optimal with respect to the time complexity versus resilience tradeoff. We compare our algorithms to other consensus algorithms in the crash-recovery model.

Collision-Fast Atomic Broadcast

Atomic Broadcast, an important abstraction in dependable distributed computing, is usually implemented by solving infinitely many instances of the well-known consensus problem. Some asynchronous consensus algorithms achieve the optimal latency of two (message) steps but cannot guarantee this latency even in good runs, those with timely message delivery and no crashes. This is due to collisions, a result of concurrent proposals. Collision-fast consensus algorithms, which decide within two steps in good runs, exist under certain conditions. Their direct application to solving atomic broadcast, though, does not guarantee delivery in two steps for all messages unless a single failure is tolerated. We show a simple way to build a fault-tolerant collision-fast Atomic Broadcast algorithm based on a variation of the consensus problem we call M-Consensus. Our solution to M-Consensus extends the Paxos protocol to allow multiple processes, instead of the single leader, to have their proposals learned in two steps.

Resilient Strategies to SDN: An Approach Focused on Actively Replicated Controllers

Software Defined Networking (SDN) are based on the separation of control and data planes. The SDN controller, although logically centralized, should be effectively distributed for high availability. Since the specification of OpenFlow 1.2, there are new features that allow the switches to communicate with multiple controllers that can play different roles -- master, slave, and equal. However, these roles alone are not sufficient to guarantee a resilient control plane and the actual implementation remains an open challenge for SDN designers. In this paper, we explore the OpenFlow roles for the design of resilient SDN architectures relying on multi-controllers. As a proof of concept, a strategy of active replication was implemented in the Ryu controller, using the OpenReplica service to ensure consistent state among the distributed controllers. The prototype was tested with commodity RouterBoards/MikroTik switches and evaluated for latency in failure recovery and switch migration for different workloads. We observe a set of trade-offs in real experiments with varyin workloads at both the data and control plane.

Semantically enriched services to understand the need of entities

Researchers from all over the world are engaged in the design of a new Internet, and Software-Defined Networking (SDN) is one of the results of this engagement. Net-Ontology uses a SDN approach to bring semantics to the intermediate network layers and make them capable of handling application requirements and adapt their behaviour over time as required. In this paper we present an experimental evaluation of Net-Ontology and a feature comparison against the traditional TCP/IP stack. This paper extends our earlier work towards a Future Internet, showing a viable approach to introduce semantics at network lower layers by contributing to bring richer and efficient services.

On-Demand Recovery in Middleware Storage Systems

This paper presents a recovery architecture for in-memory data management systems. Recovery in such systems boils down to solving two problems: retrieving and installing the last committed image of the crashed database on a new server and replaying the updates missing from the image. We improve recovery time with a novel technique called On-Demand Recovery, which removes the need to replay all missing updates before new transactions can be accepted. We have implemented and thoroughly evaluated the technique. We show in the paper that in some cases On-Demand Recovery can reduce recovery time by more than 50%.

AR2C2: Actively replicated controllers for SDN resilient control plane

Software Defined Networking (SDN) is a promising architectural approach based on a programmatic separation of the control and data planes. For high availability purposes, logically centralized SDN controllers follow a distributed implementation. While controller role features in the OpenFlow protocol allow switches to communicate with multiple controllers, these mechanisms alone are not sufficient to guarantee a resilient control plane, leaving the actual implementation as open challenge for SDN designers. This paper explores OpenFlow roles for the design of resilient SDN control plane and proposes AR2C2 as an actively replicated multi-controller strategy. As proof of concept, AR2C2 is implemented based on the Ryu controller and relying on OpenReplica to ensure consistent state among the distributed controllers. Our prototype is experimentally evaluated using real commodity switches and Mininet emulated environment. Results of the measured times to recover from failures for different workloads shed some light on the practical trade-offs on replication overhead and latency as a step forward towards SDN resiliency.