Web Cache Prefetching as an Aspect: Towards a Dynamic-Weaving Based Solution Marc...

Web Cache Prefetching as an Aspect:Towards a Dynamic-Weaving Based

Solution

Marc Ségura-Devillechaise, Jean-Marc Menaud, Gilles MullerOBASCO Project EMN/INRIA, France

Julia L. LawallDIKU University of Copenhagen, Denmark

AOSD 2003

2

Improving the Web Web cache:• Stores previously-accessed contents preparing for

later potential re-accesses• Advantageous if contents are accessed repeatedlyContent prefetching:• Stores contents that have not yet been accessed

preparing for later potential accesses• Advantageous if contents are accessed eventually

– Relies on the prediction of the access patterns of a Web application

3

Prefetching

• A prefetching policy must anticipate access patterns:– Access patterns are application dependent– A Web cache is shared among many Web applications

• Consequence:– Policies should be deployed on demand in the cache

• Problem:– How to integrate dynamically new prefetching policies

within Web caches?

4

Web Caches

Client Cache Server

Sto

rag

e s

pa

ce

3? 3?3 8

2 45

89 5

3

382

3

345

Storage space

3

394

855

Storage space

343

611

Storage space

3?3?

3

Cache in the neighborhood

Cache in the neighborhood

client request

cooperation request

5

Typical flow of a cooperation request

Accept user request

Request analysis

File lookup

Send User Reply

Local Storage

Accept cooperation request

Replacement policy

Network module

Send cooperation request

Send Internet request

Send cooperation reply

Client Cache

Web cache

Typical flow of a user request

Network

neighborhood

Internet

Server

6

Issues in integrating prefetching in Web caches

• Observation:– Prefetching crosscuts the cache structure– Execution paths: modules are not sufficient

• A “natural” solution: AOP

7

AOP for prefetching in Web Caches Mapping

• Joinpoints

Where, within the cache, a policy is allowed to run

• The pointcut language

When a particular prefetching policy should be triggered

• Advice language

What the prefetching policy should do

• Weaving

Link a prefetching policy to the cache

Specifies where adaptation can take place

Specifies when to adapt

Specifies the behaviour of the adaptation code

Link the adaptation code to the base program

8

AOP for prefetching in Web caches Steps

Base program development

Aspect developmentExecution of base program

Weaving time

Prefetching policy

Web cache development

Prefetching deployment time

Adapted development

Adaptation code

Adaptation code link time

Web cache execution

Adapted execution

time

9

Constraints on the runtime system

• A cache processes every request to a subnet. – It must be efficient.

The aspect code must be efficient.– The cache service must always be available.

The base program must continuously run.• Web caches are written in C.

The aspect system must support the C language.• Prefetching policies should be deployed on demand

in the cache.The aspect system must allow dynamic weaving.

10

• Strong performance requirements– Base program code preparation (hookable) – Aspect and base program

• Translated into C code by our tools• Can be compiled with compiler optimizations

– Weaving is performed with almost no interruption of the application

• Targeted for an audience of C developers– Advice as C code block– All pointcuts can be thought as « did the base program

execute this C construct ?»• Need to be able to perform the extension dynamically

– Weaving performed at runtime

Meeting the constraintsµDyner runtime system

11

Meeting the constraintsµDyner language

• Need to be able to reason on execution paths– Pointcut on nested functions calls «did f() call g()call h()?»

• Need to be able to monitor some global variable– Last element in the pointcut sequence can test whether a

given global variable has been read or written

• In order to extend Web caches– The advice replaces the execution of the last element in the

sequence.• Can trigger execution of the original definition through continue.

12

Ru

nti

me

Bu

ild a

nd

des

ign

tim

e

Lifecycle and tools support

Base

program

development

Aspect

development

Execution

Weaving

13

Base code

maintainer

Pretreated base code

Adaptable cache

µDyner support library

Preprocessing

Compile - link (gcc)

Cache source code C with hookable

Postprocessing

Lifecycle and tools supportR

un

tim

eB

uild

an

d d

esig

n t

ime

Aspect

development

Execution

Weavinghookable int withdraw(float amount,BankAccount * account) {

assert(account!=NULL); account->debit = amount + account->debit ;

return SUCCESS;}

14

Base code maintainer


Adaptable cache


Pretreatment



Postprocessing


C code Pointcut action as functions

Prefetching policies: aspectsources

Compiled aspects Shared library

Compilelink

(gcc)

Preprocessing

Aspect developer

Ru

nti

me

Bu

ild a

nd

des

ign

tim

e

Execution

Weaving

#include "../BaseProgram/BankAccount.h"#define MAX_WITHDRAWAL_AMOUNT 1000.0anAspect:[

int withdraw(float amount, BankAccount * account) :[ {

if(amount >= MAX_WITHDRAWAL_AMOUNT)return BANK_REFUSED;

return continue_withdraw(amount,account);}]

]

15



Adaptable cache


Ru

nti

me

Preprocessing

Bu

ild a

nd

des

ign

tim

e



Postprocessing





Compilelink

(gcc)

Preprocessing

Aspect developer

Cache administratorExecute

µDyner instrumentation

threadCache threads

Cache (host process)

16



Adaptable cache


Ru

nti

me

Preprocessing

Bu

ild a

nd

des

ign

tim

e



Postprocessing





Compilelink

(gcc)

Preprocessing

Aspect developer



threadCache threads

Prefetching policy deployed through

shell commands (weave - deweave)


17

µDyner implementation

• Aspect as shared library

• Base program preparation

• Weave

18

µDyner compiled aspects

Shared native library

19


aspect entry point

advice code

continue pointers

20


aspect entry point

advice code

continue pointers

Points to an address in the base program allowing to execute the last pointcut element

21


aspect entry point

advice code

continue pointers

Invoked each time the base program reaches the last joinpoint element

22


aspect entry point

advice code

continue pointers

Invoked each time the base program reaches the last join point element

Checks pointcut

Calls advice or

continue

23

µDyner base code preparation

• Prepare the base program for analysis– Collect functions and variables addresses– Collect addresses of instructions accessing hookable variable

– Collect addresses of instructions calling functions

• Prepare the base program for alteration– Make potential rewriting sites big enough to contain

a jump instruction

24

µDyner weaver

• Open the aspect shared library

• Overwrite the last joinpoint as a jump to the aspect entry point

• Set the continue pointers in the aspect library

25

int transfer_money {

}

// original function code

int withdraw(float amount, BankAccount * account) {

JUMP +3; NOP; NOP; NOP;

withdraw(100,account)

// code

Host process}

Weaving implementation

26

#include "../BaseProgram/BankAccount.h"#define MAX_WITHDRAWAL_AMOUNT 1000.0anAspect:[

int withdraw(float amount, BankAccount * account) :[

{if(amount >= MAX_WITHDRAWAL_AMOUNT)

return BANK_REFUSED;return continue_withdraw(amount,

account);}]

]


}



JUMP +3; NOP; NO; NOP;


// code

Host process}

if(pointcut != TRUE) continue_withdraw(amount,account); else advice(amount,account);}

int advice(float amount,BankAccount * account) {

if(amount >= MAX_WITHDRAWAL_AMOUNT) return BANK_REFUSED; return continue_withdraw(amount,account);}

int anAspect(float amount, BankAccount * account) {

void * continue_withdraw = withdraw +5;

Aspect

Weaving implementationOverview of a compiled aspect

Generated at compilation of the base program

Generated at compilation of the aspect

Generated at weaving time

continue pointer

aspect entry point

aspect advice

Aspect

rewriting site

27


}



JUMP +3; NOP; NO; NOP;


// code

Host process}Generated at compilation of

the base programGenerated at compilation of

the aspectGenerated at weaving time





} else {

JUMP anAspect

JUMP withdraw+5

}

Hook

if(aspect_loaded ==TRUE)


Aspect

1 load the aspect library – allocate the hook

2 rewriting the base code

3 set aspect_loaded to true


Hook:

28


}



JMP 3; NOP; NOP; NOP;


// code

Host process}





} else {

JUMP anAspect

JUMP withdraw+5

}

Hook



Aspect

1 load the aspect librairy – allocate the hook




JUMP Hook

Hook:




29


}




// code

Host process}





} else {

JUMP anAspect

JUMP withdraw+5

}

Hook



Aspect

1 load the aspect librairy – allocate the hook




JUMP Hook

Hook:




30


}




// code

Host process}





} else {

JUMP anAspect

JUMP withdraw+5

}

Hook



Aspect

Use case – advice execution

JUMP Hook


Hook:



Generated at weaving time Jump

Function returnFunction call

31


}




// code

Host process}





} else {

JUMP unAspect

JUMP withdraw+5

}

Hook



Aspect

Use case – advice execution

JUMP Hook


Hook:





32

Link performance evaluationMethods

Measure the runtime of a given application for a given input

Same measure with the same application with the same input but with woven aspects

The ratio gives a performance evaluation

• Micro evaluation :

• Macro evaluation :

Invoke an empty method

Invoke an empty method with an empty aspect

The ratio gives a performance evaluation

33

Link performance evaluationResults

• Linux Pentium4 1.6 GHz

• Micro evaluation: 2.2 slower

• Macro evaluation: 1.015 slower (Tinyproxy – hit counting aspect)

34

Related WorkDynamic weaving:

– PROSE Popovici A., Gross T., Alonso G. 2002

– JAC Pawlak R., Seinturier L., Duchien 2001

Native code instrumentation:– Dyninst Buck B., Hollingsworth J.K, 2000

AOP for C:– AspectC Y. Coady, G. Kiczales 2001

35

Future Work

• Increase the expressivity of the pointcut language (designing static functions…)

• Remove all static preparation of the base program code

– Implies: suppression of hookable

– Exploit debugging information rather than relying on source code

• Design a set of prefetching policies

• Modify Squid (prepare it for aspectization)

– Build a dynamically adaptable web cache

– Experiment with prefetching policies

36

Conclusion• Prefetching as a crosscutting concern

• A method to link the base program to the aspect

• Almost no service interruption during weaving

• Very fast, once woven

• Prototype: µDyner

– Within the implementation, links aspect and base program through dynamic code rewriting

– Running under GNU/Linux, Pentium

Questions

38

[BUC 00] BUCK B., Hollingsworth J. K., An API for Runtime Code Patching , The International Journal of High Performance Computing Applications, vol. 14, n 4, 2000, p. 317-329.

[CAH 02] Redmond B., Cahill V., Supporting unanticipated dynamic adaptation of application behaviour ECOOP 2002 – Object-Oriented Conference, 16th European Conference, vol. 2374 of Lectures Notes in Computer Sciences page 205-230, Malaga, Spain Juin 2002

[DOU 01] Douence R., Motelet O., Südholt M., A formal definition of crosscuts, Proceedings of the 3rd International Conference on Reflection and Crosscutting Concerns, vol. 2192 de Lecture Notes in Computer Science, Kyoto, Japan, 2001, Springer Verlag, p. 170-186.

[DOU 02] Douence R., Fradet P., Südholt M., A framework for the detection and resolution of aspect interactions , Proceedings of the ACM SIGPLAN/SIGSOFT Conference on Generative Programming and Component Engineering (GPCE’02), 2002, p. 173-188.

[KLE 96] Kleinoder J., Golm M. MetaJava : An efficient run-time meta architecture for Java. International Workshop on Object-Orientation In Operation Systems – IWOOS’96, p. 54-61, Seattle WA, octobre 1996.

[HOL 97] Hollingsworth J. K., Miller B. P., Goncalves M. J. R., Naim O., Xu Z., Zheng L., MDL : A Language and Compiler for Dynamic Program Instrumentation, IEEE PACT, 1997, p. 201-213.

[OLI 98] Oliva A., Buzato L.E. The implementation of Guaranà in Java. Techhnical report IC-98-32, Institute of of computing, University of Campinas, Brésil, septembre 1998.

[PAW 01] Pawlak R., Seinturier L., Duchien L., Florin G., JAC : A Flexible Solution for Aspect-Oriented Programming in Java , Proceedings of Reflection’01, vol. 2192 de Lecture Notes in Computer Science, Springer, 2001, p. 1-24.

[POP 02] Popovici A., Gross T., Alonso G., Dynamic weaving for aspect-oriented programming , Proceedings of the 1st international conference on Aspect-oriented software development, Enschede, The Netherlands, 2002, ACM Press, p. 141-147.

References

39

AOP in a nutshell• Joinpoints

– The instrumentation sites within the base program.

• The pointcut language– A pattern on the execution trace of the base program.

• Action language– What to do when the pointcut matches the execution of

the base program

• Weaving– Link a base program and an aspect– At compile time, at load time, at runtime.

40



Adaptable cache


Ru

nti

me

Pretreatment

Bu

ild a

nd

des

ign

tim

e



Postreatement

Three actors for three steps




Compilelink

(gcc)

Pretreatment

Aspect developer



threadCache threads




#include "../BaseProgram/BankAccount.h"#define MAX_WITHDRAWAL_AMOUNT 1000.0int (*continue_withdraw)(float amount,BankAccount * account)=NULL;int advice(float amount,BankAccount * account){

if(amount >= MAX_WITHDRAWAL_AMOUNT)return BANK_REFUSED;

return continue_withdraw(amount,account);}int anAspect(float amount,BankAccount * account) { return advice(amount,account);}

41



Adaptable cache


Ru

nti

me

Pretreatmentt

Bu

ild a

nd

des

ign

tim

e



Postreatement

Three actors for three steps




Compilelink

(gcc)

Pretreatment

Aspect developer



threadCache threads




int withdraw(float amount,BankAccount * account) __attribute__ ((noinline));int withdraw(float amount,BankAccount * account) { __asm__ __volatile__ ( "jmp assert"); __asm__ __volatile__ ("nop");__asm__ __volatile__ ("nop"); __asm__ __volatile__ ("nop"); assert(account!=NULL); if((account->credit) <= OVERDRAFT_WITH_TRIAL) return BANK_REFUSED; account->debit = amount +account->debit ; return SUCCESS;}

42

By Partial match By Popularity By Lifetime

Accept user request

Parse request

File lookup

Local storage

Accept ICP request

Send Internet request

Send ICP request

Send user reply

Send ICP reply

Replacement policy

InteractionInterface

appropriate

InteractionInterface

inadequate

No interaction

43

Summary

• Difficult to anticipate the interaction of prefetching and the cache– Interaction depends heavily of the policy– Difficult for the cache to offer an API

supporting this interaction

• A generic API might even slow down the cache.

44

Link performance evaluation• Micro evaluation :

ratio

– µDyner (AOP for C – dynamic native code rewriting ) : 2.2– IguanaJ [CAH 02] (MOP for Java – dynamic code rewriting of JIT code) : 24.0– MetaXa [KLE 96] (MOP for Java – modified JVM) : 28.0– Prose [POP 02] (AOP for Java – based on Java debugging API ) : 40.0– Guaranà [OLI 98] (MOP for Java - modified JVM modifiée) : 70.0

• Macro evaluation :ratio

– µDyner (AOP for C) with Tinyproxy : 1.015– Java Aspect Component [PAW 01] (AOP for Java) : 5.000

45

• Joinpoint – an event embeds a partial description of the current

execution context• events are grouped in a single execution trace

• Pointcut– a sequence of events– a monitor inspects the trace

• continuously checks the different pointcuts• triggers the execution of aspect when needed

• The action language – access to the base program through the information

contained in the events

• Weaving– Registration on the monitor

The EAOP model [DOU 01, DOU 02]

46

EAOP for Web Caches?

Well defined semantics but…• Issues with the model

– Not very well suited for concurrent applications– The duplication of execution context is relatively costly.

Events are big.

• Issues with the proposed prototype– Weaving for Java– The set of events are open

Everybody can use his own eventsLack of a clear distinction between action and pointcut

47


}




// code

Host process}





} else {

JMP anAspect

JUMP withdraw+5

}

Hook



Aspect

Use case – pointcut not verified

JUMP Hook


Hook:





48


}




// code

Host process}





} else {

JMP anAspect

JUMP withdraw+5

}

Hook



Aspect

Use case – aspect not activated

JUMP Hook


Hook:





Date post:	29-Dec-2015
Category:	Documents
Upload:	aubrey-watkins
View:	216 times
Download:	1 times

Web Cache Prefetching as an Aspect: Towards a Dynamic-Weaving Based Solution Marc...

Documents