mDyner : un noyeau efficace pour le tissage dynamique d'aspects sur processus natif en

cours d'ex₫cution.

Exp₫rimentation d'EAOP sur une application concr₩te diffus₫e et concurrente

1/49 ;-)

Probl₫matique G₫n₫rale

Adaptation d'application (changer des fonctionnalit₫s) Application dont la continuit₫ du service est une

contrainte Application aux performances critiques

Domaine Applicatif

Cache Web Le prix d'un cache vari de mani₩re exponentiel par

rapport aux nombres de requetes trait₫s à la seconde -> Performances importantes Code Natif (C)

Les donn₫es sont de + en + dynamique R₫aliser une partie des traitement au niveau du cache

Cache et Composant

Les composants suppos₫s “t₫l₫chargeables” sont tous tr₩s diff₫rents Pas possible d'avoir une Interface commune

(voir echec d'ActiveCache et Plugxy)

On a montr₫ que sur un certain type de composant l'insertion de la fonctionalit₫ crosscutait le cache

(Compsants t₫l₫chargeables en vues : Les services Web)

Anticipation des acc₩s et Cache

Exemple simple Anticipation des acces dans cache web coop₫ratif

Pas anticiper les acces des voisins. Notion de trace du programme

Vers l'AOP Contraintes :

T₫l₫charger à la vol₫e des strat₫gies d'anticipation des acc₩s

Ne pas arr₨ter le cache lors de l'adaptation Garantir une greffe coh₫rente et sure

AOP en 4 mots

Points de jonction Langage de Coupe (enchaînement de fonctions) Langage d'action Tissage

BuildTime / LoadTime / RunTime

EAOP (en un peu plus...) Point de jonction g₫n₫r₫ un ₫venement

Cet ₫venement est ins₫r₫ dans un trace L'₫venement propage une partie du contexte

d'ex₫cution

Un moniteur est charg₫ de rep₫rer un s₫quence d'₫venement La s₫quence est d₫finie par le langage de coupe L'aspect est activ₫ si le motif est trouv₫

EAOP par rapport à notre cadre applicatif

Intrins₩quement non concurrent une trace d'ex₫cution) Le m₫canisme de moniteur central et mal adapt₫

(goulot)

Taille des ₫v₫nements importantes en fonction de la taille du contexte a dupliquer

Langage de coupe non d₫di₫

Notre solution Mod₩le intrinsequement multi-thread₫ Langage de coupe clairement identifi₫

Parser / compilateur Volontairement le plus simple possible

Tissage à l'ex₫cution Sur code Binaire Sans arr₨t du processus hôte

On ne g₩le pas le processus via ptrace

Les Acteurs

Le concepteur du logiciel de base Annotation de son source

Le concepteur de l'aspect Ecriture de la coupe Ecriture de l'insert

L'administrateur du logiciel en cours d'ex₫cution Tissage et de-tissage des aspects.

Exemple d'un pt de vue langage 0: Test: [ 1: int pov(int a,int b) : [2: int foo(int a,int b) :[3: { a=a+2;4: if (a>10) continue_foo(a,b);5: return -1;6: }7: int bar(int a, int b):[8: { printf(«entr₫e coupe bar»);9: continue_bar(a,b);10: debug(1);11: }12: ]13: ]14: int bar(int a,int b) :[15: {int temp; 16: temp=continue_bar(a,b);17: debug(2);return temp;}18: ]19:]]

Hookable int var_glob;

Hookable int bar(int a,int b){ a=b; printf(«bar %d\n», a); return a;}

Hookable int foo(int a,int b) { printf(«foo\n»); bar(a,b+1); return 1;}

int pov(int a,int b) {foo(a,b);bar(2,3);return1;}

void main(){pov(1,2);}

Établissement des LiensSch₫mas simple

La trhread est rerout₫ donc dans l'aspect nous avons tout le contexte d'ex₫cution du programme

Ex₫cution de l'aspect

Saut

Retour de fonction

prevent_propagation_pointcut()){

return

int handle_request(char* req) {

}

// original function code

int relay_request(struct * request) {

JMP 3 ; NOP ; NOP ; NOP ;

G₫n₫r₫ à la compilation du programme de baseG₫n₫r₫ à la compilation de laspect

G₫n₫r₫ au tissage

Appel de fonction

Aspect.so

L₫gende

= relay_request+5 ; // function pointer

/* check wether relay_ request

handle_request are on the stack */

}

if (is_prefetching_request(request))

return NO_NEIGHBOR_HAS_FILE;

else return continue_relay_request(request);

}

JUMP crochet

int prevent_propagation(struct * request) {

int prevent_propagation_pointcut() {

relay_request(request)

// original function code

Processus hôte}

save registers

restore registers

} else {JMP prevent_propagation

JUMP relay_request+5irestore registers}

Crochet

if(aspect_loaded &&

int continue_relay_request(struct * request)

Deux niveaux de D₫-tissage :TemporairePermanent

Architecture g₫n₫rale Temps de conception

Pr₫paration du binaire Compilation de la coupe et de l'aspect

Temps d'ex₫cution Tissage et d₫tissage de l'aspect

Instrumentation du code Garder la coh₫rence lors de l'instrumentation de plusieurs

points de jonction

Activation des aspects

Chaîne de compilation - ex₫cution

D₫veloppeur du

code de base

Administrateur du support dex₫cution

D₫veloppeur de

laspect

extensionsANSI C with GNU 89

(thread en attente sur socket)

Code de base pr₫trait₫

Binaire ELF x86 Linux

Cache adaptable Librairie partag₫e (.so) ELF x86

Librairie support µDynerSupport dinstrumentation

Source C pr₫tait₫e

Ex₫cute

Ex₫

cuti

on

Pr₫traitement

Con

cep

tion

et

com

pila

tion

Thread dinstrumenta-tion µDyner

Processus du cache (processus hôte)

Thread du cache

Advice et pointcut fonctions

Source de politique de pr₫chargement

Collections daspects en µDyner

Aspects compil₫s

Compile - lie (gcc)

language C annotat₫ with hookable

Source du cache: code de base

Posttraitement

Compilelie

(gcc)

Pr₫traitement

(weave - deweave)

Politique de pr₫chargement d₫ploy₫e par

commandes shell

Performance du Tisseur Environnement d'Évaluation

Mat₫riel : P4 1.6 GHz RAM: 256 Mo

Logiciel : TinyProxy Gcc 3.2.1 O2 kernel linux 2.4.17

Rendre hookable toutes les fonctions et toutes les variables : ~ 3%

Tissage dun aspect vide Tissage effectu₫ en ~ 266 µs

Dont chargement du code de l'aspect (temps minimal) : ~ 199 µs Interruption de lapplication pour linsertion dun crochet

Au pire : 16.5 µs (boucle dattente dactive pour lacc₩s aux variables)

D₫lai de retransmission TCP : 250 ms soit + de 14 000 crochets

Performance du lien Rappels :

Un syst₩me à aspect permet dattraper un appel de m₫thode et dappeler la m₫thode attrap₫e depuis laspect.

Un syst₩me r₫flexif permet dattraper un appel de m₫thode et dappeler la m₫thode attrap₫e depuis le meta niveau.

Dans le cas dune m₫thode retournant imm₫diatement, le ratio du temps n₫cessaire pour effectuer cette tâche sur le temps dun appel direct à cette m₫thode est un bon indicateur de performance.

Code :

f(){}

g(){

f();}

f :continue_f();

K();

Coupe

Performance du lien sur l'appel de fonction

Quelques ratios sur un appel vide : µDyner (AOP pour C r₫₫criture dynamique du code) : 2.2 IguanaJ (MOP pour Java r₫₫criture dynamique du code JIT₫) : 24 MetaXa (MOP pour Java utilisation dune VM modifi₫e) : 28 Prose (AOP pour Java utilisation des API de d₫verminage) : 40 Guaranà (MOP pour Java utilisation dune VM modifi₫e) : 70

Quelques ratios sur un appel dans tinyproxy :

Surcoût : 1.015

Variations moyenne des mesures : ~ 20 %

Travaux connexes Dyninst

Instrumentation dynamique dapplication native Bas₫e sur les API de d₫verminage UNIX (ptrace) donc coûteux Reloge le code instrument₫e

Probl₩me si lintruction relog₫e est la cible dun saut Utilisation dheuristiques pour r₫soudre ce probl₩me

Kerninst Instrumentation dynamique du noyau de lOS R₫ecriture du code Solaris dispose dun espace m₫moire fixe pour lOS. Les fonctions de lOS sont r₫parties

dans cette espace (contrainte dalignement). Kerninst utilise ces trous pour allouer des sauts jusquà pouvoir atteindre un trou suffisamment grand pour contenir un crochet.

Les fonctions de lespace utilisateur nont pas ces contraintes dalignement. Il est rare quil y ait des « trous » non utilis₫s dans le segment de code.

Java Aspect Component Syst₩me à tissage dynamique daspect pour Java R₫ecrit le bytecode au chargement Pour chaque objet de base introduit une chaîne dobjet dinterposition Lindirection introduit par la chaîne dobjet permet le tissage sur nimporte quel objet. Tr₩s coûteux : ralentit une application dun facteur 5 environ

Etat des travaux en cours Principalement interess₫ aux technologies pour

l'₫tablissement du lien entre le code de base et l'aspect. D₫finir un sous-ensemble de crochets Instrumentation l₫g₩re et sans arret du processus

Sans passer par le d₫vermineur

Activation bas₫e sur des m₫canismes de bas niveau (r₫ification de la pile, des acc₩s aux variables et aux

fonctions) Le langage de coupe est d₫duit de ces m₫canismes de base

Comp. Orient₫ ex₫cution (pas source) Evenements : point d’ex₫cution avec la totalit₫

du contexte d’ex₫cution Coupe : enchainement de certain type

d’evenement -> acc₩s variable/fonction Plusieurs aspects sur une meme coupe sont

ex₫cut₫s sequentielement pas de // et Seq On peut avoir un ₫tat par aspect (comme EAOP)

Conclusion Guid₫ par EAOP, principalement interess₫ aux

technologies pour l'₫tablissement du lien entre le code de base et l'aspect.

On fait le lien au niveau mod₩le par la trace et au niveau impl₫mentation par r₫₫criture de code.

Travail autour d'un langage de coupe plus ₫volu₫ Supression du hookable ?