Java 7: Fork/Join, Invokedynamic and the future

Java 7 Launch

Fork/Join concurrency

@Sander_Mak

What?

Fork:
Recursively decompose
large task into subtasks

Join:
Combine results of
recursive tasks

7/7/2011 Java 7 Launch Event

Why?
Mul3core challenge


How?

Introducing:
  java.uLl.concurrent.ForkJoinPool Worker 1

• ‘ExecutorService with  Worker 2

runLme tuning’
• Recursive algorithms
Worker 3
• Workstealing


... MapReduce?

Environment Single JVM Cluster

Model Recursive forking Single fork step

Scales with Cores/CPUs Nodes

Opera3on Workstealing No inter‐node 
communicaLon


Example
Sony’s been hacked...

Are we compromised...?


Java 7 Launch

JSR‐292: Invokedynamic

@Sander_Mak

JVM Languages

Java


JVM Languages

Groovy Clojure

JRuby Java JavaFX
Scala


JVM Languages
jProlog Pizza MultiJava
Fantom

JLog
Groovy Clojure MetaJ

JRuby Java JavaFX Jaskell

Rhino Scala JBasic
Aardappel
Funnel
Jacl Drools
Jython


JVM Languages

Hundreds of
Languages

JVM Languages

‘Language ﬁcLons’

JVM

Exceptions
Primitive types
Objects
Access control
Garbage coll.
Threading
Memory model


JVM Languages

‘Language ﬁcLons’
Java

Enums
Checked exc.
JVM Generics

Exceptions Exceptions
Primitive types Primitive types
Objects Objects
Access control Access control
Garbage coll. Garbage coll.
Threading Threading.
Memory model Memory model


JVM Languages
JRuby

‘Language ﬁcLons’ Open classes
Dynamic typing
Java Closures

Enums Enums
Checked exc. Checked exc.
JVM Generics Generics

Exceptions Exceptions Exceptions
Primitive types Primitive types Primitive types
Objects Objects Objects
Access control Access control Access control
Garbage coll. Garbage coll. Garbage coll.
Threading Threading. Threading
Memory model Memory model Memory model


JVM Languages
Obviously JVM is viable, however:
• Language implementors need to invent 
‘creaLve’ compilaLon schemes for every 
language
• Performance suﬀers when abstracLng beyond 
Java idioms

How to improve?


JSR‐292
Mission:
“We are extending the JVM with first-class architectural
support for languages other than Java, especially dynamic
languages. This project will prototype a number of
extensions to the JVM, so that it can run non-Java languages
efficiently, with a performance level comparable to that of
Java itself.” http://openjdk.java.net/projects/mlvm/


Compiling dynamic languages

• JVM pre]y language‐friendly
• ExcepLon: method calls
– Signature at callsite must match exactly
TargetClass Name Method descriptor
18:
invokevirtual
#5; //Method java/util/ArrayList.add:(Ljava/lang/Object;)Z

– Dispatch on staLc type of parameters and dynamic 
type of receiver
– Method must exist at compile Lme
– Link to target is ﬁxed, no relinking


Compiling dynamic languages

• Common soluLons:
- Don’t compile, interpret (someLmes unavoidable)
- Introduce generic CallSite abstracLon which dispatches 
method calls
- AOT compilaLon into specialized invoker classes 
(suitable for core methods)
- JIT bytecode generaLon of small stub methods

Either way: abundance of syntheLc types and 
bytecode hard to opLmize for JVM


Invokedynamic
New bytecode, last piece of JSR‐292 puzzle:
Name Method descriptor
18:
invokedynamic
#5; //NameAndType addInts:(II)I

• InvocaLon without reference to actual method 
descriptor
• Instead, symbolic name and type
• No receiver: all arguments are equal
What is the target?

Method handles
• Lightweight, safe method pointers
• Like java.lang.reﬂect.Method, but:
– No argument boxing/unboxing
– Access checks only at creaLon Lme
– Leaner, can be as fast as direct call
– No wrapping of excepLons


Method handles
• Lightweight, safe method pointers
• Like java.lang.reﬂect.Method, but:
– No argument boxing/unboxing
– Access checks only at creaLon Lme
– Leaner, can be as fast as direct call
– No wrapping of excepLons

Java 7
MethodHandle mh =
MethodHandles.lookup().findVirtual(String.class,
“substring”, typeDescriptor);

String java = (String) mh.invokeExact(“jjava”, 1);


Invokedynamic ‐ bootstrap
• Invokedynamic triggers bootstrap
• Ader installing target, invokedynamic invokes 
MH directly
DynamicInvokerClass ImplementationClass

aload_1;
invokedyn. meth:Type; implementation(Type) {
return; result = ..
return result

}
bootstrap( .. ) {
..lookup..
return CallSite

}


MH directly

aload_1;
invokedyn. meth:Type; implementation(Type) {
return; result = ..
return result

}
bootstrap( .. ) {
..lookup.. MH can be guarded 
return CallSite
with test, adapt types, 
} etc.


MH directly

aload_1;
invokedyn. meth:Type; Method implementation(Type) {
return; Handle(s) result = ..
return result

}
bootstrap( .. ) {
..lookup..
return CallSite

}


Invokedynamic

• Invokedynamic + bootstrap method allow 
language to up‐call from VM for linking/
dispatching.

Not impossible before, but hard and slow. JVM now 
fully opLmizes dynamic calls.


Wrap‐up
• JSR‐292 invokedynamic features:
– Let’s language implementors avoid tricks
– Level the playing ground, speedwise
– Allow exisLng VM opLmizaLons to be applied to 
new paradigms
• JRuby, Groovy acLvely working on JSR‐292 
support
• For example, JRuby can cut 80% of linking/
calling code in runLme


Java 7 Launch

Beyond Java 7

@Sander_Mak

Ader JDK7 


JDK8: Coin conLnued
Java 7

List<Integer> piDigits = Collections.unmodifiableList
(Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 9 ));

Java 8
// List literal:
List<Integer> piDigits = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 9];
Integer first = piDigits[0];

// Map literal:
Map<Integer, String> platonicSolids = { 4 : "tetrahedron",
6 : "cube", 8 : "octahedron", 12 : "dodecahedron",
20 : "icosahedron"
};


JDK8: Project Lambda
• Add ﬁrst‐class funcLons
• Single Abstract Method types
• Solve interface evoluLon with  ‘defender 
methods’
• Paves way for parallel collecLons
Java 8
// Lambda expression
List<Integer> list = [1,2,3];
list.forEach(#{ e -> e * 2; });

// Reference existing methods
Person[] people = ...
Arrays.sort(people, #Person.compareByAge);


JDK8: Modularity
JSR‐294 ‘Project Jigsaw’, goals:

• Modular JDK
- SE Core
- Packages: Swing, CORBA, XML, etc.
• Modular and versioned applicaLons
• Integrate with plamorm dependency 
management


JDK8

Available Fall/Winter of

See you @ next launch event?


Java 7: Fork/Join, Invokedynamic and the future

More Related Content

Java 7: Fork/Join, Invokedynamic and the future

Editor's Notes