A Post-Apocalyptic sun.misc.Unsafe World by Christoph engelbert

http://www.superbwallpapers.com/fantasy/post-apocalyptic-tower-bridge-london-26546/
A Post-Apocalyptic
sun.misc.Unsafe
World

www.hazelcast.com@noctarius2k
Who’s that dude?
• Chris Engelbert
• Manager Developer Relations @Hazelcast
• Twitter-Senpai
• Java-Passionist (10+ years)
• Performance
• Garbage Collection
• Benchmark Fairytales

Disclaimer
This talk is not going to be negative!

Disclaimer
But certain things are highly speculative 
and APIs or ideas might change by
tomorrow!

http://www.underwhelmedcomic.com/wp-content/uploads/2012/03/runningdude.jpg
sun.misc.Scissors

sun.misc.Unsafe - What you (don’t) know

• Internal class (sun.misc Package)

• Used inside the JVM / JRE

// Unsafe mechanics 
private static final sun.misc.Unsafe U; 
private static final long QBASE; 
private static final long QLOCK; 
private static final int ABASE; 
private static final int ASHIFT; 
static { 
try { 
U = sun.misc.Unsafe.getUnsafe(); 
Class<?> k = WorkQueue.class; 
Class<?> ak = ForkJoinTask[].class; 
QBASE = U.objectFieldOffset 
(k.getDeclaredField("base")); 
QLOCK = U.objectFieldOffset 
(k.getDeclaredField("qlock")); 
ABASE = U.arrayBaseOffset(ak); 
int scale = U.arrayIndexScale(ak); 
if ((scale & (scale - 1)) != 0) 
throw new Error("data type scale not a power of two"); 
ASHIFT = 31 - Integer.numberOfLeadingZeros(scale); 
} catch (Exception e) { 
throw new Error(e); 
} 
} 
}
example:
java.util.concurrent.ForkJoinPool

• Used outside as well

• Used outside as well (good
// Deserialization
public Object readObject(InputStream is) { 
SomeType element = unsafe.allocateInstance(SomeType.class); 
element.deserializeValues(is); 
return element; 
}

• Used outside as well (good, bad)

#
# A fatal error has been detected by the Java Runtime Environment:
#
# SIGSEGV (0xb) at pc=0x00000001067314b5, pid=25244, tid=5891
#
# JRE version: Java(TM) SE Runtime Environment (8.0_05-b13) (build 1.8.0_05-b13)
# Java VM: Java HotSpot(TM) 64-Bit Server VM (25.5-b02 mixed mode bsd-amd64 compressed oops)
# Problematic frame:
# V [libjvm.dylib+0x5314b5] Unsafe_SetNativeAddress+0x36
#
# An error report ﬁle with more information is saved as:
# /Users/noctarius/git/hazelcast-only.idea/hs_err_pid25244.log
#
# If you would like to submit a bug report, please visit:
# http://bugreport.sun.com/bugreport/crash.jsp
#

• Used outside as well (good / bad)
• Never intended for outside use

• Used outside as well (good / bad)
• Never intended for outside use
• Used by popular:
• Applications
• Frameworks
• Libraries

MapDB
Netty
Hazelcast
Cassandra
Mockito
EasyMock
JMock
Scala
Spock
Robolectric
Grails
Gson
Neo4j
Apache Ignite
Apache Spark
Apache Kafka
Apache Wink
Apache Storm
Apache Flink
Apache Continuum
Zookeeper
Dropwizard
Metrics (AOP)
Kryo
Byte Buddy
Hibernate
Liquibase
Spring Framework
Ehcache
OrientDB
Chronicle
Apache Hadoop
Apache HBase
GWT
Disruptor
JRuby
AkkaAgrona
Aeron
Simple Binary Encoding
XRebel
Presto
jol
ActivePivot
LWJGL
XAP
XStream
CapLogic
WildFly
Inﬁnispan

sun.misc.Unsafe
is only supported on HotSpot JVMs anyways, isn’t it?

sun.misc.Unsafe
is only supported on HotSpot JVMs anyways, isn’t it?
No!

Language URL sun.misc.Unsafe
Avian C++ https://github.com/ReadyTalk/avian Yes
BicaVM JavaScript https://github.com/nurv/BicaVM No
Cacao C http://www.cacaojvm.org Yes
Excelsior JVM C / C++ ? http://www.excelsiorjet.com Yes
Dalvik / ART / Android C / C++ https://source.android.com/source/index.html Yes
Graal mainly Java http://openjdk.java.net/projects/graal Yes
GCJ C / C++ https://gcc.gnu.org/java Yes
HaikuVM C http://haiku-vm.sourceforge.net No
IBM J9 C / C++ ? http://www.ibm.com/developerworks/java/jdk/index.html Yes
IcedTea C / C++ http://icedtea.classpath.org/wiki/Main_Page Yes
IKVM.NET C# http://www.ikvm.net Yes
Jamiga C https://sourceforge.net/projects/jamiga2 No
JamVM C http://jamvm.sourceforge.net Yes
JatoVM C http://jatovm.org Yes
JikesRVM C microkernel, Java http://www.jikesrvm.org Yes
JNode C microkernel, Java http://www.jnode.org Yes
JVM.go Go https://github.com/zxh0/jvm.go Yes
JX C http://www4.cs.fau.de/Projects/JX/index.html No
Kaffe C https://github.com/kaffe/kaffe Yes
NanoVM C http://harbaum.org/till/nanovm/index.shtml No
OpenJDK / Oracle / Zulu C / C++ http://openjdk.java.net Yes
RoboVM C / C++ / ObjC https://robovm.com Yes
SAPJVM C / C++ ? http://help.sap.com/saphelp_nwce10/helpdata/en/47/
dc90b4ef17452289f9128b8c2bbd77/content.htm
Yes
Waratek Multitenant JVM C / C++ ? http://www.waratek.com Yes
Zing JVM C / C++ ? https://www.azul.com/products/zing Yes

Use Cases - The Good Ones!
• Low Latency, GC Overhead

Caution: Overly simpliﬁed!
Unsafe unsafe = findUnsafe(); 
long baseAddress = unsafe.allocateMemory(8);
 
class Point { 
long offsetX = 0; 
long offsetY = 4; 
 
int getX(long baseAddress) {
return unsafe.getInt(baseAddress + offsetX);
}
 
int getY(long baseAddress) {
return unsafe.getInt(baseAddress + offsetY);
} 
}

• Fast (de-)serialization

// Deserialization
public Object readObject(InputStream is) { 
SomeType element = unsafe.allocateInstance(SomeType.class); 
element.deserializeValues(is); 
return element; 
}

• 64bit Memory regions

long baseAddress = unsafe.allocateMemory(Long.MAX_VALUE); 
unsafe.putInt(baseAddress + Long.MAX_VALUE - 4, Integer.MAX_VALUE);

• Atomic memory operations

unsafe.compareAndSwapInt(this, offsetField, oldValue, newValue); 
unsafe.compareAndSwapLong(this, offsetField, oldValue, newValue); 
unsafe.compareAndSwapObject(this, offsetField, oldObject, newObject);

• Efﬁcient memory layout

class Point { 
long offsetX = 0; 
long offsetY = 4; 
}
offsetX
offsetY

• Fast ﬁeld / memory access

long versionFieldOffset = unsafe.objectFieldOffset(versionField); 
 
long version = unsafe.getLong(this, versionFieldOffset); 
 
unsafe.putLong(this, versionFieldOffset, 10L);

• Access to array elements with volatile semantics

long base = unsafe.arrayBaseOffset(int[].class); 
long index = unsafe.arrayIndexScale(int[].class); 
 
unsafe.getIntVolatile(array, base + (index * 3));

• Custom memory fences

unsafe.fullFence();
 
unsafe.storeFence();
 
unsafe.loadFence();

• Fast interaction with native code

• Fast interaction with native code
long addr = unsafe.allocateMemory(50); 
copyBytes(addr, byteArray); 
nativeCall(addr);

Get Access
Easy One (not working outside the JRE / JDK)
Unsafe unsafe = Unsafe.getUnsafe();

Get Access
The Ugly One
private static final Unsafe UNSAFE; 
static { 
try { 
Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe"); 
theUnsafeField.setAccessible(true); 
UNSAFE = (Unsafe) theUnsafeField.get(Unsafe.class); 
 
// We need you! =( 
} 
}

Get Access
The Working One
(at least for more than just HotSpot)
private static Unsafe findUnsafe() { 
try { 
return Unsafe.getUnsafe(); 
} catch (SecurityException se) { 
return AccessController.doPrivileged(new PrivilegedAction<Unsafe>() { 
@Override 
public Unsafe run() { 
try { 
Class<Unsafe> type = Unsafe.class; 
try { 
Field field = type.getDeclaredField("theUnsafe"); 
field.setAccessible(true); 
return type.cast(field.get(type)); 
 
for (Field field : type.getDeclaredFields()) { 
if (type.isAssignableFrom(field.getType())) { 
field.setAccessible(true); 
return type.cast(field.get(type)); 
} 
} 
} 
throw new RuntimeException("Unsafe unavailable", e); 
} 
throw new RuntimeException("Unsafe unavailable"); 
} 
}); 
} 
}

Get Access
The Tricky One
private static final Unsafe UNSAFE; 
static { 
try { 
Constructor<Unsafe> constructor =
Unsafe.class.getDeclaredConstructor();
 
constructor.setAccessible(true); 
UNSAFE = constructor.newInstance(); 
 
// We need you! =( 
} 
}

Get Access
Does Any Of This Feel Right?

Let me be blunt -- sun.misc.Unsafe must die in a ﬁre. It is -- wait
for it -- Unsafe. It must go. Ignore any kind of theoretical rope and
start the path to righteousness _*/now/*_. It is still years until the
end of public updates to JDK 8, so we have /*years */to work this out
properly. But sticking our heads in the collective sands and hoping for
trivial work arounds to Unsafe is not going to work. If you're using
Unsafe, this is the year to explain where the API is broken and get it
straight....
Please help us kill Unsafe, kill Unsafe dead, kill Unsafe right, and do
so as quickly as possible to the ultimate beneﬁt of everyone.
Wed Apr 8 19:15:42 UTC 2015, OpenJFX Mailinglist, Donald Smith, Oracle
http://mail.openjdk.java.net/pipermail/openjfx-dev/2015-April/017028.html

Oracle created a new Taskforce

Oracle created a new Taskforce
K.U.T.T. - Kill Unsafe To Total death

private static final Unsafe UNSAFE = findUnsafe();
private static long VERSION_OFFSET = findVersionOffset();
// Updated through Unsafe only!
private volatile long version = 0;
public long increment() {
while(true) {
long version = this.version;
long newVersion = version + 1;
if (UNSAFE.compareAndSwapLong(
this, VERSION_OFFSET, version, newVersion)) {
return newVersion;
}
}
}
Atomic Updates

Atomic Updates
private final AtomicLong version = new AtomicLong(0);
public long increment() {
return version.incrementAndGet();
}

Atomic Updates
private static final AtomicLongFieldUpdater<Record> VERSION = 
AtomicLongFieldUpdater.newUpdater(Record, "version"); 
// Updated through atomic field updater only! 
private volatile long version = 0; 
 
public long increment() { 
return VERSION.incrementAndGet(this); 
}

Atomic Updates
private static final VarHandle VERSION = findVersionVarHandle(); 
 
// Updated through VarHandle only! 
private volatile long version = 0; 
 
public long increment() { 
return (long) VERSION.addAndGet(this, 1); 
}

Atomic Updates
public static VarHandle findVersionVarHandle() { 
try { 
return MethodHandles.lookup(). 
findFieldVarHandle(Record.class, "version", long.class); 
 
} 
}

Memory Management
public long memory() { 
long address = UNSAFE.allocateMemory(8);
 
UNSAFE.putLong(address, Long.MAX_VALUE);
 
return UNSAFE.getLong(address); 
}

Memory Management
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(8); 
 
byteBuffer.putLong(0, Long.MAX_VALUE); 
 
return byteBuffer.getLong(0); 
}

Memory Management
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(8); 
 
VarHandle bufferView = 
MethodHandles.byteBufferViewVarHandle(long[].class, true); 
 
bufferView.set(byteBuffer, 0, Long.MAX_VALUE); 
 
return bufferView.get(byteBuffer, 0); 
}

Memory Management
MemoryRegion region = MemoryRegion.allocateNative 
("myname", MemoryRegion.UNALIGNED, Long.MAX_VALUE); 
 
VarHandle regionView = MethodHandles. 
memoryRegionViewVarHandle(long[].class, true);
 
regionView.set(region, 0, Long.MAX_VALUE);
 
return regionView.get(region, 0); 
}

Memory Management
public long memory(long index) { 
try (Scope scope = new NativeScope()) { 
Pointer<Long> ptr = scope.allocate( 
NativeLibrary.createLayout(long.class), numElements); 
 
Reference<Long> ref = ptr.offset(index).deref(); 
 
ref.set(Long.MAX_VALUE); 
 
return ref.get(); 
} 
}

Deserialization
private static final Unsafe UNSAFE = findUnsafe(); 
 
private static final long VALUE_OFFSET = findValueOffset(); 
 
public String deserializeString() throws Exception { 
char[] chars = readCharsFromStream(); 
String allocated = (String) UNSAFE.allocateInstance(String.class); 
UNSAFE.putObjectVolatile(allocated, VALUE_OFFSET, chars); 
return allocated; 
}

Deserialization
public String deserializeString() throws Exception { 
char[] chars = readCharsFromStream().freeze(); 
 
ReflectionFactory reflectionFactory = 
ReflectionFactory.getReflectionFactory(); 
 
Constructor<String> constructor = reflectionFactory 
.newConstructorForSerialization(String.class, char[].class); 
 
return constructor.newInstance(chars); 
}

Interoperability
extern c { 
JNIEXPORT int JNICALL 
Java_ProcessIdentifier_getProcessId(JNIEnv *, jobject); 
} 
 
JNIEXPORT int JNICALL 
Java_ProcessIdentifier_getProcessId(JNIEnv *env, jobject thisObj) { 
return getpid(); 
} 
 
public class ProcessIdentifier { 
static { 
System.loadLibrary("processidentifier"); 
} 
 
public native void talk(); 
}

Interoperability
interface LibC { 
void getpid(); 
} 
 
public int call() { 
LibC c = LibraryLoader.create(LibC.class).load("c"); 
return c.getpid(); 
}

Interoperability
public void call() {
MethodType intType = MethodType.methodType(int.class);
 
MethodHandle handle = MethodHandles 
.findNative(null, “getpid”, intType);
 
return (int) handle.invokeExact(); 
}

Value Types
value class Point { 
final int x; 
final int y; 
} 
 
// Create a Point instance 
Point point = makeValue(1, 2);

Value Types
int[] values = new int[2]; 
int x = values[0]; 
int y = values[1];

Value Types
int y = values[1];
Stack
var X
var Y

Value Types
int y = values[1];
Stack
var X
var Y
Stack Allocation!

Specialized Generics
class Box<any T> { 
void set(T element) { ... };
 
T get() { ... }; 
}

class Box<any T> { 
void set(T element) { ... };
 
T get() { ... }; 
}
Box<int> Box${T=int}.class 
Box<String> Box${T=java.lang.String}.class 
Box<RandomClass> Box${T=RandomClass}.class

public void generics() { 
Box<int> intBox = new Box<>(); 
intBox.set(1); 
int intValue = intBox.get(); 
 
Box<String> stringBox = new Box<>(); 
stringBox.set("hello"); 
String stringValue = stringBox.get(); 
 
Box<RandomClass> box = new Box<>(); 
box.set(new RandomClass()); 
RandomClass value = box.get(); 
}

Arrays 2.0
int[] values = new int[Long.MAX_VALUE];

Arrays 2.0
Arrays.chop(T[] a, int newlength);

Arrays 2.0
Box<String>[] ... = new Box<String>[];

Arrays 2.0
Box<int>[] ... = new Box<int>[];

Arrays 2.0
char[] frozen = new char[20L].freeze();

Arrays 2.0
char[] frozen = new char[20L].freeze();
Point[] points = new Point[3]; Stack
var X
var Y
var X
var Y
var X
var Y
points[0]
points[1]
points[2]

Cleaner API
Who knows the Cleaner API?
You should - it’s around since Java 1.4 ;-)

Cleaner API
package java.nio;
import sun.misc.Cleaner;
class DirectByteBuffer 
extends MappedByteBuffer 
implements DirectBuffer {
private static class Deallocator implements Runnable {
private Deallocator(long address, long size, int capacity) {...}
public void run() {...}
}
private final Cleaner cleaner;
DirectByteBuffer(int cap) {
...
cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
}
}

Cleaner API
public selfCleaning() { 
try(AutoCleaning autoCleaning : new AutoCleaning()) { 
// do your thing here 
} 
}

Cleaner API
public class AutoCleaning implements AutoCloseable {
// A cleaner, preferably one shared within a library
private static final Cleaner cleaner = ...;
static class State
implements Runnable {
State(...) {/* initialize State needed for cleaning action */}
public void run() {/*cleanup action accessing State, executed at most once*/}
}
private final State state;
private final Cleaner.Cleanable cleanable;
public AutoCleaning() {
this.state = new State(...);
this.cleanable = cleaner.register(this, state);
}
public void close() {
cleanable.clean();
}
}

More exciting
stuff upcoming…

Class Dynamic
•Templating functionality

Class Dynamic
•Aspect-like approach

Class Dynamic
•Group common functionality

Class Dynamic
•Enhanced Proxies

Class Dynamic
•Enhanced Proxies
R methodName(ARGS) { 
synchronized (this) { 
underlying.methodName(ARGS); 
} 
}
Collections::sychronizedMap

Class Dynamic
•Enhanced Proxies
Logging / Tracing
R methodName(ARGS) { 
logger.trace("Before methodname X");
underlying.methodName(ARGS); 
logger.trace("After methodname X"); 
}

Class Dynamic
•Enhanced Proxies
Your Use Case!

SpinWait Hints
Hints the JVM that a busy spin’s upcoming

SpinWait Hints
JVM CAN intrinsify to use a WAIT opcode for the speciﬁc platform / CPU

SpinWait Hints
No-Op implementation for non supported CPUs

SpinWait Hints
No-Op implementation for non supported CPUs
while (!shutdown) { 
while (queue.length == 0) { 
// Hint the JVM to intrinsify wait 
// opcode otherwise busy spin  
Thread.onSpinWait(); 
} 
consume(queue); 
}

What Else?
No idea!
A lot is changing now.
Java / JVM will be different.

What Else?
No idea!
A lot is changing now.
Java / JVM will be different.
Don’t forget about Jigsaw,
test your application with Java 9 EA builds!
https://jdk9.java.net/jigsaw/

Questions?
github.com/noctarius
@noctarius2k
More information:
• http://openjdk.java.net/jeps/193
• http://openjdk.java.net/projects/valhalla/
• http://cr.openjdk.java.net/~jrose/arrays/frozen-array-value-rules.html
• https://twitter.com/PaulSandoz/status/623891528432394240
• http://openjdk.java.net/projects/panama/
• http://cr.openjdk.java.net/~jrose/values/values-0.html
• http://cr.openjdk.java.net/~briangoetz/valhalla/spec-classdyn.html
• http://blog.codefx.org/java/dev/the-road-to-valhalla/

http://openjdk.java.net/jeps/259

A Post-Apocalyptic sun.misc.Unsafe World by Christoph engelbert

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à A Post-Apocalyptic sun.misc.Unsafe World by Christoph engelbert

Similaire à A Post-Apocalyptic sun.misc.Unsafe World by Christoph engelbert (20)

Plus de J On The Beach

Plus de J On The Beach (20)

Dernier

Dernier (20)

A Post-Apocalyptic sun.misc.Unsafe World by Christoph engelbert