continuation join points
DESCRIPTION
Continuation Join Points. Yusuke Endoh, Hidehiko Masuhara, Akinori Yonezawa (University of Tokyo). Login. id = readLine();. CUI Aspect. Main. pointcut input(): call(readLine()). cmd = readLine();. logging return value. Background: Aspects are reusable in AspectJ (1). - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/1.jpg)
1
Continuation Join Points
Yusuke Endoh, Hidehiko Masuhara, Akinori Yonezawa
(University of Tokyo)
![Page 2: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/2.jpg)
2
cmd = readLine();
Main
id = readLine();
Login
Background: Aspects are reusable in AspectJ (1)
Example: A generic logging aspect can log user inputs in a CUI program by defining a pointcut
loggingreturn value
Generic LoggingAspect
pointcut input():call(readLine())
CUI Aspect
![Page 3: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/3.jpg)
3
Background: Aspects are reusable in AspectJ (2)
Example: A generic logging aspect can also log environment variable by also defining a pointcut
Generic LoggingAspect
pointcut input():call(readLine())
CUI Aspect
pointcut input():call(getEnv())
Env Aspect
Q. Now, if we want to log environment variable (getEnv) …?
A. Merely concretize an aspect additionally
Aspect reusability
![Page 4: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/4.jpg)
4
Example: A generic logging aspect can NOT log inputs in a GUI program by defining a
pointcut
Problem: Aspects are not as reusable as expected
void onSubmit(id){ … }
Login
void onSubmit(cmd){ … }
Main
loggingarguments
Generic LoggingAspect
pointcut Input():call(onSubmit(Str))
GUI Aspect
![Page 5: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/5.jpg)
5
Why can’t we reuse the aspect?
Generic LoggingAspectabstract pointcut: input();
after() returning(String s) : input() { Log.add(s); }
Logging Aspect (inner)
unable to change to before
Timing of advice execution depends on both advice modifiers and pointcuts
![Page 6: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/6.jpg)
6
Workaround in AspectJ is awkward: overview
Required changes for more reusable aspect: generic aspect (e.g., logging)
two abstract pointcuts, two advice decls. and an auxiliary method
concrete aspects two concrete pointcuts even if they are not needed
![Page 7: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/7.jpg)
7
Workaround in AspectJ is awkward:how to define generic aspect
1. define two pointcutsfor before and after
2. define two advice decls.for before and after
3. define auxiliary method
abstract pointcut: inputAfter();abstract pointcut: inputBefore();
after() returning(String s) : inputAfter() { log(s); }before(String s) : inputBefore() && args(s) { log(s); }
void log(String s) { Log.add(s); }
Simple Logging Aspect
![Page 8: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/8.jpg)
8
Workaround in AspectJ is awkward:how to define concrete aspects
UpdatedLogging Aspect
pointcut inputAfter() : call(readLine());pointcut inputBefore() : never();
CUI Aspect
pointcut inputAfter() : never();pointcut inputBefore() : call(onSubmit(Str));
GUI Aspect
always define both pointcuts even if not needed
![Page 9: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/9.jpg)
9
Summary: Aspect Reusability Problem
Aspects are not reusablewhen advice modifiers need to be changed CUI/GUI is not an artificial example
stand-alone application framework blocking I/O non-blocking I/O
Workaround is awkward
Cause: Timing of advice execution depends on both advice modifiers and pointcuts
![Page 10: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/10.jpg)
10
Contributions
The point-in-time join point model PitJ: an experimental AOP language based o
n the model completed the language design
Pit: simplified version of PitJ based on -calculus a working interpreter formalized in CPS
![Page 11: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/11.jpg)
11
Point-in-Time Join Point Model
readLine();
readLine(){
}
readLine();
readLine(){
}
call join pointreception join point
Define ends of actions as different join points from beginnings of actionsregion-in-time model
(traditional)
point-in-time model(proposed)
AspectJ, AspectWerkz, JBoss AOP, …
call join point
![Page 12: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/12.jpg)
12
PitJ: An Experimental AOP Language Based on Point-in-Time Model is more reusable than AspectJ because of
point-in-time model is as expressive as AspectJ
base language : Java (AspectJ-like)
![Page 13: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/13.jpg)
13
PitJ: Pointcuts
call(method): a call to method reception(method): a return from method failure(method): an exceptional return from method i.e., exception is thrown by method
args(var): binding join point’s value to var call join point’s value : argument reception join point’s value : return value failure join point’s value : exception object
![Page 14: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/14.jpg)
14
PitJ: Examples of Advice (1)
No need for advice modifiers advice(Str s): call(m) && args(s) { … }
advices at call join point of the method m in AspectJ: before(): call(m) { … }
advice(Str s): reception(m) && args(s) { … } in AspectJ: after() returning(Str s): call(m) { … }
advice(Obj e): failure(m) && args(e) { … } in AspectJ: after() throwing(Obj e): call(m) { … }
![Page 15: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/15.jpg)
15
PitJ: Examples of Advice (2)
before and after advice can be defined in one advice declaration advice(Str s):
(call(onSubmit(Str)) || reception(readLine())) && args(s) { … } runs at both call join point of onSubmit and a reception j
oin point of readLine
in AspectJ, corresponding to a pair of advice decls. before(String s): call(onSubmit(Str)) && args(s) { … } after() returning(String s): call(readLine()) { … }
![Page 16: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/16.jpg)
16
Reusable Logging Aspect in PitJ
abstract pointcut input();advice(String s): input() && args(s) { Log.add(s); }
Generic Logging Aspect
pointcut input():
reception(readLine())
CUI Aspect
pointcut input():
call(onSubmit(Str))
GUI Aspect
![Page 17: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/17.jpg)
17
PitJ: Around-like Advice
usages of around advice in AspectJ1. replace the parameters to a join point with new ones
2. replace the return value to the caller of a join point
3. go back to the caller without executing a join point
4. execute a join point more than once In PitJ, these are realized by:
1, 2 return in advice body 3 new construct: skip 4 special function: proceed
![Page 18: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/18.jpg)
18
return in advice body (1)
replaces join point’s value
Example: at call join point advice(Str s): call(m) && args(s) { return sanitize(s); }
replaces the argument of m with the sanitized one
in AspectJ: around(Str s): call(m) && args(s)
{ return proceed(sanitize(s)); }
![Page 19: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/19.jpg)
19
return in advice body (2)
Example: at reception join point advice(Str s): reception(m) && args(s)
{ return sanitize(s); } replaces the return value of m with the sanitized one
in AspectJ: around(Str s): call(m) && args(s)
{ return sanitize(proceed(s)); }
![Page 20: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/20.jpg)
20
new construct: skip
skip is evaluated in a call join point: skips subsequent advice decls. and the call itself
i.e., jumps to the corresponding reception join point in a reception or failure join point:
skips subsequent advice decls.
Example: advice(): call(readLine()) { skip “dummy”; }
makes readLine always return “dummy”
in AspectJ: String around(): call(readLine()) { return “dummy”; }
![Page 21: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/21.jpg)
21
special function: proceed
proceed is evaluated in a call join point: executes the action until the corresponding reception join point
in a reception or failure join point: no effect
Example: advice(): call(readLine) { proceed(); }
let readLine skip every other line advice(): call(readLine) { skip(proceed() + proceed()); }
let readLine return a concatenation of two lines advice(): call(readLine) { skip(proceed()); }
no effect
![Page 22: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/22.jpg)
22
Summary: PitJ
No need for advice modifiers Advice decls. are more reusable than AspectJ’s
due to the point-in-time model PitJ is as expressive as AspectJ’s advice mecha
nism before : call join points after : reception or failure join point around-like : skip and proceed
![Page 23: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/23.jpg)
23
Formalization of Point-in-Time Model
target: Pit simplified version of PitJ base language: untyped -calculus
approach: denotational semantics in continuation-passing st
yle key idea: denote join points as applications to c
ontinuation
![Page 24: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/24.jpg)
24
Semantic Equations: Advice
A : advice list Event Ctn Ctn Event : kind of join point Ctn : continuation
A [A] : return continuation that: selects applicable advice decls. from A (list of advi
ce) executes them, and executes (continuation)
: kind of join point
![Page 25: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/25.jpg)
25
Semantic Equations: Expression
E : expression Ctn Ans Ctn : continuation Ans : answer
E [E] : evaluates E and executes E : expression : continuation
![Page 26: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/26.jpg)
26
Sample Program in Pit
advice call(f) && args(x) x+1advice reception(f) && args(x) x+2 let f x = x*2 in f 2
8
f 2 let f x = x*223 6
8
![Page 27: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/27.jpg)
27
E [E0 E1] = E [E0] (f. E [E1] (v. f v))
Semantics of Function Call (abridged)
semantics of -calculus without aspect mechanismsemantics of -calculus with advice mechanism
E [E0 E1] = E [E0] (f. E [E1] (v. (f ) v))
f : continuation
A[A] call(f ) v application to continuation = call join point
E [E0 E1] = E [E0] (f. E [E1] (v. A[A] call (f ) v))E [E0 E1] = E [E0] (f. E [E1] (v. A[A] call (f (v. v)) v))A[A] reception
application to continuation v = reception join point
f 2 let f x = x*2
we can define it in systematic way!
![Page 28: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/28.jpg)
28
Advantages of Our Formalization
simpler than existing formalizations [Wand ’02] [Walker ’03]
no need for rules for each advice modifier beginnings and ends of actions are represented sy
mmetrically easier to support advanced features
exception handling context sensitive pointcuts (cflow) around advice
![Page 29: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/29.jpg)
29
exception handling (sketch)
give a standard semantics by adding continuation that represents current
handler identify failure join point
E [E0 E1] h = E [E0] (f. E [E1] (v. A[A] call (f (v. A[A] reception h v) (v. h v) ) h v) h) h
semantics of -calculus without aspect mechanism
(v. A[A] failure h h v) )
semantics of -calculus with advice mechanism
![Page 30: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/30.jpg)
30
around-like advice (concept)
using idea of partial continuation [Danvy ’89]
a part of the rest of computation, rather than the whole rest
we currently formalized by using continuation-composing style
f 2 let f x = x*2
partial continuation = skip / proceed
![Page 31: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/31.jpg)
31
Related Work
approaches based on the region-in-time model: Aspect SandBox[Wand ’02], Tucker et al. ’03, MiniMAO[Clifton ‘05],
some approaches treat beginning and end of an event as different join points, but that have different motivations Walker et al. ’03: propose a low-level language that serves as
a target of translation from a high-level AOP language Douence et al. ’04: define a formal semantics of cflow by using
calling contexts from execution history
![Page 32: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/32.jpg)
32
Conclusion
a new join point model that defines beginnings and ends of actions as different join points Point-in-time vs. Region-in-time designed PitJ based on the model
improves aspect reusability by enhancing expressiveness of pointcuts
formalized the model in continuation-passing style simpler than some existing formalizations easier to support advanced features
![Page 33: Continuation Join Points](https://reader036.vdocuments.mx/reader036/viewer/2022070410/56814668550346895db38b92/html5/thumbnails/33.jpg)
33
Future Work
integrate more advanced features dflow pointcut [Kawauchi ’03]
first-class continuation tail-call elimination
implement a compiler for PitJ language Java bytecode should be made without CPS transf
ormation