• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Sub-Method Reflection
 

Sub-Method Reflection

on

  • 1,044 views

Reflection has proved to be a powerful feature to support the design of development environments and to extend languages. However, the granularity of structural reflection stops at the method level. ...

Reflection has proved to be a powerful feature to support the design of development environments and to extend languages. However, the granularity of structural reflection stops at the method level. This is a problem since without sub-method reflection developers have to duplicate efforts, for example to introduce transparently pluggable type-checkers or fine-grained profilers. In this paper we present Persephone, an efficient implementation of a sub-method meta-object protocol (MOP) based on AST annotations and dual methods (a compiled method and its meta-object) that reconcile AST expressiveness with bytecode execution. We validate the MOP by presenting TreeNurse, a method instrumentation framework and TypePlug, an optional, pluggable type system which is based on Persephone.

Statistics

Views

Total Views
1,044
Views on SlideShare
1,043
Embed Views
1

Actions

Likes
0
Downloads
2
Comments
0

1 Embed 1

http://www.slideshare.net 1

Accessibility

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Sub-Method Reflection Sub-Method Reflection Presentation Transcript

    • Sub-Method Reflection Marcus Denker Stéphane Ducasse Adrian Lienhard Philippe 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 :CompiledMethod annotation compiledMethod #(12 13 45 38 98 128 annotation reflectiveMethod 84 72 42 77 22 28 59 32 7 49 51 87 64) 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 (9 raisedTo: 10000) <:evaluateAtCompiletime:> > Source invisible annotations — Reflective API — Can reference any object > Every node can be annotated > Semantics: Compiler Plugins © Marcus Denker
    • Example I: Instrumentation > Goal: Code Instrumentation — Similar to Javassist, but at runtime — Insert code before/after, replace — Access to runtime data (e.g. receiver of send) a := 1 max: 3 a := 1 max: 3. AssignmentCounter inc. Original Code Instrumented Code © Marcus Denker
    • Instrumentation using Annotations > On demand code generation Annotation — Faster! AST after > Better code — No preamble code to access original data on stack #[10 125 55 00 80 90] bytecode > Annotations are instrumented #[10 125 55 33 55 00 80 90 33] metadata bytecode — 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 Squeak tinyBenchmarks Caching scheme Runtime unmodified Squeak 6.9 seconds Persephone, no cache >1 hour Persephone, cache 6.9 seconds © Marcus Denker
    • Memory number of classes memory Squeak 3.9 2040 15.7 MB Persephone 2224 20 MB no reflective methods Persephone 2224 123 MB reflective methods © 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? © Marcus Denker