Towards QoS-Oriented SLA Guarantees for Online Cloud Services

International audienceCloud Computing provides a convenient means of remote on-demand and pay-per-use access to computing resources. However, its ad hoc management of quality-of-service and SLA poses significant challenges to the performance, dependability and costs of online cloud services. The paper precisely addresses this issue and makes a threefold contribution. First, it introduces a new cloud model, the SLAaaS (SLA aware Service) model. SLAaaS enables a systematic integration of QoS levels and SLA into the cloud. It is orthogonal to other cloud models such as SaaS or PaaS, and may apply to any of them. Second, the paper introduces CSLA, a novel language to describe QoS-oriented SLA associated with cloud services. Third, the paper presents a control-theoretic approach to provide performance, dependability and cost guarantees for online cloud services, with time-varying workloads. The proposed approach is validated through case studies and extensive experiments with online services hosted in clouds such as Amazon EC2. The case studies illustrate SLA guarantees for various services such as a MapReduce service, a cluster-based multi-tier e-commerce service, and a low-level locking service

Puma: pooling unused memory in virtual machines for I/O intensive applications

International audienceWith the advent of cloud architectures, virtualization has become a key mechanism. In clouds, virtual machines (VMs) offer both isolation and flexibility. This is the foundation of cloud elasticity, but it induces fragmentation of the physical resources, including memory. While each VM memory needs evolve during time, existing mechanisms used to dynamically adjust VMs memory are inefficient, and it is currently impossible to take benefit of the unused memory of VMs hosted by another host. In this paper we propose Puma, a mechanism that improves I/O intensive applications performance by providing the ability for a VM to entrust clean page-cache pages to other VMs having unsused memory. By reusing the existing page-cache data structures, Puma is very efficient to reclaim the memory lent to another VM. By being distributed, Puma increases the memory consolidation at the scale of a data center. In our evaluations made with TPC-C, TPC-H, BLAST and Postmark, we show that Puma can significantly boost the performance without impacting potential activity peaks on the lender

PUMA: Un cache distant pour mutualiser la mémoire inutilisée des machines virtuelles

National audienceCertaines applications, comme les serveurs d'e-commerce, effectuent beaucoup d'opérations d'entrée/sortie (E/S) sur disque. Leurs performances sont étroitement liées à l'efficacité de ces opérations. Pour les améliorer, les systèmes d'exploitation tels que Linux utilisent la mémoire libre pour fournir des mécanismes de cache. Cependant, les ressources d'aujourd'hui sont virtualisées : par exemple, dans les clouds, les machines virtuelles (MVs) peuvent être déployées et déplacées entre les hôtes physiques pour offrir à la fois isolation et flexibilité. Ceci implique une fragmentation des ressources physiques, dont la mémoire. Cette fragmentation limite la quantité de mémoire disponible d'une MV pour y mettre ses données en cache. Dans cet article, nous proposons PUMA, un mécanisme de cache distant qui permet à une MV d'étendre son cache en utilisant la mémoire d'autres MVs situées sur un hôte local ou distant. Nos évaluations montrent que PUMA permet de multiplier les performances des applications par 9

A fair starvation-free prioritized mutual exclusion algorithm for distributed systems

International audienceSeveral distributed mutual exclusion algorithms define the order in which requests are satisfied based on the priorities assigned to requests. These algorithms are very useful for real-time applications ones or those where priority is associated to a quality of service requirement. However, priority based strategies may result in starvation problems where high priority requests forever prevent low priority ones to be satisfied. To overcome this problem, many priority-based algorithms propose to gradually increase the priority of pending requests. The drawback of such an approach is that it can violate priority-based order of requests leading to priority inversion. Therefore, aiming at minimizing the number of priority violations without introducing starvation, we have added some heuristics in Kanrar-Chaki priority-based token-oriented algorithm in order to slow down the frequency with which priority of pending requests is increased. Performance evaluation results confirm the effectiveness of our approach when compared to both the original Kanrar-Chaki and Chang's priority-based algorithms

Un algorithme équitable d'exclusion mutuelle distribuée avec priorité

National audienceLes algorithmes distribués d'exclusion mutuelle à priorité permettent de définir un ordre d'accès aux sections critiques protégeant des ressources partagées. Ces algorithmes sont très utiles dans les applications temps-réel ou pour assurer différents niveaux de qualité de service [6]. Cependant, la prise en compte des priorités peut conduire à des famines dans le cas où des demandes de sections critique les plus prioritaires empêchent la satisfaction des moins prioritaires. Pour palier ce problème, certains algorithmes comme celui de Kanrar-Chaki proposent d'incrémenter progressivement les priorités des requêtes pendantes mais ceci peut conduire à une violation de l'ordre des priorités. Ainsi, pour minimiser ces violations sans engendrer de famine et de surplus de messages, nous proposons des modifications de l'algorithme de Kanrar-Chaki pour ralentir la fréquence d'incrémentation des priorités. Nos évaluations des performances confirment l'efficacité de notre approche

Vers un cache réparti adapté au cloud computing

National audienceComposer plusieurs infrastructures fournies en tant que service (IaaS) pour former une plate-forme virtualisée (PaaS) nécessite l'introduction d'un mécanisme de cache permettant d'offrir certaines garanties en termes de performances et de cohérence à l'utilisateur. Les caches répartis permettent d'offrir ce type de service et sont particulièrement bien adaptés aux environnements distribués, surtout lorsqu'ils offrent une faible latence réseau. Bien souvent, ces caches répartis sont associés à des systèmes de fichiers répartis ou sont implantés au niveau applicatif, nécessitant d'adapter les applications existantes, ce qui n'est pas compatible avec la philosophie du cloud. Cet article propose une approche générique pour développer un cache réparti en l'intégrant directement dans le noyau Linux, ce qui permet d'ap- porter le niveau de généricité dont les clouds ont besoin. Nous avons implémenté un prototype de cache réparti utilisant cette approche. Notre évalation des performances montre que nous pouvons multiplier par 6 le débit lors de lectures aléatoires

Comparaisons équitables des algorithmes de gossip sur les topologies aléatoires à grande-échelle

National audienceCet article compare les performances des trois grandes familles de protocoles probabilistes de dissémination d'informations (gossip) exécutées sur trois graphes aléatoires. Les trois graphes représentent les topologies typiques des réseaux à grande-échelle : le graphe de Bernoulli (ou Erdos-Rényi), le graphe géométrique aléatoire et le graphe scale-free. Nous proposons un nou- veau paramètre générique : le fanout effectif. Pour une topologie et un algorithme donnés, le fanout effectif caractérise la puissance moyenne de la dissémination des sites. Il permet l'analyse précise du comportement d'un algorithme sur une topologie. De plus, il simplifie la comparaison théorique des différents algorithmes sur une topologie. En s'appuyant sur les résultats obtenus par les expérimentations dans le simulateur OMNET++, qui exploitent le fanout effectif, nous étudions l'impact des topologies et les algorithmes sur les performances. Nous suggérons également une façon de les combiner afin d'obtenir le meilleur gain en termes de fiabilité

Towards multi-SDN services: Dangers of concurrent resource allocation from multiple providers

International audienceOne of the Software-Defined Networking (SDN) promises is the programmability of networks through Application Programming Interfaces (APIs). Those APIs allow different users to access the network concurrently. Thus leading to the allocation of dedicated critical resources by a given Service Provider. In this paper we formalize the problem of deadlocks , and present a case where they occur

2W-FD: A Failure Detector Algorithm with QoS

International audienceFailure detection plays a central role in the engineering of distributed systems. Furthermore, many applications have timing constraints and require failure detectors that provide quality of service (QoS) with some quantitative timeliness guarantees. Therefore, they need failure detectors that are fast and accurate. We introduce the Two Windows Failure Detector (2W-FD), an algorithm that provides QoS and is able to react to sudden changes in network conditions, a property that currently existing algorithms do not satisfy. We ran tests on real traces and compared the 2W-FD to state-of-the-art algorithms. Our results show that our algorithm presents the best performance in terms of speed and accuracy in unstable scenarios

Fewer Cores, More Hertz: Leveraging High-Frequency Cores in the OS Scheduler for Improved Application Performance

International audienceIn modern server CPUs, individual cores can run at different frequencies, which allows for fine-grained control of the per-formance/energy tradeoff. Adjusting the frequency, however, incurs a high latency. We find that this can lead to a problem of frequency inversion, whereby the Linux scheduler places a newly active thread on an idle core that takes dozens to hundreds of milliseconds to reach a high frequency, just before another core already running at a high frequency becomes idle. In this paper, we first illustrate the significant performance overhead of repeated frequency inversion through a case study of scheduler behavior during the compilation of the Linux kernel on an 80-core Intel R Xeon-based machine. Following this, we propose two strategies to reduce the likelihood of frequency inversion in the Linux scheduler. When benchmarked over 60 diverse applications on the Intel R Xeon, the better performing strategy, S move , improves performance by more than 5% (at most 56% with no energy overhead) for 23 applications, and worsens performance by more than 5% (at most 8%) for only 3 applications. On a 4-core AMD Ryzen we obtain performance improvements up to 56%