This class may be removed in the future. Consider the replacements in JEP 193 'Variable Handles': http://openjdk.java.net/jeps/193
import sun.misc.Unsafe; public class Crash { private static final Unsafe unsafe = Unsafe.getUnsafe(); public static void crash() { unsafe.putAddress(0, 0); } public static void main(String[] args) { crash(); } }
@Override public final OnAddressFollowBy putAddress(long address){ UNSAFE.putAddress(currentAddress,address); currentAddress += SIZE_ADDRESS; return this; }
public static void putAddress(final long address, final long x) { UNSAFE.putAddress(address, x); }
public static void putAddress(long addr,long value){ unsafe.putAddress(addr, value); }
@Override public void putAddress(Unsafe unsafe, long address, long x) { unsafe.putAddress(address, x); }
public static final void putAddress(long address,long addrValue) { UNSAFE.putAddress(address,addrValue); }
public static void aput(long value, long addr) { INSTANCE.putAddress(addr, value); }
public static void aput(MappedObject mapped, long value, int fieldOffset) { INSTANCE.putAddress(mapped.viewAddress + fieldOffset, value); }
private static final void tlp_FreePages_addToHead(long addrFreePagesHead, long newFreePage, long addrNumFreePages) { long numFreePages = UNSAFE.getLong(addrNumFreePages); long oldHead = UNSAFE.getAddress(addrFreePagesHead); if (numFreePages != 0) {//oldHead!=availablePageTail UNSAFE.putAddress(oldHead + ZMPAGE_PREVFREEPAGE_OFFSET, newFreePage); }else {//oldHead is tail UNSAFE.putAddress(oldHead, newFreePage); } UNSAFE.putAddress(newFreePage + ZMPAGE_NEXTFREEPAGE_OFFSET, oldHead); UNSAFE.putAddress(newFreePage + ZMPAGE_PREVFREEPAGE_OFFSET, addrFreePagesHead); UNSAFE.putAddress(addrFreePagesHead, newFreePage); UNSAFE.putLong(addrNumFreePages, numFreePages + 1); }
private static final void tlp_AvailablePages_addToHead( long addrAvailablePageHead, long newAvailablePage) { long addrNumAvailablePage = addrAvailablePageHead+2*SIZE_LONG_TYPE; long numAvailablePage = UNSAFE.getLong(addrNumAvailablePage); long oldHead = UNSAFE.getAddress(addrAvailablePageHead); if (numAvailablePage != 0) {//oldHead!=availablePageTail UNSAFE.putAddress(oldHead + ZMPAGE_PREVPAGE_OFFSET, newAvailablePage); }else {//oldHead is tail UNSAFE.putAddress(oldHead, newAvailablePage); } UNSAFE.putAddress(newAvailablePage + ZMPAGE_NEXTPAGE_OFFSET, oldHead); UNSAFE.putAddress(newAvailablePage + ZMPAGE_PREVPAGE_OFFSET, addrAvailablePageHead); UNSAFE.putAddress(addrAvailablePageHead, newAvailablePage); UNSAFE.putLong(addrNumAvailablePage, numAvailablePage + 1); }
private static final void pg_AvailableChunks_push(long addressPage, long addressChunk) { //availableChunks = addressPage long head = UNSAFE.getAddress(addressPage); UNSAFE.putAddress(addressPage, addressChunk); UNSAFE.putAddress(addressChunk, head); long numAvailableChunks = addressPage+ZMPAGE_NUMAVAILABLECHUNKS_OFFSET; UNSAFE.putInt(numAvailableChunks, UNSAFE.getInt(numAvailableChunks) + 1); }
private static final void tlp_RemoteFreedChunksHead_add( long addrRemoteFreedChunksTail, long addrRemoteFreedChunk) { UNSAFE.putAddress(addrRemoteFreedChunk,NULL_ADDRESS); // UNSAFE.fullFence(); long oldTail = UNSAFE.getAndSetLong(null, addrRemoteFreedChunksTail, addrRemoteFreedChunk); UNSAFE.putAddress(oldTail, addrRemoteFreedChunk); UNSAFE.fullFence(); }
private static final void tlp_FreePages_remove(long addrFreePagesHead, long addrFreePagesTail, long addrNumFreePages, long removedFreePage) { long addrPrevFreePage = removedFreePage+ZMPAGE_PREVFREEPAGE_OFFSET; long addrNextFreePage = removedFreePage+ZMPAGE_NEXTFREEPAGE_OFFSET; long prev = UNSAFE.getAddress(addrPrevFreePage); long next = UNSAFE.getAddress(addrNextFreePage); if (prev!=addrFreePagesHead) { UNSAFE.putAddress(prev+ZMPAGE_NEXTFREEPAGE_OFFSET,next); } else {//prev is head UNSAFE.putAddress(prev,next); } if (next!=addrFreePagesTail) { UNSAFE.putAddress(next+ZMPAGE_PREVFREEPAGE_OFFSET,prev); } else {//next is tail UNSAFE.putAddress(next,prev); } UNSAFE.putLong(addrNumFreePages, UNSAFE.getLong(addrNumFreePages)-1); }
private static final long pg_AvailableChunks_pop(long addressPage) { //long availableChunks = addressPage+ZMPAGE_AVAILABLECHUNKS_OFFSET; long head = UNSAFE.getAddress(addressPage); if (head != NULL_ADDRESS) { UNSAFE.putAddress(addressPage, UNSAFE.getAddress(head)); long numAvailableChunks = addressPage+ZMPAGE_NUMAVAILABLECHUNKS_OFFSET; UNSAFE.putInt(numAvailableChunks, UNSAFE.getInt(numAvailableChunks) - 1); }//meet a full zmalloc page when head ==0L return head; }
public static void main(String[] args) throws Exception { // Reading the address of the String class long strClassAddress = normalize(UnsafeSupport.UNSAFE.getInt("", 8L)); // Reading the address of the Integer class long intClassAddress = normalize(UnsafeSupport.UNSAFE.getInt(new Integer(0), 8L)); // Write String class address as superclass to Integer class UnsafeSupport.UNSAFE.putAddress(intClassAddress + 32, strClassAddress); // Creating a new Integer object Integer intValue = new Integer(666); // Casting the Integer to it's now String superclass String value = (String) (Object) intValue; // Proof it works :) System.out.println("String (Integer) value is: " + value); Class<?> clazz = Integer.class; while (clazz != null) { System.out.println("Class: " + clazz); clazz = clazz.getSuperclass(); } }
import java.lang.reflect.Field; import sun.misc.Unsafe; public class Direct { public static void main(String... args) { Unsafe unsafe = null; try { Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe"); field.setAccessible(true); unsafe = (sun.misc.Unsafe) field.get(null); } catch (Exception e) { throw new AssertionError(e); } long value = 12345; byte size = 1; long allocateMemory = unsafe.allocateMemory(size); unsafe.putAddress(allocateMemory, value); long readValue = unsafe.getAddress(allocateMemory); System.out.println("read value : " + readValue); } }
@Override @Operation(opcode = Opcode.WRITE_POINTER) public void writeWord(WordBase offset, WordBase val) { UNSAFE.putAddress(add((Word) offset).unbox(), ((Word) val).unbox()); }
@Override @Operation(opcode = Opcode.WRITE_POINTER) public void writeWord(WordBase offset, WordBase val, LocationIdentity locationIdentity) { UNSAFE.putAddress(add((Word) offset).unbox(), ((Word) val).unbox()); }
@Override public void setName(String name, boolean destroy) throws OutOfHybridMemory, RetrieveDurableEntityError { if (destroy && null != getName()) { m_name_1B779B.destroy(); m_name_1B779B = null; m_unsafe_B1757C.putAddress(m_holder_3CE8C3.get() + 0, 0L); } if (null == name) { m_unsafe_B1757C.putLong(m_holder_3CE8C3.get() + 0, 0L); } else { m_name_1B779B = m_allocator_11A68B.createBuffer(name.length() * 2, m_autoreclaim_071A8E); if (null == m_name_1B779B) { throw new OutOfHybridMemory("Create Durable String Error!"); } m_name_1B779B.get().asCharBuffer().put(name); m_unsafe_B1757C.putLong(m_holder_3CE8C3.get() + 0, m_allocator_11A68B.getBufferHandler(m_name_1B779B)); } }
@Override public void setName(String name, boolean destroy) throws OutOfHybridMemory, RetrieveDurableEntityError { if (destroy && null != getName()) { m_name_9807CF.destroy(); m_name_9807CF = null; m_unsafe_760FBE.putAddress(m_holder_68BA57.get() + 0, 0L); } if (null == name) { m_unsafe_760FBE.putLong(m_holder_68BA57.get() + 0, 0L); } else { m_name_9807CF = m_allocator_77CA34.createBuffer(name.length() * 2, m_autoreclaim_7E4A25); if (null == m_name_9807CF) { throw new OutOfHybridMemory("Create Durable String Error!"); } m_name_9807CF.get().asCharBuffer().put(name); m_unsafe_760FBE.putLong(m_holder_68BA57.get() + 0, m_allocator_77CA34.getBufferHandler(m_name_9807CF)); } }