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

Marc Segura-DevillechaiseJean-Marc MenaudJulia LawallGilles Muller

Ecole des Mines de NantesOBASCO, EMN/INRIA

Datalogisk InstitutUniversity of Copenhagen

* * *

* *

**

*

CFSE’3

Extensibilité Dynamique dans les Caches Web

Plan : Problématique de l’extensibilité Les connecteurs comme des aspects Expérimentation et évaluation dans Squid Conclusion

Un cache Web

Client Cache Serveur

Esp

ace

de

sto

ckag

e

3? 3?3 8

2 45

89 5

3

382

3

345

Espace de stockage

3

Contraintes

Efficacité

Continuité du service

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

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

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é

Extensibilité Dynamique dans les Caches Web

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

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é

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:]]

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;}

La Conception du connecteur

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

Principe0804837c <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;}

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

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

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

Extensibilité Dynamique dans les Caches Web

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

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 %

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

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