Extensibilit Dynamique dans les Caches Web une Approche

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

Extensibilité Dynamique dans les Caches Web Plan : n n Problématique de l’extensibilité Les connecteurs comme des aspects Expérimentation et évaluation dans Squid Conclusion

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

Contexte de l’étude n n n 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

Notre problématique n n n 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 n n 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

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

Extensibilité Dynamique dans les Caches Web Plan : n Problématique générale n Les connecteurs comme des aspects n n Expérimentation et évaluation dans Squid Conclusion

Notre Approche n n Développement indépendant du cache Développer la fonctionnalité de manière pseudo-indépendante n n Offrir un module et une interface Développer un connecteur pour établir une liaison entre le cache et l’interface de la fonctionnalité. n Concentrer tous les aspects transversaux et spécifiques au logiciel de base dans ce même et unique module. Connecteur Fonctionnalité

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

Déploiement des fonctionnalités n Intégration du connecteur et de sa fonctionnalité sur source n n n Arrêt de squid 30 s Temps de compil. de Squid sur un P 4 2, 4 Ghz : 1 m 30 s Notre solution : n Intégration dynamique sans arrêt du processus d’un ou de plusieurs connecteurs/modules sur code natif

Principe 0804837 c <payinterest>: 804837 c: 55 int balance() 804837 d: 89 e 5 { 804837 f: 83 ec 18 return bal; 8048382: 8 b 45 08 8048385: 8 b 55 0 c } 8048388: 89 45 f 8 804838 b: 89 55 fc 804838 e: e 8 e 3 ff int payinterest(double rate) 8048393: 50 { 8048394: db 04 24 int temp; 8048397: 8 d 64 24 804839 b: dd 45 f 8 temp = balance()*(rate/100); 804839 e: dd 05 18 return deposit(temp); 80483 a 4: de f 9 } 80483 a 6: de c 9 80483 a 8: d 9 7 d f 2 int deposit(int amt) 80483 ab: 66 8 b 45 80483 af: b 4 0 c { 80483 b 1: 66 89 45 return bal = bal + amt; 80483 b 5: d 9 6 d f 0 } 80483 b 8: db 5 d f 4 80483 bb: d 9 6 d f 2 void withdraw(int amt) 80483 be: 83 ec 0 c { 80483 c 1: ff 75 f 4 bal = bal - amt; } ff ff 04 85 04 08 f 2 f 0 push mov sub mov mov call push fildl lea fldl fdivrp fmulp fnstcw mov mov fldcw fistpl fldcw sub pushl %ebp %esp, %ebp $0 x 18, %esp 0 x 8(%ebp), %eax 0 xc(%ebp), %edx %eax, 0 xfffffff 8(%ebp) %edx, 0 xfffffffc(%ebp) 8048376 <balance> %eax (%esp, 1) 0 x 4(%esp, 1), %esp 0 xfffffff 8(%ebp) 0 x 8048518 %st, %st(1) 0 xfffffff 2(%ebp), %ax $0 xc, %ah %ax, 0 xfffffff 0(%ebp) 0 xfffffff 4(%ebp) 0 xfffffff 2(%ebp) $0 xc, %esp 0 xfffffff 4(%ebp) 80483 c 4: e 8 05 00 00 00 call 80483 ce <deposit> 80483 c 9: 80483 cc: 80483 cd: 83 c 4 10 c 9 c 3 add leave ret $0 x 10, %esp

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

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

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

Extensibilité Dynamique dans les Caches Web Plan : n Problématique générale Les connecteurs comme des aspects n Expérimentation et évaluation dans Squid n Conclusion n

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

Conclusion n n 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

Travaux futurs n Autres expérimentation en cours : n n Création dynamique d’interface RPC (passage à SOAP …) Conception d’aspect sur le Tisseur lui même (Pb de bootstrap) n Sécurité du code téléchargé n Support du langage C++ n Extraction d’interfaces dans un modèle de composant orienté système