util/sketch/Platform.java

0001 /*
0002  * Licensed to the Apache Software Foundation (ASF) under one or more
0003  * contributor license agreements.  See the NOTICE file distributed with
0004  * this work for additional information regarding copyright ownership.
0005  * The ASF licenses this file to You under the Apache License, Version 2.0
0006  * (the "License"); you may not use this file except in compliance with
0007  * the License.  You may obtain a copy of the License at
0008  *
0009  *    http://www.apache.org/licenses/LICENSE-2.0
0010  *
0011  * Unless required by applicable law or agreed to in writing, software
0012  * distributed under the License is distributed on an "AS IS" BASIS,
0013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014  * See the License for the specific language governing permissions and
0015  * limitations under the License.
0016  */
0017
0018 package org.apache.spark.util.sketch;
0019
0020 import java.lang.reflect.Field;
0021
0022 import sun.misc.Unsafe;
0023
0024 // This class is duplicated from `org.apache.spark.unsafe.Platform` to make sure spark-sketch has no
0025 // external dependencies.
0026 final class Platform {
0027
0028   private static final Unsafe _UNSAFE;
0029
0030   public static final int BYTE_ARRAY_OFFSET;
0031
0032   public static final int INT_ARRAY_OFFSET;
0033
0034   public static final int LONG_ARRAY_OFFSET;
0035
0036   public static final int DOUBLE_ARRAY_OFFSET;
0037
0038   public static int getInt(Object object, long offset) {
0039     return _UNSAFE.getInt(object, offset);
0040   }
0041
0042   public static void putInt(Object object, long offset, int value) {
0043     _UNSAFE.putInt(object, offset, value);
0044   }
0045
0046   public static boolean getBoolean(Object object, long offset) {
0047     return _UNSAFE.getBoolean(object, offset);
0048   }
0049
0050   public static void putBoolean(Object object, long offset, boolean value) {
0051     _UNSAFE.putBoolean(object, offset, value);
0052   }
0053
0054   public static byte getByte(Object object, long offset) {
0055     return _UNSAFE.getByte(object, offset);
0056   }
0057
0058   public static void putByte(Object object, long offset, byte value) {
0059     _UNSAFE.putByte(object, offset, value);
0060   }
0061
0062   public static short getShort(Object object, long offset) {
0063     return _UNSAFE.getShort(object, offset);
0064   }
0065
0066   public static void putShort(Object object, long offset, short value) {
0067     _UNSAFE.putShort(object, offset, value);
0068   }
0069
0070   public static long getLong(Object object, long offset) {
0071     return _UNSAFE.getLong(object, offset);
0072   }
0073
0074   public static void putLong(Object object, long offset, long value) {
0075     _UNSAFE.putLong(object, offset, value);
0076   }
0077
0078   public static float getFloat(Object object, long offset) {
0079     return _UNSAFE.getFloat(object, offset);
0080   }
0081
0082   public static void putFloat(Object object, long offset, float value) {
0083     _UNSAFE.putFloat(object, offset, value);
0084   }
0085
0086   public static double getDouble(Object object, long offset) {
0087     return _UNSAFE.getDouble(object, offset);
0088   }
0089
0090   public static void putDouble(Object object, long offset, double value) {
0091     _UNSAFE.putDouble(object, offset, value);
0092   }
0093
0094   public static Object getObjectVolatile(Object object, long offset) {
0095     return _UNSAFE.getObjectVolatile(object, offset);
0096   }
0097
0098   public static void putObjectVolatile(Object object, long offset, Object value) {
0099     _UNSAFE.putObjectVolatile(object, offset, value);
0100   }
0101
0102   public static long allocateMemory(long size) {
0103     return _UNSAFE.allocateMemory(size);
0104   }
0105
0106   public static void freeMemory(long address) {
0107     _UNSAFE.freeMemory(address);
0108   }
0109
0110   public static void copyMemory(
0111     Object src, long srcOffset, Object dst, long dstOffset, long length) {
0112     // Check if dstOffset is before or after srcOffset to determine if we should copy
0113     // forward or backwards. This is necessary in case src and dst overlap.
0114     if (dstOffset < srcOffset) {
0115       while (length > 0) {
0116         long size = Math.min(length, UNSAFE_COPY_THRESHOLD);
0117         _UNSAFE.copyMemory(src, srcOffset, dst, dstOffset, size);
0118         length -= size;
0119         srcOffset += size;
0120         dstOffset += size;
0121       }
0122     } else {
0123       srcOffset += length;
0124       dstOffset += length;
0125       while (length > 0) {
0126         long size = Math.min(length, UNSAFE_COPY_THRESHOLD);
0127         srcOffset -= size;
0128         dstOffset -= size;
0129         _UNSAFE.copyMemory(src, srcOffset, dst, dstOffset, size);
0130         length -= size;
0131       }
0132
0133     }
0134   }
0135
0136   /**
0137    * Raises an exception bypassing compiler checks for checked exceptions.
0138    */
0139   public static void throwException(Throwable t) {
0140     _UNSAFE.throwException(t);
0141   }
0142
0143   /**
0144    * Limits the number of bytes to copy per {@link Unsafe#copyMemory(long, long, long)} to
0145    * allow safepoint polling during a large copy.
0146    */
0147   private static final long UNSAFE_COPY_THRESHOLD = 1024L * 1024L;
0148
0149   static {
0150     sun.misc.Unsafe unsafe;
0151     try {
0152       Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
0153       unsafeField.setAccessible(true);
0154       unsafe = (sun.misc.Unsafe) unsafeField.get(null);
0155     } catch (Throwable cause) {
0156       unsafe = null;
0157     }
0158     _UNSAFE = unsafe;
0159
0160     if (_UNSAFE != null) {
0161       BYTE_ARRAY_OFFSET = _UNSAFE.arrayBaseOffset(byte[].class);
0162       INT_ARRAY_OFFSET = _UNSAFE.arrayBaseOffset(int[].class);
0163       LONG_ARRAY_OFFSET = _UNSAFE.arrayBaseOffset(long[].class);
0164       DOUBLE_ARRAY_OFFSET = _UNSAFE.arrayBaseOffset(double[].class);
0165     } else {
0166       BYTE_ARRAY_OFFSET = 0;
0167       INT_ARRAY_OFFSET = 0;
0168       LONG_ARRAY_OFFSET = 0;
0169       DOUBLE_ARRAY_OFFSET = 0;
0170     }
0171   }
0172 }