Jonathan Lejeune

Towards QoS-Oriented SLA Guarantees for Online Cloud Services

Cloud 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.

SLA guarantees for cloud services

Quality-of-service and SLA guarantees are among the major challenges of cloud-based services. In this paper we first present a new cloud model called SLAaaS - SLA?aware Service. SLAaaS considers QoS levels and SLA as first class citizens of cloud-based services. This model is orthogonal to other SaaS, PaaS, and IaaS cloud models, and may apply to any of them. More specifically we make three contributions: (i) we provide a novel domain specific language that allows to describe QoS-oriented SLA associated with cloud services; (ii) we present a general control-theoretic approach for managing cloud service SLA; (iii) we apply the proposed language and control approach to guarantee SLA in various case studies, ranging from cloud-based MapReduce service, to locking service, and higher-level e-commerce service; these case studies successfully illustrate SLA management with different QoS aspects of cloud services such as performance, dependability, financial energetic costs. We provide a domain specific language that allows to describe SLA in cloud services.We present a general control-theoretic approach for managing cloud service SLA.We apply our approach on MapReduce, locking, and e-commerce services.

Service Level Agreement for Distributed Mutual Exclusion in Cloud Computing

In Cloud Computing, Service Level Agreement (SLA) is a contract that defines a level and a type of QoS between a cloud provider and a client. Since applications in a Cloud share resources, we propose two tree-based distributed mutual exclusion algorithms that support the SLA concept. The first one is a modified version of the priority-based Kanrar-Chaki algorithm [1] while the second one is a novel algorithm, based on Raymond algorithm [2], where a deadline is associated with every request. In both cases, our aim is to improve Critical Section execution rate and to reduce the number of SLA violations, which, for the first algorithm represents the number of priority inversions (i.e. a higher priority request is satisfied after a lower one) and for the second one, the number of requests whose deadline is not respected. Performance evaluation results show that our solutions significantly reduce SLA violations avoiding message overhead.

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

Several 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 Changs priority-based algorithms. Our algorithm is based on two mechanisms aiming at postponing priority increment and reducing messages overhead.Priority increment postponing reduces the amount of priority violations without introducing starvation.Taking into account request locality allows to reduce the message overhead due to the priority postponement.Priority increment increases significantly the waiting time of the lowest priorities.The location of processes on the logical tree topology has an impact over performance.

Vers une plate-forme MapReduce tolérant les fautes byzantines

Les pannes arbitraires sont inherentes aux calculs massivement paralleles tels que ceux vises par le modele MapReduce ; or les implementations courantes du MapReduce ne fournissent pas d’outils permettant de tolerer les fautes byzantines. Il est donc impossible de certifier l’exactitude des resultats obtenus au terme des traitements longs et couteux. Nous presentons dans cet article une architecture permettant de repliquer les tâches dans le modele MapReduce afin de garantir l’integrite des traitements et d’isoler les tâches defaillantes. Dans une premiere etude de performances nous avons evalue certains mecanismes lies a la replication. Une seconde etude, effectuee avec un prototype implementant l’ensemble de l’architecture, a permis de valider certains choix en montrant qu’il est possible de minimiser le surcout de la tolerance aux fautes byzantines.

Allouer efficacement des ressources dans un environnement distribué.

RÉSUMÉ. Les algorithmes d’exclusion mutuelle généralisée permettent de gérer les accès concurrents des processus sur un ensemble de ressources partagées. Cependant, ils doivent assurer un accès exclusif à chaque ressource. Afin d’éviter les interblocages beaucoup de solutions reposent sur l’hypothèse forte d’une connaissance préalable des conflits entre les requêtes des processus. D’autres approches, qui ne requièrent pas une telle connaissance, utilisent un mécanisme de diffusion ou un verrou global, dégradant ainsi la complexité en messages et augmentant le coût de synchronisation. Nous proposons dans cet article un nouvel algorithme pour l’allocation de ressources partagées qui réduit les communications entre processus non conflictuels sans connaître à l’avance le graphe des conflits. Les résultats de nos évaluations de performances montrent que notre solution améliore le taux d’utilisation d’un facteur 1 à 20 comparé à un algorithme se basant sur un verrou global.