Extensibilité Dynamique dans les Caches Web : une Approche par Aspects

Présentation au sujet: "Extensibilité Dynamique dans les Caches Web : une Approche par Aspects"— Transcription de la présentation:

1 Extensibilité Dynamique dans les Caches Web : une Approche par Aspects
CFSE’3 Marc Segura-Devillechaise Jean-Marc Menaud Julia Lawall Gilles Muller * * * * * * * * Ecole des Mines de Nantes OBASCO, EMN/INRIA Datalogisk Institut University of Copenhagen

2 Extensibilité Dynamique dans les Caches Web
Plan : Problématique de l’extensibilité Les connecteurs comme des aspects Expérimentation et évaluation dans Squid Conclusion Au depart on a voulu integrer une alorithmique : le prechargement dans une application existante: les caches web. Assez rapidement il est apparu que l’algp optimale dependait du contexte d execution et que chaque algo interagissait Differament avec l appli d origine. Pour choisir l alpgo on avait besoin d introspecter la pile. Ca nous a conduit aux aspects.

3 Un cache Web Contraintes Continuité du service Efficacité Client Cache
3? 3? 3 8 89 5 Espace de stockage 8 45 3 3 3 3 2 2 45 3 Espace de stockage Client Cache Serveur Contraintes Continuité du service Efficacité

4 Contexte de l’étude Limitation : un cache ne sait traiter qu’un certain nombre de types de documents Adapter les fonctionnalités du cache en fonction des flux d’information à traiter Objectif de l’adaptation : Améliorer les performances Adapter pourquoi ? Squid : document html static Flux vidéo, Documents sécurisés, Données dynamiques,… Objectif adaptation Préserver la bande passante entre cache et fournisseur internet Diminuer les temps de réponse pour les clients du cache Diminuer la charge des serveurs web Idée de base de l’adaptation avoir une interface pour charger des modules

5 Notre problématique La fonctionnalité est dépendante du flux en cours
L’ensemble des fonctionnalités est indénombrable Tension entre développement des fonctionnalités et développement du cache Impossible d’anticiper toutes les fonctionnalités au moment de la conception du cache Comment Concevoir/Déployer/Exécuter un cache adapté (intégrant la fonctionnalité) au flux de données en cours Parler de cache web dynamiquement extensible Dépendante du flux : dynamique et unique Interface générique pas bonne : certaines fonctionnalités sont transverses et nécessites une interaction fine : Ex de l’anticipation des accès

6 Une Solution Puisque l’on ne peut pas anticiper à la conception du cache l’interface nécessaire : La produire dynamiquement au moment du déploiement de la fonctionnalité

7 Extensibilité Dynamique dans les Caches Web
Plan : Problématique générale Les connecteurs comme des aspects Expérimentation et évaluation dans Squid Conclusion Au depart on a voulu integrer une alorithmique : le prechargement dans une application existante: les caches web. Assez rapidement il est apparu que l’algp optimale dependait du contexte d execution et que chaque algo interagissait Differament avec l appli d origine. Pour choisir l alpgo on avait besoin d introspecter la pile. Ca nous a conduit aux aspects.

8 Notre Approche Développement indépendant du cache
Développer la fonctionnalité de manière pseudo-indépendante Offrir un module et une interface Développer un connecteur pour établir une liaison entre le cache et l’interface de la fonctionnalité. Concentrer tous les aspects transversaux et spécifiques au logiciel de base dans ce même et unique module. Architecture générale Connecteur + module = Fonctionnalité Connecteur est pour une fonctionnalité unique Dire pourquoi ne pas écrire la fonctionnalité comme un aspect ? (12 méga de sources) possède sa propre gestion des descripteurs, possède son propre allocateur mémoire, multithreadé … Avec AOP, à chaque nouvelle/ancienne version de squid on doit vérifier que son aspect est encore valide Il existe actuellement une multitude de version Première version 96, Actuellement une version par mois Connecteur Fonctionnalité

9 La Conception du connecteur
int bal; CreateBankAccount(int amt) { bal=amt; } int balance() return bal; int payinterest(double rate) int temp; temp = balance()*(rate/100); return deposit(temp); int deposit(int amt) return bal = bal + amt; void withdraw(int amt) bal = bal - amt; 0: #include “Tax.h” 1: 2: require void withdraw(int); 3: 4: Test: [ 5: int main() : [ 6: int payinterest(double b) :[ 7: int deposit(int a):[ 8: { if (a>10) 9: continue_deposit(a); 10: else withdraw(a); 11: } 12: ] 13: ] 14: int balance(int a) :[ 15: {int temp; 16: temp=continue_balance(a,b); 17: return temp;} 18: ] 19:]]

10 Déploiement des fonctionnalités
Intégration du connecteur et de sa fonctionnalité sur source Arrêt de squid 30s Temps de compil. de Squid sur un P4 2,4 Ghz : 1 m 30s Notre solution : Intégration dynamique sans arrêt du processus d’un ou de plusieurs connecteurs/modules sur code natif Comment intégrer en simplifiant un connecteur c’est dire si f(a,b,c) est exécuter alors appeler g(a,b) du module x Avec les contraintes de l’application efficace et continuité de service Arret de squid mini 30s pour le timeout socket Patch sur code natif Les processus entre eux sont forcément indépendants (aucun partage de mémoire, de disque etc …) Un cache Web n’a des sens que si il y a un effet d’agrégation Patch intéligent dynamqiue et chirurgical

11 Principe 80483c4: e8 05 00 00 00 call 80483ce <deposit>
c <payinterest>: 804837c: push %ebp 804837d: e mov %esp,%ebp 804837f: ec sub $0x18,%esp : b mov 0x8(%ebp),%eax : b 55 0c mov 0xc(%ebp),%edx : f mov %eax,0xfffffff8(%ebp) 804838b: fc mov %edx,0xfffffffc(%ebp) 804838e: e8 e3 ff ff ff call <balance> : push %eax : db fildl (%esp,1) : d lea 0x4(%esp,1),%esp 804839b: dd 45 f fldl 0xfffffff8(%ebp) 804839e: dd fldl 0x 80483a4: de f fdivrp %st,%st(1) 80483a6: de c fmulp %st,%st(1) 80483a8: d9 7d f fnstcw 0xfffffff2(%ebp) 80483ab: b 45 f mov 0xfffffff2(%ebp),%ax 80483af: b4 0c mov $0xc,%ah 80483b1: f mov %ax,0xfffffff0(%ebp) 80483b5: d9 6d f fldcw 0xfffffff0(%ebp) 80483b8: db 5d f fistpl 0xfffffff4(%ebp) 80483bb: d9 6d f fldcw 0xfffffff2(%ebp) 80483be: ec 0c sub $0xc,%esp 80483c1: ff 75 f pushl 0xfffffff4(%ebp) 80483c4: e call 80483ce <deposit> 80483c9: c add $0x10,%esp 80483cc: c leave 80483cd: c ret int balance() { return bal; } int payinterest(double rate) int temp; temp = balance()*(rate/100); return deposit(temp); int deposit(int amt) return bal = bal + amt; void withdraw(int amt) bal = bal - amt;

12 Tissage : 1 chargement de l’aspect – allocation du crochet
2 réécriture du code de base 3 mettre aspect_loaded à vrai Saut Retour de fonction int payinterest { } // original function code int deposit(int amount) { Généré à la compilation de l’aspect Généré au tissage Appel de fonction Légende if(pointcut != TRUE) continue_deposit(amount,account); else advice(amount,account); int advice(float amount) { CODE return continue_deposit(amount); int unAspect(float amount) { deposit(100,account) // code Processus hôte } else { JMP unAspect JUMP deposit Crochet if(aspect_loaded ==TRUE) void * continue_deposit = deposit; Aspect Deux niveaux de tissage/détissage L’aspect s’exécute dans le contexte d’exécution du programme de base.

13 Comment lier l’aspect au programme de base ?
Saut Retour de fonction int payinterest { } // original function code int deposit(int amount) { Généré à la compilation de l’aspect Généré au tissage Appel de fonction Légende if(pointcut != TRUE) continue_deposit(amount,account); else advice(amount,account); int advice(float amount) { CODE return continue_deposit(amount); int unAspect(float amount) { deposit(100,account) // code Processus hôte } else { JMP unAspect JUMP deposit Crochet if(aspect_loaded ==TRUE) void * continue_deposit = deposit; Aspect Deux niveaux de tissage/détissage L’aspect s’exécute dans le contexte d’exécution du programme de base.

14 Exécution des fonctionnalités
Tissage et détissage Sans interruption de service Efficacité de l’intégration Sécurité de l’intégration Serveur de confiance Maîtriser la cohabitation des fonctionnalités Vérification d’exclusivité lors de la création d’interface Sur la sécurté travail encours : Isolation de la fonctionnalité

15 Extensibilité Dynamique dans les Caches Web
Plan : Problématique générale Les connecteurs comme des aspects Expérimentation et évaluation dans Squid Conclusion Au depart on a voulu integrer une alorithmique : le prechargement dans une application existante: les caches web. Assez rapidement il est apparu que l’algp optimale dependait du contexte d execution et que chaque algo interagissait Differament avec l appli d origine. Pour choisir l alpgo on avait besoin d introspecter la pile. Ca nous a conduit aux aspects.

16 Evaluation Conception Déploiement Exécution
Rapport de 1 à 7 pour le développement d’une fonctionnalité Déploiement Tissage inférieur à 30 µs (sur Celeron 600) Exécution Performance du lien 2,2 Performance de l’intégration : surcoût de 1,2 %

17 Conclusion Le connecteur comme glue entre fonctionnalité et logiciel de base. Architecture pour le développement d’aspect en C et pour leurs déploiements sur un code natif en cours d’exécution. Tisseur efficace et travaillant sur des binaires non préparés Première expérimentation des outils sur Squid et l’anticipation des accès

18 Travaux futurs Autres expérimentation en cours :
Création dynamique d’interface RPC (passage à SOAP …) Conception d’aspect sur le Tisseur lui même (Pb de bootstrap) Sécurité du code téléchargé Support du langage C++ Extraction d’interfaces dans un modèle de composant orienté système Autre vision : Système efficace et chirurgical de patch dynamique. Travail autour d'un langage de coupe plus évolué