Your SlideShare is downloading. ×
Invoke dynamics
Upcoming SlideShare
Loading in...5

Thanks for flagging this SlideShare!

Oops! An error has occurred.


Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Invoke dynamics


Published on

Published in: Technology, Education

1 Like
  • Be the first to comment

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

No notes for slide


  • 1. JSR 292 Invoke Dynamics By Balamurugan S
  • 2. My Info
    • 4+ years of experience in Java
    • Currently working in logica
    • Worked as a trainer for two years
    • Completed SCJP, SCWCD and SCBCD certifications
    • Passion in learning new technologies and training people
    • Joined JUG Chennai few months back
  • 3. Why JSR 292 ?
    • Dynamically Typed Languages
    • Performance
    • Invokedynamic instruction
    • Hotswappable classes – Interface Injection
  • 4. Dynamically Typed Languages and the JVM
    • What is the JVM?
    • Statically Typed Languages vs. Dynamically Typed Languages
    • JSR 223 — A First Step in Dynamic Language Support
  • 5. The Problem for Dynamically Typed Languages
    • Satisfying the requirements of Java Byte code
    • Byte code supports only statically typed languages
    • Byte code requirements for method invocation
      • Statically typed languages – Type checking is done in compile time
    • Consider the following Java code snippet:
    • String s = "Hello World";
    • System.out.println(s);
    • Bytecode instructions for the above code:
    • ldc #2
    • astore_1
    • getstatic #3
    • aload_1
    • invokevirtual #4
  • 6. JSR 292 — The Next Step in Dynamic Language Support
    • Introduction of new java byte code instruction “invokedynamic” and new method linkage mechanism
    • Bytecode Instructions for Method Invocation:
    • Since its inception, the Java Virtual Machine Specification has specified four bytecodes for method invocation
      • invokevirtual
      • invokeinterface
      • invokestatic
      • Invokespecial
    • Let's examine invokevirtual and invokeinterface instruction, because it's similar in format to the new “invokedynamic” instruction.
  • 7. The invokevirtual and invokeinterface Instruction
    • The invokevirtual instruction:
    • invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
    • Its one byte operation code
    • The remainder of the instruction, #4, is the two-byte operand
    • The receiver class that contains the method, the method name, and the method descriptor
    • Syntax:
    • invokevirtual <method-specification>
    • The invokeinterface Instruction:
    • invokeinterface #9, 2; //InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
    • Syntax:
    • invokeinterface <method-specification> <n>
  • 8. The invokedynamic Instruction
    • Syntax:
    • invokedynamic <method-specification> <n>
    • An invokeinterface bytecode instruction might look similar to the following:
    • Invokedynamic #10; //NameAndTypelessThan:(Ljava/lang/Object;Ljava/lang/Object;)
    • Dynamic language to translate a method invocation into bytecode without having to specify a target type
    • The method specification in this case is a simplified constant pool reference
    • How does the JVM find the method if the receiver type isn't supplied?
    • The answer to that question is that JSR 292
  • 9. A New Dynamic Linkage Mechanism: Method Handles
    • New linkage mechanism for dynamically typed languages called Method Handles
    • java.dyn package
    • Java.lang.invoke package
    • It is callable just like a named reference to a method
    • When invokedynamic instruction is executed, it is linked first
    • When linking Method Handle is assigned to individual invokedynamic instruction
  • 10.
    • BootStrap Method:
    • Another part of this new linkage mechanism is the bootstrap method
    • A bootstrap method is a method handle that is called once for each invokedynamic instruction, when the instruction is linked
    • Each class that contains at least one invokedynamic instruction must also specify a bootstrap method
    • The bootstrap method, in turn, creates a call site object and chooses an appropriate target method handle
    • The call site object provides an API to get and set the target method
  • 11.
    • Here, for example, is a snippet of bytecode that calls a method handle:
    • getfield myMH
    • ldc #999
    • invokevirtual #44 //Method java/dyn/MethodHandle:invoke(I)I
    • istore 5
    • When a bootstrap method is called for an unlinked dynamic call site, it is passed the following information:
    • The java.lang.Class object for the class containing the instruction.
    • The method name represented as a String.
    • The resolved descriptor for the instruction, represented as a java.dyn.MethodType token.
  • 12. Sample code snippet import java.lang.invoke.*; import java.sql.*; public class Query { static { //Bootstrap method Linkage.registerBootstrapMethod(&quot;doBootstrap&quot;); } public static ResultSet query(String queryString, Object... params) { //Performs query, return ResultSet } public static CallSite doBootstrap(Class caller, String methodName, MethodType type) { MethodHandles.Lookup lookup = MethodHandles.lookup(); //Lookup the class that has the method that we will be linking to //In this case, query is in the same class Class me = lookup.lookupClass(); //Lookup query method by matching the parameter type and return type MethodHandle rawQuery = lookup.findStatic(me, &quot;query&quot; , MethodType.methodType(ResultSet.class, String.class, Object[].class)); //Set the method name as the first parameter to query() MethodHandle cookedQuery = MethodHandles.insertArguments(rawQuery, 0, methodName); //Return a CallSite object back to the JVM to continue with the call return (new ConstantCallSite(MethodHandles.collectArguments(cookedQuery, type))); }
  • 13. public static void main(String... args) throws Throwable { //Invoking this will result in doBootstrap() method being called ResultSet result = InvokeDynamic.<ResultSet>findByTitleAndAuthor (&quot;The Shining&quot;, &quot;Stephen King&quot;); String val = InvokeDynamic.<String>findByTitleAndAuthor (&quot;Lord of the Rings&quot;, &quot;JRR Tolkein&quot;); } } //java -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic Query
  • 14. Future Enhancements
    • Interface injection:
    • Modify classes at runtime so that they can implement new interfaces
    • Can provide a structured way to accomplish this in the JVM
  • 15. Summary
    • JVM has been host to a growing number of languages
    • JVM is very attractive to application developers
    • JVM delivers a lot of execution efficiency
    • Implementers of compilers for dynamically typed languages have found it difficult to meet the JVM bytecode requirements for method invocation. JSR 292 addresses that problem by providing a new bytecode, invokedynamic, and a new linkage mechanism based on method handles
    • Investigation for inclusion in JSR 292 is interface injection
  • 16. Thank ‘U’ email:
  • 17. Queries?