| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more contributor license |
| * agreements. See the NOTICE file distributed with this work for additional information regarding |
| * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance with the License. You may obtain a |
| * copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License |
| * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
| * or implied. See the License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| package org.apache.geode.unsafe.internal.sun.misc; |
| |
| import java.lang.reflect.Field; |
| |
| /** |
| * This class wraps the sun.misc.Unsafe class which is only available on Sun JVMs. It is also |
| * available on other JVMs (like IBM). |
| * |
| * |
| */ |
| public class Unsafe { |
| |
| private final sun.misc.Unsafe unsafe; |
| { |
| sun.misc.Unsafe tmp; |
| try { |
| Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe"); |
| field.setAccessible(true); |
| tmp = (sun.misc.Unsafe) field.get(null); |
| } catch (Exception e) { |
| throw new AssertionError(e); |
| } |
| unsafe = tmp; |
| } |
| |
| public long objectFieldOffset(Field f) { |
| return unsafe.objectFieldOffset(f); |
| } |
| |
| public int getInt(Object o, long offset) { |
| return unsafe.getInt(o, offset); |
| } |
| |
| public int getIntVolatile(Object o, long offset) { |
| return unsafe.getIntVolatile(o, offset); |
| } |
| |
| /** |
| * Returns 4 if this is a 32bit jvm; otherwise 8. Note it does not account for compressed oops. |
| */ |
| public int getAddressSize() { |
| return unsafe.addressSize(); |
| } |
| |
| public void putInt(Object o, long offset, int v) { |
| unsafe.putInt(o, offset, v); |
| } |
| |
| public void putIntVolatile(Object o, long offset, int v) { |
| unsafe.putIntVolatile(o, offset, v); |
| } |
| |
| public boolean compareAndSwapInt(Object o, long offset, int expected, int v) { |
| return unsafe.compareAndSwapInt(o, offset, expected, v); |
| } |
| |
| public boolean getBoolean(Object o, long offset) { |
| return unsafe.getBoolean(o, offset); |
| } |
| |
| public void putBoolean(Object o, long offset, boolean v) { |
| unsafe.putBoolean(o, offset, v); |
| } |
| |
| public byte getByte(Object o, long offset) { |
| return unsafe.getByte(o, offset); |
| } |
| |
| public void putByte(Object o, long offset, byte v) { |
| unsafe.putByte(o, offset, v); |
| } |
| |
| public short getShort(Object o, long offset) { |
| return unsafe.getShort(o, offset); |
| } |
| |
| public void putShort(Object o, long offset, short v) { |
| unsafe.putShort(o, offset, v); |
| } |
| |
| public char getChar(Object o, long offset) { |
| return unsafe.getChar(o, offset); |
| } |
| |
| public void putChar(Object o, long offset, char v) { |
| unsafe.putChar(o, offset, v); |
| } |
| |
| public long getLong(Object o, long offset) { |
| return unsafe.getLong(o, offset); |
| } |
| |
| public long getLongVolatile(Object o, long offset) { |
| return unsafe.getLongVolatile(o, offset); |
| } |
| |
| public void putLong(Object o, long offset, long v) { |
| unsafe.putLong(o, offset, v); |
| } |
| |
| public void putLongVolatile(Object o, long offset, long v) { |
| unsafe.putLongVolatile(o, offset, v); |
| } |
| |
| public boolean compareAndSwapLong(Object o, long offset, long expected, long v) { |
| return unsafe.compareAndSwapLong(o, offset, expected, v); |
| } |
| |
| public float getFloat(Object o, long offset) { |
| return unsafe.getFloat(o, offset); |
| } |
| |
| public void putFloat(Object o, long offset, float v) { |
| unsafe.putFloat(o, offset, v); |
| } |
| |
| public double getDouble(Object o, long offset) { |
| return unsafe.getDouble(o, offset); |
| } |
| |
| public void putDouble(Object o, long offset, double v) { |
| unsafe.putDouble(o, offset, v); |
| } |
| |
| public Object getObject(Object o, long offset) { |
| return unsafe.getObject(o, offset); |
| } |
| |
| public void putObject(Object o, long offset, Object v) { |
| unsafe.putObject(o, offset, v); |
| } |
| |
| public Object allocateInstance(Class<?> c) throws InstantiationException { |
| return unsafe.allocateInstance(c); |
| } |
| |
| public long allocateMemory(long size) { |
| return unsafe.allocateMemory(size); |
| } |
| |
| public byte getByte(long addr) { |
| return unsafe.getByte(addr); |
| } |
| |
| public void putByte(long addr, byte value) { |
| unsafe.putByte(addr, value); |
| } |
| |
| |
| |
| public void copyMemory(Object o1, long addr1, Object o2, long addr2, long size) { |
| unsafe.copyMemory(o1, addr1, o2, addr2, size); |
| } |
| |
| public void copyMemory(long src, long dst, long size) { |
| unsafe.copyMemory(src, dst, size); |
| } |
| |
| public void freeMemory(long addr) { |
| unsafe.freeMemory(addr); |
| } |
| |
| public int arrayBaseOffset(Class c) { |
| return unsafe.arrayBaseOffset(c); |
| } |
| |
| public int arrayScaleIndex(Class c) { |
| return unsafe.arrayIndexScale(c); |
| } |
| |
| public long fieldOffset(Field f) { |
| return unsafe.objectFieldOffset(f); |
| } |
| |
| public int getPageSize() { |
| return unsafe.pageSize(); |
| } |
| |
| public void setMemory(long addr, long size, byte v) { |
| unsafe.setMemory(addr, size, v); |
| } |
| |
| public int arrayIndexScale(Class<?> arrayClass) { |
| return unsafe.arrayIndexScale(arrayClass); |
| } |
| |
| public Object getObjectVolatile(Object o, long offset) { |
| return unsafe.getObjectVolatile(o, offset); |
| } |
| |
| public boolean compareAndSwapObject(Object o, long offset, Object expected, Object x) { |
| return unsafe.compareAndSwapObject(o, offset, expected, x); |
| } |
| |
| public void putOrderedObject(Object o, long offset, Object x) { |
| unsafe.putOrderedObject(o, offset, x); |
| } |
| } |