Optimisation des entrées-sorties dans les architectures multi-tiers

input-output optimization in multi-tiers architectures

• Auteur / Autrice : Brice Ekane apah
• Direction : Noël de Palma, Daniel Hagimont
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 08/12/2022
• Etablissement(s) : Université Grenoble Alpes
• Ecole(s) doctorale(s) : École doctorale Mathématiques, sciences et technologies de l'information, informatique (Grenoble ; 1995-....)
• Partenaire(s) de recherche : Laboratoire : Laboratoire d'informatique de Grenoble (2007-....)
• Jury : Président / Présidente : Alain Bouzaïde Tchana
• Jury : Examinateurs / Examinatrices : Mathieu Bacou
• Jury : Rapporteur / Rapporteuse : Jean-Marc Menaud, David Bromberg

Mots clés

Mots clés contrôlés

Analyse entrées-sorties

Mots clés libres

Gestion de ressources

Entrées-Sorties

Optimisation

Architectures multi-Tiers

Resource management

Input-Output

Optimization

Multi-Tiers architectures

Résumé

Pour des raisons de modularité et de scalabilité, la plupart des services en ligne déployés dans des datacenters reposent sur une architecture multi-tiers dans laquelle plusieurs composants logiciels sont déployés sur des machines différentes (par exemple un équilibreur de charge, un serveur web, une application métier et un serveur de base de données). Ces tiers interagissent à travers des communications réseaux, le plus souvent reposant sur le protocole TCP/IP. Un client externe au datacenter peut se connecter à un tier frontal (le point d'entrée) et soumettre une requête, provoquant un traitement distribué entre les tiers et retournant au client une réponse incluant des données. Les interactions entre les tiers suivent le modèle classique client-serveur.Nous observons que dans ces services, une quantité significative des données retournées au client sont émises par des tiers dans cette architecture, sans que les tiers par lesquels passe la réponse et ces données (au retour, en passant par le tier frontal) n'exploitent les données. Les tiers qui précédent le tier émettant les données ne font que les propager. Les communications nécessaires pour faire remonter ces données dans l'architecture multi-tiers sont inutiles et sources d'une charge de calcul significative dans le datacenter.L'objectif de cette thèse est de réduire ces communications inutiles en introduisant un mécanisme de raccourci. Lorsque dans l'architecture multi-tiers, un tier génère des données qui ne sont pas exploitées par les tiers qui le précédent avant leur retour au client, alors un raccourci permet à ce tier de retourner directement les données au client sans passer par les tiers intermédiaires. La mise en place d'un mécanisme de raccourci revient à distribuer la connexion TCP entre le client et le tiers frontal, celle-ci devenant accessible à tous les tiers.Deux problèmes rendent difficile l'implantation de cette notion de raccourci. Premièrement, il faut coordonner les différents tiers émetteurs pour garantir la cohérence interne de TCP (en particulier la gestion des numéros de séquence de TCP et des acquittements). Deuxièmement, les raccourcis bousculent la cohérence interne des applications et il faut modifier les applications dans ce sens. Les solutions actuelles nécessitent soit une modification du protocole TCP, soit des modifications importantes des applications.Nous montrons comment il est possible de distribuer une session TCP comme évoqué précédemment sans modification du protocole TCP. Nous montrons que les modifications sur les applications sont mineures et qu'il est même possible d'implanter des raccourcis sans modification des applications. Enfin, nous conduisons une évaluation de performances qui montre que ces raccourcis permettent de réduire significativement la charge de calcul dans le datacenter, sans dégrader les performances des communications en termes de latence ou de débit.

For modularity and scalability reasons, most online services deployed in datacenters rely on a multi-tier architecture where several software components are deployed on different machines (e.g. a load balancer, a web server, a business logic application, and a database server). These tiers interact through network communications mostly relying on the TCP/IP protocol. A client, external to the data center, can connect to a frontal tier (the entry point) and submit a request, triggering a distributed execution between tiers which returns to the client a response that includes data. Interactions between tiers follow the classical client-server model.We observe that in such services, a significant amount of data returned to the client are emitted by tiers in this architecture, without any handling by other tiers that lie between the emitting tier and the frontal tier. The tiers which precede the emitting tier only forward such data until the frontal tier returns the data to the client. Therefore, network communications used to transfer such data through the multi-tier architecture until the frontal tier are needless and a significant source of CPU waste in the data center.The objective of this thesis is to reduce these needless communications by introducing a shortcut mechanism. In a multi-tier architecture, when a tier emits data that is returned to the client without any other handling by intermediate tiers, a shortcut allows the emitting tier to directly return data to the client without traversing intermediate tiers. The introduction of a shortcut mechanism is equivalent to making the TCP connection with the client remotely accessible from any tier in the architecture.Two problems make it hard to implement such shortcuts. First, emitting tiers have to be coordinated in order to enforce the TCP internal consistency (especially the management of TCP sequence numbers and acknowledgments). Second, shortcuts compromise the internal consistency of applications which have to be modified accordingly. Current solutions require either a modification of the TCP protocol or important modifications in applications.We show that it is possible to distribute a TCP connection as mentioned above without any modification in the TCP protocol. We show that modifications to applications can be minimal and that it is even possible to implement shortcuts without any modification to applications. Finally, we conducted a performance evaluation that shows that shortcuts allow a significant reduction of the CPU load in the data center, without degrading communication performance in terms of latency and throughput.