Embed Size (px)
DESCRIPTION
Behavioral reflection is crucial to support for example functional upgrades, on-the-fly debugging, or monitoring critical applications. However the use of reflective features can lead to severe problems due to infinite metacall recursion even in simple cases. This is especially a problem when reflecting on core language features since there is a high chance that such features are used to implement the reflective behavior itself. In this paper we analyze the problem of infinite meta-object call recursion and solve it by providing a first class representation of meta-level execution: at any point in the execution of a system it can be determined if we are operating on a meta-level or base level so that we can prevent infinite recursion. We present how meta-level execution can be represented by a meta-context and how reflection becomes context-aware. Our solution makes it possible to freely apply behavioral reflection even on system classes: the meta-context brings stability to behavioral reflection. We validate the concept with a robust implementation and we present benchmarks. Slides from presentation at TOOLS 2008 Zuerich, 30.06.2008
Citation preview
© Marcus Denker
Sub-Method Reflection
Marcus DenkerStéphane DucasseAdrian LienhardPhilippe Marschall
© Marcus Denker
Roadmap
> Structural Reflection and Sub-Method Reflection> Persephone: Sub-Method Reflection for Smalltalk> Example I: Instrumentation Framework> Example II: Pluggable Type-System> Benchmarks + Memory> Future Work
© Marcus Denker
Structural Reflection
> Structure modeled as objects
— e.g. Classes, methods— Causally connected
> Uses:— Development environments— Language extensions and experiments
© Marcus Denker
Methods and Reflection
> Method are Objects— e.g in Smalltalk
> No high-level model for sub-method elements— Message sends— Assignments— Variable access
> Structural reflection stops at the granularity of methods
© Marcus Denker
Sub-Method Reflection
> Many tools work on sub method level— Profiler, Refactoring Tool, Debugger, Type Checker
> Communication between tools needed— example: Code coverage
> All tools use different representations— Tools are harder to build— Communication not possible
© Marcus Denker
Existing Method Representations
> Existing representations for Methods
— Text
— Bytecode
— AST
© Marcus Denker
Requirements
> Causal Connection
> Abstraction Level
> Extensibility
> Persistency
> Size and Performance
© Marcus Denker
Text
> Low level abstraction— String of Characters
> Not causally connected— Need to call compiler
© Marcus Denker
Bytecode
> Low level abstraction— Array of Integers
> Missing extensibility— e.g. for tools
> Mix of base- and meta-level code— Problems with synthesized code when changing code— Examples: AOP point-cut residues, reflection hooks
© Marcus Denker
Abstract Syntax Tree
> Not causally connected— Need to call compiler
> Not extensible— Fixed set of codes, no way to store meta data
> Not persistent— Generated by compiler from text, never stored
© Marcus Denker
Solution: Reflective Methods
> Annotated, persistent AST> Bytecode generated on demand and cached
:ReflectiveMethod
annotation
#(12 13 45 38 98 128 84 72 42 77 22 28 59
32 7 49 51 87 64)
:CompiledMethod
compiledMethod
reflectiveMethodannotation
Tools VM
© Marcus Denker
Persephone
> Implementation of Reflective Methods for Squeak Smalltalk
> Smalltalk Compiler generates Reflective Methods— Translated to Bytecode on demand
> Open Compiler: Plugins— Called before code generation— Transform a copy of the AST
© Marcus Denker
Requirements revisited
> Abstraction Level OK
> Causal Connection OK
> Extensibility OK
> Persistency OK
> Size and Performance OK
© Marcus Denker
Reflective Methods: Annotations
> Source visible annotations— extended Smalltalk syntax
> Source invisible annotations— Reflective API— Can reference any object
> Every node can be annotated> Semantics: Compiler Plugins
(9 raisedTo: 10000) <:evaluateAtCompiletime:>
© Marcus Denker
Example I: Instrumentation
Original Code Instrumented Code
a := 1 max: 3 a := 1 max: 3.
AssignmentCounter inc.
> Goal: Code Instrumentation — Similar to Javassist, but at runtime— Insert code before/after, replace— Access to runtime data (e.g. receiver of send)
© Marcus Denker
Instrumentation using Annotations
after
#[10 125 55 33 55 00 80 90 33]
#[10 125 55 00 80 90]originalbytecode
instrumentedbytecode
ASTAnnotation
> On demand code generation— Faster!
> Better code— No preamble
code to access data on stack
> Annotations are metadata— Original code
untouched
© Marcus Denker
Example II: Pluggable Type-System
> Example for textual annotations
bitFromBoolean: aBoolean <:type: Boolean :> ^ (aBoolean ifTrue: [1] ifFalse: [0]) <:type: Integer :>
> Optional, pluggable type-system> Types stored as annotations in the Reflective Methods
© Marcus Denker
Performance
Caching scheme Runtime
unmodified Squeak 6.9 seconds
Persephone, no cache >1 hour
Persephone, cache 6.9 seconds
Squeak tinyBenchmarks
© Marcus Denker
Memory
number of classes memory
Squeak 3.9 2040 15.7 MB
Persephoneno reflective methods
2224 20 MB
Persephonereflective methods
2224 123 MB
© Marcus Denker
Future Work
> Optimize Size of AST Representation— Simpler AST— AST Compression
> Behavioral Reflection— Implement Reflex model of partial behavioral reflection
> Beyond Text— Store only AST (no text)— Build text from annotated AST
© Marcus Denker
Conclusion
> Motivated the need for Reflective Methods> Implementation: Persephone> Examples
— Instrumentation framework— Pluggable type-system
> Benchmarks / Memory
© Marcus Denker
Conclusion
> Motivated the need for Reflective Methods> Implementation: Persephone> Examples
— Instrumentation framework— Pluggable type-system
> Benchmarks / Memory
Questions?
![Object-based and class-based composition of transitive mixinsnm.wu-wien.ac.at/research/publications/b613.pdf[25,36], meta-object protocols (MOP) [19], meta-classes [12], dynamic classes,](https://img.pdfslide.us/doc/110x75/604372669e8492726d790cb6/object-based-and-class-based-composition-of-transitive-2536-meta-object-protocols.jpg)
