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

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

3. 2 2 8 8 45 45 5 3 3 89 3 3 3 3 3? 3? Un cache Web Espace de stockage 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

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

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

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

11. Principe 0804837c <payinterest>: 804837c: 55 push %ebp 804837d: 89 e5 mov %esp,%ebp 804837f: 83 ec 18 sub $0x18,%esp 8048382: 8b 45 08 mov 0x8(%ebp),%eax 8048385: 8b 55 0c mov 0xc(%ebp),%edx 8048388: 89 45 f8 mov %eax,0xfffffff8(%ebp) 804838b: 89 55 fc mov %edx,0xfffffffc(%ebp) 804838e: e8 e3 ff ff ff call 8048376 <balance> 8048393: 50 push %eax 8048394: db 04 24 fildl (%esp,1) 8048397: 8d 64 24 04 lea 0x4(%esp,1),%esp 804839b: dd 45 f8 fldl 0xfffffff8(%ebp) 804839e: dd 05 18 85 04 08 fldl 0x8048518 80483a4: de f9 fdivrp %st,%st(1) 80483a6: de c9 fmulp %st,%st(1) 80483a8: d9 7d f2 fnstcw 0xfffffff2(%ebp) 80483ab: 66 8b 45 f2 mov 0xfffffff2(%ebp),%ax 80483af: b4 0c mov $0xc,%ah 80483b1: 66 89 45 f0 mov %ax,0xfffffff0(%ebp) 80483b5: d9 6d f0 fldcw 0xfffffff0(%ebp) 80483b8: db 5d f4 fistpl 0xfffffff4(%ebp) 80483bb: d9 6d f2 fldcw 0xfffffff2(%ebp) 80483be: 83 ec 0c sub $0xc,%esp 80483c1: ff 75 f4 pushl 0xfffffff4(%ebp) 80483c4: e8 05 00 00 00 call 80483ce <deposit> 80483c9: 83 c4 10 add $0x10,%esp 80483cc: c9 leave 80483cd: c3 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. void * continue_deposit = deposit; int unAspect(float amount) { if(aspect_loaded ==TRUE) if(pointcut != TRUE) continue_deposit(amount,account); else advice(amount,account); } int deposit(int amount) { JMP unAspect // 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 Retour de fonction } Processus hôte Crochet Généré à la compilation de l’aspect Saut Légende Généré au tissage Tissage : 1 chargement de l’aspect – allocation du crochet 2 réécriture du code de base 3 mettre aspect_loaded à vrai

13. Comment lier l’aspect au programme de base ? void * continue_deposit = deposit; int unAspect(float amount) { if(aspect_loaded ==TRUE) if(pointcut != TRUE) continue_deposit(amount,account); else advice(amount,account); } int deposit(int amount) { JMP unAspect // 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 Retour de fonction } Processus hôte Crochet Généré à la compilation de l’aspect Saut Légende Généré au tissage

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

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

16. Evaluation • Conception • 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