Search

International audience; Virtualized cloud infrastructures (also known as IaaS platforms) generally rely on a server consolidation system to pack virtual machines (VMs) on as few servers as possible. However, an important limitation of consolidation is not addressed by such systems. Because the managed VMs may be of various sizes (small, medium, large, etc.), VM packing may be obstructed when VMs do not fit available spaces. This phenomenon leaves servers with a set of unused resources (‘holes’). It is similar to memory fragmentation, a well‐known problem in operating system domain. In this paper, we propose a solution which consists in resizing VMs so that they can fit with holes. This operation leads to the management of what we call elastic VMs and requires cooperation between the application level and the IaaS level, because it impacts management at both levels. To this end, we propose a new resource negotiation and allocation model in the IaaS, called HRNM. We demonstrate HRNM's applicability through the implementation of a prototype compatible with two main IaaS managers (OpenStack and OpenNebula). By performing thorough experiments with SPECvirt_sc2010 (a reference benchmark for server consolidation), we show that the impact of HRNM on customer's application is negligible. Finally, using Google data center traces, we show an improvement of about 62.5% for the traditional consolidation engines.

International audience; In a Cloud computing data center and especially in a IaaS (Infrastructure as a Service), performance predictability is one of the most important challenges. For a given allocated virtual machine (VM) in one IaaS, a client expects his application to perform identically whatever is the hosting physical server or its resource management strategy. However, performance predictability is very difficult to enforce in a heterogeneous hardware environment where machines do not have identical performance characteristics, and even more difficult when machines are internally heterogeneous as for Asymmetric Multicore Processor machines. In this paper, we introduce a VM scheduler extension which takes into account hardware performance heterogeneity of Asymmetric Multicore Processor machines in the cloud. Based on our analysis of the problem, we designed and implemented two solutions: the first weights CPU allocations according to core performance, while the second adapts CPU allocations to reach a given instruction execution rate (Ips) regardless the core types. We demonstrate that such scheduler extensions can enforce predictability with a negligible overhead on application performance.

Conférence invitée; International audience

International audience; Nowadays, virtualization is present in almost all computing infrastructures. Thanks to VM migration and server consolidation, virtualization helps in reducing power consumption in distributed environments. On another side, Dynamic Voltage and Frequency Scaling (DVFS) allows servers to dynamically modify the processor frequency (according to the CPU load) in order to achieve less energy consumption. We observe that while DVFS is widely used, it still generates a waste of energy. By default and thanks to the ondemand governor, it scales up or down the processor frequency according to the current load and the different predefined threshold (up and down). However, DVFS frequency scaling policies are based on advertised processor frequencies, i.e. the set of frequencies constitutes a discrete range of frequencies. The frequency required for a given load will be set to a frequency higher than necessary; which leads to an energy waste. In this paper, we propose a way to emulate a precise CPU frequency thanks to the DVFS management in virtualized environments. We implemented and evaluated our prototype in the Xen hypervisor.

International audience; The Autonomic Administration technology has proved its efficiency for the administration of complex com-puting systems. However, experiments conducted with several Autonomic Administration Systems (AAS) revealed the need to adapt the AAS according to the administrated system or the considered administration facet. Consequently, users usually have to adapt even to re-implement the AAS according to their specific needs but these tasks require high expertise on the AAS implementation that users do not necessarily have. In this paper we propose a service-oriented components approach to build a generic, flexible, and useful AAS. We present an implementation of this approach, the design principles and the prototype called TUNeEngine. We illustrate the flexibility of this prototype through the administration of a complex computing system which is a virtualized cloud platform.

Self-optimization through dynamic resource provisioning is an appealing approach to tackle load variation in Internet services. It allows to assign or release resources to/from Internet services according to the varying load. However, dynamic resource provisioning raises several challenges among which: (i) How to plan a good capacity of an Internet service, i.e.~a necessary and sufficient amount of resource to handle the Internet service workload, (ii) How to manage both gradual load variation and load peaks in Internet services, (iii) How to prevent system oscillations in presence of potentially concurrent dynamic resource provisioning, and (iv) How to provide generic self-optimization that applies to different Internet services such as e-mail services, streaming servers or e-commerce web systems. This paper precisely answers these questions. It presents the design principles and implementation details of a self-optimization autonomic manager. It describes the results of an experimental evaluation of the self-optimization manager with a realistic e-commerce multi-tier web application running in a Linux cluster of computers. The experimental results show the usefulness of self-optimization in terms of end-user's perceived performance and system's operational costs, with a negligible overhead.

National audience; La complexité des systèmes répartis d'aujourd'hui est telle que la présence de bogues et de failles de sécurité est statistiquement inévitable. Une approche très prometteuse pour répondre à ce problème est la construction d'un système auto protégé, qui fonctionnerait de façon analogue à un système immunitaire biologique, capable de détecter l'intrusion d'éléments suspects au sein du système et de réagir à une attaque en cours. Nous avons conçu et implémenté un système autonome appelé JADE qui repose sur une architecture à composants logiciels pour reconfigurer des applications en réaction à des évènements observés. La connaissance de l'architecture de l'application peut être utilisée pour détecter des activités étrangères et pour déclencher des contre-mesures. Nous décrivons comment cette approche peut être appliquée pour ajouter la capacité d'auto protection à une grappe d'application J2EE.

The wide diffusion of Java is partly due to its mechanisms for mobile computing. Java provides most of the functions required to implement mobile applications, essentially code mobility (i.e., dynamic class loading) and data mobility (i.e., object serialization). However, Java does not provide any mechanism for the mobility of the computation (i.e., threads migration). Several projects have addressed the issue of Java thread migration- , e.g.,Sumatra, Wasp, JavaGo, Brakes, CIA. Most of these projects have attempted to minimize the overhead incurred by the migration mechanisms on applications performance, but none of them has been able to completely avoid this overhead. We propose a Java thread migration mechanism that does not incur any performance overhead on migratory threads. In this report, we present the design choices which allowed us to cancel the performance overhead, and we describe the implementation of our thread migration prototype in Sun Microsystems' JDK. We report on the experimental results that confirm the elimination of the performance overhead.

In this report, we present a proxy-based framework for dynamic adaptation in distributed multimedia applications. This proxy can be configured to perform adaptations of multimedia data in real time. Proxy adaptations can be used to manage QoS according to the resources of the underlying environment (capacity of the user terminal or of the network), or to personali- ze (or extend) the functions of the application. We present the motivations for this approach, the implementation of the framework (based on the Microsoft DirectShow environment) and a performance evaluation that demonstrates the effectiveness of the approach.

Today, mobility and persistence are important aspects of distributed computing- . They have many fields of use such as load balancing, fault tolerance and dynamic reconfiguration of applications. In this context, Java provides many useful mechanisms for the mobility of code via dynamic class loading, and the mobility or persistence of data via object serialization. However, Java does not provide any mechanism for the mobility/persistence of computation (i.e., threads). We designed and implemented a new mechanism, called , that is used to build thread mobility or thread persistence. Therefore, a running Java thread can, at an arbitrary state of its execution, migrate to a remote machine where it resumes its execution, or be checkpointed on disk for possible subsequent recovery. With our services, migrating a thread is simply performed by the call of our primitive, and checkpointing/recovering a thread is performed by the call of our and primitives. Several projects have recently addressed the issue of Java thread serialization, e.g., Sumatra, Wasp, JavaGo, Brakes, JavaGoX, Merpati. Some of them have attempted to minimize the overhead incurred by the thread serialization mechanism on thread performance, but none of them has been able to completely avoid this overhead. We propose a generic Java thread serialization mechanism that does not impose any performance overhead on serialized threads. This is achieved thanks to the use of type inference and dynamic de-optimization techniques. In this paper, we describe the design and implementation details of our thread serialization prototype in Sun Microsystems' JDK. We report on experiments conducted with our prototype, present a comparative performance evaluation of the main thread serialization techniques, and confirm the elimination of the performance overhead with our thread serialization mechanism.

Separation of concerns, which aims at separating different aspects involved in complex applications, is a general trend in software programming. It allows a given aspect to be programmed in a more or less isolated manner from the functional code of an application. This trend has been studied by the AOP (Aspect Oriented Programming) community, through the provision of language supports for programming and composing aspects. It has also been experi-mented in the context of component-based middleware, which usually address system-related aspects (e.g., transactions, security, persistence, etc). In both domains, most implementations of separation of concerns involve indirection objects and extra method calls that incur a non-negligible performance over-head. While performance was initially not the main motivation of «separation of concern environments», we believe that it is possible to efficiently integrate as-pects in such environments. In this paper, we report on an experiment which aims at optimizing aspects through code injection techniques. We consider two aspects, replication and access control, and present a preliminary performance evaluation which confirms that the overhead can be significantly reduced.

In this paper, we present the experiment we have conducted to evaluate the suitability of Java cards for advanced applications. We developed a resource-consuming application in a Java card using only the specified Java Card environment, and noted which missing features could have been useful to improve the functionalities of our application or to ease its development. We then propose new system services to improve the Java Card environment.

Designing mechanisms for distributed information management constitute a basic research area of distributed computing. The issues of naming objects, locating objects, sharing objects between cooperating users, and access control are problems that heavily impact the design of a distributed operating system. This Habilitation à Diriger les Recherches summarizes my research in the framework of two projects: the Guide project from the Bull-IMAG joint research laboratory (1990 to 1994) and my ongoing research in the Sirac project (started in 1995). In the context of these two projects, I have studied the fundamental mechanisms for management of distributed information in different environments, i.e. a distributed object based system (Guide), a distributed shared memory (Arias) and more recently a Java-based distributed object system. The lessons learned from these projects are reported and I present the directions for my research in the years to come.; L'accès et le contrôle d'accès à l'information réparties constituent un domaine fondamental de l'informatique répartie. En effet, la désignation des objets qui encapsulent l'information, la localisation de ces objets, leur partage entre les usagers autorisés, leurs accès et les contrôles de ces accès déterminent les structures de base de toute architecture de système réparti. Cette Habilitation à Diriger les Recherches résume un ensemble de travaux que j'ai essentiellement réalisés dans le cadre de deux projets de recherche : le projet GUIDE mené à l'Unité Mixte Bull-IMAG de 1990 à 1994, et le projet SIRAC qui a débuté en 1995 et qui se poursuit actuellement. A travers ces projets, j'ai été amené à étudier les problèmes d'accès et de contrôle d'accès dans des environnements très différents, à savoir un système à objets répartis (Guide), une mémoire virtuelle répartie (Arias) et plus récemment un environnement Java réparti sur l'Internet. A partir d'un bilan des travaux effectués et des résultats obtenus, je dresse les perspectives de recherches pour les années à venir.

Designing mechanisms for distributed information management constitute a basic research area of distributed computing. The issues of naming objects, locating objects, sharing objects between cooperating users, and access control are problems that heavily impact the design of a distributed operating system. This Habilitation à Diriger les Recherches summarizes my research in the framework of two projects: the Guide project from the Bull-IMAG joint research laboratory (1990 to 1994) and my ongoing research in the Sirac project (started in 1995). In the context of these two projects, I have studied the fundamental mechanisms for management of distributed information in different environments, i.e. a distributed object based system (Guide), a distributed shared memory (Arias) and more recently a Java-based distributed object system. The lessons learned from these projects are reported and I present the directions for my research in the years to come.; L'accès et le contrôle d'accès à l'information réparties constituent un domaine fondamental de l'informatique répartie. En effet, la désignation des objets qui encapsulent l'information, la localisation de ces objets, leur partage entre les usagers autorisés, leurs accès et les contrôles de ces accès déterminent les structures de base de toute architecture de système réparti. Cette Habilitation à Diriger les Recherches résume un ensemble de travaux que j'ai essentiellement réalisés dans le cadre de deux projets de recherche : le projet GUIDE mené à l'Unité Mixte Bull-IMAG de 1990 à 1994, et le projet SIRAC qui a débuté en 1995 et qui se poursuit actuellement. A travers ces projets, j'ai été amené à étudier les problèmes d'accès et de contrôle d'accès dans des environnements très différents, à savoir un système à objets répartis (Guide), une mémoire virtuelle répartie (Arias) et plus récemment un environnement Java réparti sur l'Internet. A partir d'un bilan des travaux effectués et des résultats obtenus, je dresse les perspectives de recherches pour les années à venir.

Projet SOR; The PerDiS (Persistent Distributed Store) project addresses the issue of providing support for distributed collaborative engineering applications. We describe the design and implementation of the PerDiS platform, and its support for such applications. Collaborative engineering raises systems issues related to the sharing of large volumes of fine-grain, complex objects across wide-area networks and administrative boundaries. PerDiS automatically manages all these aspects in a well defined, integrated, and automatic way. Distributed application programming is simplified because it uses the same memory abstraction as in the centralized case. Porting an existing centralized program is usually a matter of a few, well-isolated changes. We present some performance results from a proof-of-concept platform that runs a number of small, but real, distributed applications on Unix and Windows NT. These confirm that the PerDiS abstraction is well adapted to the targeted application area and that the overall performance is promising compared to alternative approaches.

This work has been carried out in the framework of the Guide project, which aims at designing and implementing a system for the support of distributed persistent objects. The thesis is structured into two parts. The first part addresses the design problems for such a system and describes various approaches adopted in similar projects. The second part is devoted to the presentation of the work achieved within the Guide project. A major result is the design and prototype implementation of a distributed kernel called Eliott on the Mach 3.0 micro-kernel, which provides a generic support for a family of object-oriented languages. This kernel was used to develop pilot distributed object-oriented applications. The Eliott kernel manages persistent objects and provides object sharing between tasks which are multithreaded distributed execution structures. For efficiency reasons, objects are grouped into clusters, but a given object may migrate from one cluster to another according to administrative clustering policies. Objects are dynamically bound into tasks virtual address spaces. For security purpose, objects can be isolated from each other so that an error in a given object can not damage another object. To achieve this goal, a lightweight segmented addressing scheme "a la Multics" was designed. The general addressing scheme also includes access-control mechanisms, which are based on access-lists specified at the operation level. These mechanisms allow the construction of mutually suspicious protected subsystems. Control structures, including protection data are generated at the first invocation of a given object. This information is then used to perform efficiently subsequent invocations of the same object.; Ce travail de these se situe dans le cadre du projet Guide dont le but est la conception et la realisation dun systeme reparti fournissant un support d'objets partages persistants. Dans une premiere partie, cette these etudie les problemes poses par la conception d'un tel systeme, les differentes approches rencontrees dans les systemes existants illustrant cette etude. La seconde partie est consacree a la presentation du travail realise dans le cadre du projet Guide. Un noyau de systeme appele Eliott a ete realise sur le micro-noyau Mach 3.0 et fournit le support necessaire aux langages orientes-objets utilises pour la programmation dapplications reparties. Le noyau Eliott gere a la fois la persistance des objets et le partage des objets entre les structures d'execution. Les objets sont regroupes en grappes, ce qui permet de les gerer plus efficacement dans le systeme ; ils peuvent etre deplaces entre les grappes. Les structures d'execution sont des espaces dadressage repartis partages par plusieurs flots dexecution ; les objets sont lies dynamiquement dans ces espaces d'adressage. Pour assurer un niveau de protection minimum, le systeme isole les objets afin d'eviter qu'une erreur dans un programme puisse perturber d'autres objets. Un schema dadressage a la Multics a ete defini afin deviter une interpretation systematique des appels de methode. Des mecanismes de controle des droits d'acces fondes sur des listes dacces sont integres a ce schema d'adressage et permettent la construction de sous-systemes proteges mutuellement mefiants. La realisation de ces mecanismes a ete effectuee sans degrader l'efficacite de l'appel de methode. La verification de la protection genere un cout supplementaire lors du premier appel qui est interprete, mais aucun cout pour les appels suivants.

This work has been carried out in the framework of the Guide project, which aims at designing and implementing a system for the support of distributed persistent objects. The thesis is structured into two parts. The first part addresses the design problems for such a system and describes various approaches adopted in similar projects. The second part is devoted to the presentation of the work achieved within the Guide project. A major result is the design and prototype implementation of a distributed kernel called Eliott on the Mach 3.0 micro-kernel, which provides a generic support for a family of object-oriented languages. This kernel was used to develop pilot distributed object-oriented applications. The Eliott kernel manages persistent objects and provides object sharing between tasks which are multithreaded distributed execution structures. For efficiency reasons, objects are grouped into clusters, but a given object may migrate from one cluster to another according to administrative clustering policies. Objects are dynamically bound into tasks virtual address spaces. For security purpose, objects can be isolated from each other so that an error in a given object can not damage another object. To achieve this goal, a lightweight segmented addressing scheme "a la Multics" was designed. The general addressing scheme also includes access-control mechanisms, which are based on access-lists specified at the operation level. These mechanisms allow the construction of mutually suspicious protected subsystems. Control structures, including protection data are generated at the first invocation of a given object. This information is then used to perform efficiently subsequent invocations of the same object., Ce travail de these se situe dans le cadre du projet Guide dont le but est la conception et la realisation dun systeme reparti fournissant un support d'objets partages persistants. Dans une premiere partie, cette these etudie les problemes poses par la conception d'un tel systeme, les differentes approches rencontrees dans les systemes existants illustrant cette etude. La seconde partie est consacree a la presentation du travail realise dans le cadre du projet Guide. Un noyau de systeme appele Eliott a ete realise sur le micro-noyau Mach 3.0 et fournit le support necessaire aux langages orientes-objets utilises pour la programmation dapplications reparties. Le noyau Eliott gere a la fois la persistance des objets et le partage des objets entre les structures d'execution. Les objets sont regroupes en grappes, ce qui permet de les gerer plus efficacement dans le systeme ; ils peuvent etre deplaces entre les grappes. Les structures d'execution sont des espaces dadressage repartis partages par plusieurs flots dexecution ; les objets sont lies dynamiquement dans ces espaces d'adressage. Pour assurer un niveau de protection minimum, le systeme isole les objets afin d'eviter qu'une erreur dans un programme puisse perturber d'autres objets. Un schema dadressage a la Multics a ete defini afin deviter une interpretation systematique des appels de methode. Des mecanismes de controle des droits d'acces fondes sur des listes dacces sont integres a ce schema d'adressage et permettent la construction de sous-systemes proteges mutuellement mefiants. La realisation de ces mecanismes a ete effectuee sans degrader l'efficacite de l'appel de methode. La verification de la protection genere un cout supplementaire lors du premier appel qui est interprete, mais aucun cout pour les appels suivants.

International audience; Nested/Extended Page Table (EPT) is the current hardware solution for virtualizing memory in virtualized systems. It induces a significant performance overhead due to the 2D page walk it requires, thus 24 memory accesses on a TLB miss (instead of 4 memory accesses in a native system). This 2D page walk constraint comes from the utilization of paging for managing virtual machine (VM) memory. This paper shows that paging is not necessary in the hypervisor. Our solution Compromis, a novel Memory Management Unit, uses direct segments for VM memory management combined with paging for VM's processes. This is the first time that a direct segment based solution is shown to be applicable to the entire VM memory while keeping applications unchanged. Relying on the 310 studied datacenter traces, the paper shows that it is possible to provision up to 99.99% of the VMs using a single memory segment. The paper presents a systematic methodology for implementing Compromis in the hardware, the hypervisor and the datacenter scheduler. Evaluation results show that Compromis outperforms the two popular memory virtualization solutions: shadow paging and EPT by up to 30% and 370% respectively.

This thesis focuses on replication and consistency configuration in distributed applications. It aims to define configuration mechanisms that do not impose modifications to the business code of applications and that allow reuse of replication and consistency management code. The first point responds to the need to execute applications in different contexts. The second point allows replication protocols to be used in different applications. The thesis objectives are considered in the case of component-based applications. Non intrusive replication configuration is based on the separation between the components' business code and their system code. Replication code reuse is achieved through modeling of protocols in terms of application-independent components. The proposed models for programming, composition and execution of protocols and applications are validated using a Java prototype implementation. We measure the cost of our replication management and analyze the way its principles can be applied to the EJB and CCM environments. We show the configuration and reuse facilities of our prototype through several experiments involving different applications, as well as different replication protocols., Cette thèse s'intéresse à la gestion configurable de la duplication et de la cohérence dans les applications réparties. Elle vise la définition de mécanismes de configuration qui n'impliquent pas de modification du code métier des applications et qui permettent la réutilisation du code de gestion de la duplication et de la cohérence. Le premier objectif permet d'exécuter les applications dans différents environnements sans les réimplémenter. Le deuxième objectif permet de réutiliser les protocoles de duplication et de cohérence dans différents domaines d'application. Cette thèse se place dans le contexte des applications réparties à base de composants. Elle permet la configuration non intrusive de la duplication et de la cohérence en se basant sur la séparation entre le code métier et le code système des composants. Elle permet la réutilisation du code de gestion de la duplication et de la cohérence en modélisant les protocoles en termes de composants qui sont indépendants des applications métier. Les modèles de programmation, de composition et d'exécution proposés sont validés à l'aide d'un prototype Java. Le coût de gestion de la duplication et de la cohérence est évalué et l'applicabilité de l'approche aux environnements CCM et EJB est étudiée. Les capacités de configuration et de réutilisation sont démontrées par des expérimentations avec plusieurs applications et plusieurs protocoles.

This work tackles the problem of applications mobility and applications persistence in heterogeneous environments. These functions have many fields of use such as dynamic load balancing in distributed systems, fault tolerance and dynamic reconfiguration of distributed applications. Applications mobility and persistence have been largely addressed at the operating system level and at the programming language/model level. However, few works were done at the virtual machine level. The goal of this thesis is to propose mobility and persistence functions at the Java virtual machine level. The Java environment provides many useful tools for making code and data mobile or persistent but it does not address threads' execution state mobility and persistence. We provide such functionalities, following two principles : portability across heterogeneous platforms with respect to applications performance. Indeed, regarding performance, an important effort was made by Java's designers in terms of execution optimization and Just-In-Time (JIT) compilation. Our solution allows us to provide mobility and persistence functions that are portable even in the presence of JIT compilation. This is performed by basing our solution, on the one hand, on techniques of dynamic type inference via flow analysis, and on the other hand, on techniques of dynamic de-optimization of compiled Java code. Our mobility and persistence services were implemented as an extension of Sun Microsystems' Java virtual machine. They are operational and were used in a metacomputing platform for fault tolerance purpose. Nowadays, this solution is the unique approach that is complete without inducing any performance overhead for applications., Les travaux de cette thèse portent sur la mobilité et la persistance des applications dans des environnements hétérogènes. Ces fonctions sont utiles à la répartition dynamique de charge dans les systèmes distribués, à la reconfiguration dynamique d'applications réparties ou à la mise en place de techniques de tolérance aux pannes. La mobilité et la persistance des applications ont largement été abordées au niveau du système d'exploitation ou au niveau du langage/modèle de programmation. Mais très peu de travaux ont été menés au niveau des machines virtuelles. L'objet de cette thèse est l'étude et la réalisation de fonctions de mobilité et de persistance dans la machine virtuelle Java. L'environnement Java fournit des outils pour la mobilité et la persistance du code et des données mais il n'adresse pas le problème de mobilité ni de persistance de l'état d'exécution des processus légers (threads). Les travaux de cette thèse portent sur la conception de tels services, une conception guidée par deux principes : la portabilité sur des environnements hétérogènes et le respect des performances des applications. Pour des besoins de performances, plusieurs efforts ont été faits par les concepteurs de Java en matière d'optimisation de l'exécution et de compilation à la volée. Notre solution permet de fournir des fonctions de mobilité et de persistance portables même en présence de compilation à la volée. Ceci est mis en oeuvre en reposant, d'une part, sur des techniques d'inférence dynamique du type des données sur la pile d'exécution à partir du code Java exécuté et, d'autre part, sur des techniques de dés-optimisation dynamique du code Java compilé à la volée. Nos services ont été réalisés via une extension de la machine virtuelle Java de Sun Microsystems. Ils sont opérationnels et ont pu être validés pour des besoins de tolérance aux pannes dans une plate-forme de metacomputing. Notre solution est actuellement l'unique approche qui est complète et qui élimine toute pénalité sur l'exécution des applications.