Surveillance de l'exécution et analyse de préemption entre machines virtuelles

RÉSUMÉ Au cours des dernières années, l'infonuagique a pris un essor considérable dans le domaine de l'informatique. Cette technologie oriente les parcs informatiques à grande échelle vers un modèle flexible, portable et souvent écoénergétique. Les fournisseurs de services infonuagiques offrent à leurs clients un environnement isolé, disponible, et surtout adapté à leurs besoins. Les machines virtuelles non seulement répondent à ces critères, mais procurent aussi des avantages supplémentaires. Les coûts de gestion de matériel, de consommation d'électricité et de licences de logiciels sont réduits dans un tel modèle. Ainsi, dans un nuage informatique, un grand nombre de machines virtuelles (VM, ou système invité), gérées par un hyperviseur, cohabitent sur un même poste physique dont elles se partagent les ressources. Cependant, les machines virtuelles sont entièrement isolées les unes des autres et ont toutes l'illusion d'avoir un accès exclusif et absolu aux ressources de leur hôte. Ces ressources sont souvent surengagées, dans le sens où elles apparaissent comme étant plus disponibles qu'elles ne sont réellement. Cette caractéristique introduit inévitablement des baisses de performance aux applications des machines virtuelles, dont les sources dépendent de l'environnement externe et sont à priori impossibles à identifier. L'objectif de cette étude est d'offrir aux administrateurs des machines hôtes un outil permettant de surveiller les interactions des systèmes d'exploitation invités et localiser facilement les anomalies de performance lorsqu'elles surviennent. Notre approche est basée sur le traçage, une méthode de surveillance qui s'est avérée efficace pour la compréhension du détail de fonctionnement d'une application. Par ailleurs, le traçage noyau permet d'effectuer la surveillance de vue globale d'un système d'exploitation. On peut ensuite analyser les interactions entre les applications utilisateurs qu'il sert et le matériel disponible qu'il exploite. En traçant simultanément le système hôte et les machines virtuelles, il est possible d'agréger les informations collectées de ces différentes sources et de présenter en clair à l'utilisateur les interactions entre les différents systèmes qui sont à priori invisibles. Cette étude se concentre sur les CPUs comme ressources partagées. Le déni du CPU à une machine virtuelle par le système hôte y introduit des délais invisibles, mais bien présents. Nous utilisons LTTng, un traceur à bas surcoût d'utilisation, pour collecter des traces noyau générées sur les différents systèmes d'exploitation. Une fois les traces agrégées, il est possible de modéliser l'ensemble des systèmes concernés et d'effectuer un bilan d'utilisation et d'interactions entre ceux-ci. L'indisponibilité du CPU pour chaque VM est alors présentée à l'administrateur du parc informatique, qui peut par la suite prendre les mesures nécessaires pour remédier aux problèmes. Cependant, tel que nous l'expliquerons dans ce mémoire, l'agrégation des traces est une tâche non triviale. En effet, chaque système d'exploitation, hôte ou invité, est responsable de sa propre gestion d'horloge. Par conséquent, les estampilles de temps assignées aux évènements des traces ne sont cohérentes que dans le contexte propre à chaque système. Un algorithme de synchronisation de traces distribuées a été adapté au contexte des machines virtuelles pour remédier à la non-conformité des horloges.----------ABSTRACT Over the past few years, Cloud computing has enjoyed a considerable growth in the field of computer science. This technology is leading warehouse-scale data clusters towards a more flexible, portable, and environmentally friendly model. Cloud providers offer to their customers environments that are isolated, available, and above all adapted to their needs. System virtualization not only meets these criterias, but also provides additional benefits. Management costs of hardware, energy consumption and software licenses are reduced in such a model. Thus, in a Cloud environment, a large number of virtual machines (VM, or guest system), managed by a hypervisor, coexist on the same physical computer whose resources are shared amongst them. However, virtual machines are fully isolated from one another and all have the illusion of absolute and exclusive access to the host's resources. These resources are often overcommitted whereas they appear as being more available than they actually are. This property inevitably induces performance setbacks in virtual machines. Because of system isolation, it is a priori impossible to find the source of performance problems that depend on the external environment. The objective of this study is to provide the host administrators with a tool to monitor the interactions of the guest operating systems, allowing them to easily locate and justify performance anomalies when they occur. Our approach is based on tracing, a monitoring method that has been proven effective to give detailed information about the functioning of an application. Furthermore, kernel tracing allows to monitor the operating system and assess the interactions between users' applications it serves and the available material which it operates. By tracing the host and the virtual machines simultaneously, it is possible to aggregate the information collected from these various systems and present clearly to the user the interactions between the various systems that are usually invisible. This study focuses on the CPU as a shared resource. The denial of a CPU by the host to a VM introduces invisible yet effective latency. We use LTTng, a low overhead userspace and kernel tracer, to collect kernel traces generated on different operating systems. Once the traces are aggregated, it is possible to model all of the systems concerned and to summarize resources contention and interactions between them. The unavailability of the CPU for each VM is then presented to the administrator of the host, which can then take the necessary steps to remedy the problems. However, as we present in this thesis, aggregation of traces turned out to be a non-trivial task. Indeed, each operating system, host or guest, is responsible for its own timekeeping. Therefore, drifts between the clocks of the different systems are introduced, and the timestamps assigned to trace events are not consistent across traces. A portable method to address clock drifts and trace synchronization is also proposed

Fine-grained preemption analysis for latency investigation across virtual machines

This paper studies the preemption between programs running in different virtual machines on the same computer. One of the current monitoring methods consist of updating the average steal time through collaboration with the hypervisor. However, the average is insufficient to diagnose abnormal latencies in time-sensitive applications. Moreover, the added latency is not directly visible from the virtual machine point of view. The main challenge is to recover the cause of preemption of a task running in a virtual machine, whether it is a task on the host computer or in another virtual machine. We propose a new method to study thread preemption crossing virtual machines boundaries using kernel tracing. The host computer and each monitored virtual machine are traced simultaneously. We developed an efficient and portable trace synchronization method, which is required to account for time offset and drift that occur within each virtual machine. We then devised an algorithm to recover the root cause of preemption between threads at every level. The algorithm successfully detected interactions between multiple competing threads in distinct virtual machines on a multi-core machine

Survey and analysis of kernel and userspace tracers on Linux : design, implementation, and overhead

As applications and operating systems are becoming more complex, the last decade has seen the rise of many tracing tools all across the software stack. This article presents a hands-on comparison of modern tracers on Linux systems, both in user space and kernel space. The authors implement microbenchmarks that not only quantify the overhead of different tracers, but also sample fine-grained metrics that unveil insights into the tracers’ internals and show the cause of each tracer’s overhead. Internal design choices and implementation particularities are discussed, which helps us to understand the challenges of developing tracers. Furthermore, this analysis aims to help users choose and configure their tracers based on their specific requirements to reduce their overhead and get the most of out of them