The goal of this work is to study process algebraic foundations for component-based distributed programming. Most of this work takes place in the context of the ANR PiCoq project.

To develop composable abstractions for programming dependable systems, we investigate concurrent reversible models of computation, where arbitrary executions can be reversed, step by step, in a causally consistent way. This year we have continued the study of the reversible higher-order pi-calculus and obtained a new encoding of it in the higher-order pi-calculus which improves on the result we published in Concur 2010 by proving the faithfulness of the encoding with a much finer equivalence relation. We also developed a reversible variant of the higher-order pi-calculus where reversibility can be controlled by means of an explicit rollback primitive . We have proved that this rollback primitive is sound and complete in that it provides a causally consistent and complete reversal of concurrent computations, and we have developed a low-level semantics for this primitive, closer to an actual distributed implementation, which we have proved equivalent to the high-level one. All these results are presented in detail in Claudio Mezzina's forthcoming PhD thesis, and have been developed in cooperation with the INRIA Focus team at the University of Bologna.

An interesting and expressive component model for embedded systems is the BIP component model , developed by J. Sifakis' team at the Verimag Laboratory, which features hierarchical software architectures, explicit constructs for specifying component compositions ( glues), and multipoint synchronization under priority constraints. We have begun a process calculus analysis of BIP, with a view to combine the reactive features of BIP with the dynamic reconfiguration features of Fractal. Our first result takes the form of new process calculus, called CAB, which we have proved to be a conservative extension of BIP. CAB also enabled us to study the intrinsic expressivity of the BIP model and to prove that priority constraints are essential to BIP expressivity .

We have made significant progress on the formalization in the Coq proof assistant of a core higher-order $\pi$-calculus, called HOcore . We have in particular adapted a canonical locally nameless representation of binding to handle alpha-conversion in our formalization. Several major theorems of HOcore, in particular the fact that IO-bisimulation is correct in relation to barbed congruence and is decidable. This work has been submitted for publication.

A longer version of our work on untyping theorems and cyclic linear logic has been accepted for publication in LMCS  , and a book chapter on up-to techniques for bisimulations, written with Davide Sangiorgi from the INRIA Focus team in Bologna, has been published by Cambdridge University Press  .

Together with Filippo Bonchi (LIP, ENS Lyon), we have worked on a new algorithm for checking the language equivalence of non-deterministic finite automata (NFA). This algorithm improves on the standard Hopcroft and Karp' algorithm, by using up-to techniques. The first empirical tests look really promising 

Together with Tom Hirschowitz (LAMA, U. de Chambéry), we have worked on a categorical model of CCS, where innocent strategies are pre-sheaves. This work has been presented at the ICE workshop  , and a long version has been submitted to SACS.

The goal of this work is to develop proof-assistant-based tools for verifying distributed systems and distributed abstract machines. In particular, we aim to support the derivation of fully formal proofs of correctness for abstract machines supporting the component-based languages and programming models we develop.

We have presented our work about tools for rewriting modulo AC in Coq at CPP'11  . An extended version of our work on Kleene algebra (ATBR, first published at ITP'10), was accepted for publication in LMCS  . Also on the Coq side, we have developed a library for verifying hardware circuits, which was also presented at CPP'11  .

The goal of this work is to apply control techniques based on the behavioral model of reactive automata and the algorithmic techniques of discrete controller synthesis. We adopt the synchronous approach to reactive systems, and use an associated effective controller synthesis tool, Sigali, developed at INRIA Rennes. Both are integrated into a programming language, called BZR, and its compiler, as an extension of the Heptagon language. We thus have a complete tool-supported method from control modeling down to concrete execution, considering different execution models, and targetting either software or hardware. We explore control theory for computer science, as an original alernative to computer science for control (as more usually in embedded systems), and to classical discrete control systems (as more usually applied to manufacturing). We are exploring several target application domains, where we expect to find commonalities in the control problems, and variations in the definitions of configurations, and in the criteria motivating adaptation.

We have obtained this year the following results:

The goal of this work is to study system configuration and software deployment issues in large distributed systems.

System configuration and software deployment in a distributed environment can be greatly aided by the use of a uniform component model to support software assembly, software configuration and deployment, as well as runtime system configuration. We have developed a specialization of the Fractal component model that provides a reference model for heterogeneous software assembly and configuration. In particular, we have shown how this reference model can be used to assemble and configure software architectures built from heterogeneous software packages (e.g. OSGI bundles for Java packages, Debian or RPM packages for Linux modules and applications). The definition of this model, a description of its implementation and its evaluation are documented in Loris Bouzonnet's PhD thesis .

As an alternative to current public cloud infrastructures, which rely on large data centers, we have started the study of a cloud infrastructure based on a peer-to-peer (P2P) overlay network built on gossip-based protocols. More precisely, we have studied how to implement a distributed resource allocation service in a P2P environment maintained by a gossip-based peer-sampling protocol . The resulting system, called Salute, provides for the allocation of application-specific overlays out of an underlying P2P network. By combining several P2P services (including peer-sampling, topology maintenance, and node synchronization), and by partitioning available nodes into free nodes (available for the allocation of new application overlays) and reserve nodes (nodes dedicated to the maintenance of allocated overlays), Salute provides a churn-resilient, completely decentralized cloud infrastructure. In addition, we have shown that Salute can provide its allocation service while maintaining fairness and avoiding starvation. The Salute architecture has been validated through simulations using network traces from different real-worl P2P environments. The Salute architecture, algorithms and their validation are documented in Willy Malvault's PhD thesis .

In a cloud computing context the complexity of deploying and configuring non-trivial software architectures is exacerbated. In line with our previous work on architecture-based distributed system management, we have proposed a novel algorithm for configuring component-based distributed applications deployed within several virtual machines in an IaaS environment. The algorithm is completely decentralized, relies on a message queuing middleware and exploits the software architecture descriptions of the applications to deploy and configure, written in an extension of the Fractal Architecture Description Language. A first version of this algorithm, that does not take into account potential failures during the configuration process, has been formally specified in collaboration with Gwen Salaün from the INRIA Vasy team in Grenoble, and presented at IEEE Cloud 2011  .

Multicore machines with Non-Uniform Memory Accesses (NUMA) are becoming commodity platforms. Efficiently exploiting their resources remains an open research problem. Most of the body of existing work focuses on increasing locality between computations and memory or I/O resources. This is achieved by allocating data items preferably in local memory nodes, by moving computations close to I/O devices or by moving already allocated memory pages close to the applications which use them most. In all these works, researchers always assume that all processors have equal memory performance. Nevertheless, this assumption is not always valid. In 2011, we have studied the performance achieved by a 16-core NUMA exhibiting an irregular connectivity between processors. Some processors are directly connected to all other processors and access memory nodes with a low latency. Other processors have a lower degree of connectivity and need more hops to access some memory nodes and access memory with a higher latency.

Current operating systems are not aware of such performance characteristics. We have shown that the completion time of applications taken from the PARSEC benchmark suite can vary by up to 15% depending on the processor they are scheduled on. We have thus proposed a new OS scheduler that takes this asymmetry into account in order to make efficient decisions. This scheduler relies on a new metric, called MAPI (number of main Memory Accesses Per retired Instruction), to predict the impact of processor interconnect asymmetry on the performance of applications. We have empirically evaluated the relevance of this metric on applications taken from the PARSEC benchmark suite. We have shown that this metric helps estimating the performance gap between running an application on a "well-interconnected” processor and on a "weakly-interconnected” one. Using this metric, the scheduler we proposed makes efficient decisions. More precisely, we have observed that the scheduler always performed within 3% of the best possible scheduling decision. This work is currently under submission.

We have worked on replication protocols for P2P systems. In particular, we have worked on replication in so called Distributed Hash-Tables (DHTs). DHTs provide a simple high-level put/get abstraction that can be used to build efficient distributed storage systems. DHTs gained wide popularity in the last decade, fostering a large amount of interest in the academia, and inspiring the design of key/value distributed storage systems deployed in production.

DHTs provide a way to deterministically map objects to nodes and allow efficiently retrieving objects in a distributed fashion. Nodes and objects are logically arranged in a large numeric key-space, according to a given variant of consistent hashing. Typically, the node in charge of an object is the one whose position immediately follows the object in the key-space.

To guarantee that objects are reliably stored, DHTs rely on replication. A replication protocol is in charge of ensuring that, at any time, each object is replicated on a sufficiently large number of replicas. Several replication strategies have been proposed in the last years. The most efficient ones use predictions about the availability of nodes to reduce the number of object migrations that need to be performed: objects are preferably stored on highly available nodes.

We have proposed an alternative replication strategy. Rather than exploiting highly available nodes, we have designed a protocol that leverages nodes that exhibit regularity in their connection pattern. Roughly speaking, the strategy consists in replicating each object on a set of nodes that is built in such a way that, with high probability, at any time, there are always at least k nodes in the set that are available. We have evaluated this new replication strategy using traces of two real-world systems: eDonkey and Skype. Our evaluation showed that our regularity-based replication strategy induces a systematically lower network usage than existing state of the art replication strategies. This work has been published at the International Symposium on Reliable Distributed Systems, in October 2011.

Cloud Computing is a paradigm for enabling remote, on-demand access to a virtually infinite set of configurable computing resources. This model aims to provide hardware and software services to customers, while minimizing human efforts in terms of service installation, configuration and maintenance, for both cloud provider and cloud customer. A cloud may have the form of an Infrastructure as a Service (SaaS), a Platform as a Service (PaaS) or a Software as a Service (SaaS). Clouds pose significant challenges to the full elasticity of clouds, their scalibility and their dependability in large scale data management and large scale computing resources. Caching is a means for high performance and scalability of distributed systems. Although caching solutions have been successfully studied for individual systems such as database systems or web servers, if collectively applied, these solutions violate the coherence of cached data. We precisely studied this issue in e-Caching, a novel end-to-end caching system.

The contribution of this work is twofold: guaranteeing the coherence of cached data at multiple locations of a distributed system, while improving the overall performance of the system. In collaboration with Marta Patino and Ricardo Jimenez from Universidad Politecnica de Madrid, we proposed a novel distributed caching protocol, implemented it and evaluated it with real online services. The experiments showed that e-Caching was successfully able to improve service performance by two orders of magnitude.

This work has been presented at CFSE, the French Chapter of ACM-SIGOPS in May 2011. An extended version has been submitted for publication in a journal.

MapReduce has become a popular programming model and runtime environment for developing and executing distributed data-intensive and compute-intensive applications. It offers developers a means to transparently handle data partitioning, replication, task scheduling and fault tolerance on a cluster of commodity computers. MapReduce allows a wide range of applications such as log analysis, data mining, Web search engines, scientific computing, bioinformatics, decision support and business intelligence.

There has been a large amount of work on MapReduce towards improving its performance and reliability. Several efforts have explored task scheduling policies in MapReduce, cost-based optimization techniques, replication and partitioning policies. There has also been a considerable interest in extending MapReduce with other fault tolerance models, or with techniques from database systems. However, there has been very little in the way of empiric evaluation for the comparison of the different systems. Most evaluations of these systems have relied on microbenchmarks based on simple MapReduce programs. While microbenchmarks may be useful in targetting specific system features, they are not representative of full distributed applications, and they do not provide multi-user realistic workloads. Furthermore, as far as we know, no studies have investigated dependability benchmarking of MapReduce.

Thus, we provide MapReduce Benchmarking (MRB), a novel MapReduce benchmark suite to enable a thorough analysis of a wide range of features of MapReduce systems. MRB has the following features. First, it enables the empirical evaluation of the performance and dependability of MapReduce systems. This provides a means to analyze the effectiveness of scalability and fault tolerance, two key features of MapReduce. Second, it covers a variety of application domains, workload and faultload characteristics, ranging from compute-oriented to data-oriented applications, batch applications to online real-time applications. While MapReduce farmewsorks were originally limited to offline batch processing, recent works are exploring the extension of MapReduce beyond batch processing. Moreover, in order to stress MapReduce dependability and performance, the benchmark suite enables different fault injection rates, workloads and concurrency levels. Finally, the benchmark suite is portable and easy to use on a wide range of platforms, covering different MapReduce frameworks and cloud infrastructures. This work has been submitted for publication.

Although distributed services provide a means for supporting scalable Internet applications, their ad-hoc provisioning and configuration pose a difficult tradeoff between service performance and availability. This is made harder as Internet service workloads tend to be heterogeneous, and vary over time in amount of concurrent clients and in mixture of client interactions. This work proposes an approach for building self-adaptive Internet services through utility-aware capacity planning and provisioning. First, an analytic model is presented to predict Internet service performance, availability and cost. Second, a utility function is defined and a utility-aware capacity planning method is proposed to calculate the optimal service configuration which guarantees SLA performance and availability objectives while minimizing functioning costs. Third, an adaptive control method is proposed to automatically apply the optimal configuration to the Internet service. Finally, the proposed model, capacity planning and control methods are implemented and applied to an online bookstore. Experimental evaluations show that the service successfully self-adapts to both workload mix and workload amount variations, and present significant benefits in terms of performance and availability, with a saving of resources underlying the Internet service.

This work is part of the MyCloud ANR project. It has been described in a chapter of the book titled Performance and Dependability in Service Computing, 2011. There has been an industrial transfer of the MoKa software prototype.

Cloud computing environments fall under three main kinds of offers according to the resources they provide. The Infrastructure as a Service (IaaS) level enables the access to virtualized hardware resources (processing, storage and network). The Software as a Service (SaaS) layer aims at providing the end-users with software applications. The intermediary layer, called Platform as a Service (PaaS), offers a set of tools and runtime environments that allow managing the applications life-cycle. This life-cycle includes the phases related to the design, the development, the deployment of applications, and generally speaking all their management stages (workload, fault tolerance, security). This article focuses on the deployment of distributed applications in virtualized environments such as cloud computing. Such deployments require to generate the virtual images that will be instantiated as virtual machines, thus ensuring the execution of the application on an IaaS platform. Each image embeds technical elements (operating system, middleware pieces) and functional ones (data and applicative software entities). Once it has been instantiated, each virtual machine is subjected to a stage of dynamic settings, which finalizes the global configuration of the distributed application.

On the whole, the deployment solutions currently available do not take into account these different configuration parameters, which are mostly managed by dedicated scripts. Moreover these solutions are not able to automate the images generation, their instantiation as virtual machines and their configuration independently from the kind of distributed application to be deployed. For instance, Google App Engine solution only deals with Web services organized into precisely defined tiers. In our opinion, the absence of general solutions results essentially from a lack of formalism for describing the distributed application architecture with its configuration constraints in a virtualized infrastructure such as cloud computing. Pour work focused on a general solution, for Virtual Applications Management Platform, that automates the deployment of any distributed applications in the cloud. The suggested approach is architectural, meaning that it is based upon an explicit representation of the applications’ distributed architecture. We offer, on the one hand, a formalism for describing an application as a set of interconnected virtual machines and, on the other hand, an engine for interpreting this formalism and automating the application deployment on an IaaS platform. Specifically, we study three contributions:

We published in this context two journal articles (TPDS and TAAS ) and three conference papers (Cloud11 , UCC11 and SAC12).

A core aspect of the Synergy virtual machine is its ability to reconfigure component-based applications at execution time. We have focused on the reconfiguration protocol with the intent of verifying and proving its robustness.

In a first step, we have formalized and verified that any correct and complex reconfiguration through our reconfiguration protocol can be processed as a sequence of elementary reconfiguration operations and always results in a component assembly that is architecturally consistent. This aspect has been verified using model-checking techniques. This work has been done in collaboration with Gwen Salaün from the VASY team (Inria Rhône-Alpes). It lead to a publication in the Formal Method (FM'11) conference .

In a second step, we have considered software failures that may occur during a reconfiguration. Although the protocol is trusted code, it invokes components to reconfigure them, thereby executing unsafe code that may fail. This work with Damien Pous produced a high-level formalisation of our reconfiguration protocol and a completely certified modelisation of these algorithms in Coq . This work resulted in a submitted publication.

Finally, we have also investigated the control of complex reconfiguration through using discrete synchronous control techniques with Eric Rutten and Gwenael Delaval .