Class PlatformDependent


  • public final class PlatformDependent
    extends java.lang.Object
    Utility that detects various properties specific to the current runtime environment, such as Java version and the availability of the sun.misc.Unsafe object.

    You can disable the use of sun.misc.Unsafe if you specify the system property io.netty.noUnsafe.

    • Field Detail

      • MAX_DIRECT_MEMORY_SIZE_ARG_PATTERN

        private static final java.util.regex.Pattern MAX_DIRECT_MEMORY_SIZE_ARG_PATTERN
      • MAYBE_SUPER_USER

        private static final boolean MAYBE_SUPER_USER
      • CAN_ENABLE_TCP_NODELAY_BY_DEFAULT

        private static final boolean CAN_ENABLE_TCP_NODELAY_BY_DEFAULT
      • UNSAFE_UNAVAILABILITY_CAUSE

        private static final java.lang.Throwable UNSAFE_UNAVAILABILITY_CAUSE
      • DIRECT_BUFFER_PREFERRED

        private static final boolean DIRECT_BUFFER_PREFERRED
      • MAX_DIRECT_MEMORY

        private static final long MAX_DIRECT_MEMORY
      • MAX_ALLOWED_MPSC_CAPACITY

        private static final int MAX_ALLOWED_MPSC_CAPACITY
        See Also:
        Constant Field Values
      • BYTE_ARRAY_BASE_OFFSET

        private static final long BYTE_ARRAY_BASE_OFFSET
      • TMPDIR

        private static final java.io.File TMPDIR
      • BIT_MODE

        private static final int BIT_MODE
      • NORMALIZED_ARCH

        private static final java.lang.String NORMALIZED_ARCH
      • NORMALIZED_OS

        private static final java.lang.String NORMALIZED_OS
      • ALLOWED_LINUX_OS_CLASSIFIERS

        private static final java.lang.String[] ALLOWED_LINUX_OS_CLASSIFIERS
      • LINUX_OS_CLASSIFIERS

        private static final java.util.Set<java.lang.String> LINUX_OS_CLASSIFIERS
      • IS_WINDOWS

        private static final boolean IS_WINDOWS
      • IS_OSX

        private static final boolean IS_OSX
      • IS_J9_JVM

        private static final boolean IS_J9_JVM
      • IS_IVKVM_DOT_NET

        private static final boolean IS_IVKVM_DOT_NET
      • ADDRESS_SIZE

        private static final int ADDRESS_SIZE
      • USE_DIRECT_BUFFER_NO_CLEANER

        private static final boolean USE_DIRECT_BUFFER_NO_CLEANER
      • DIRECT_MEMORY_COUNTER

        private static final java.util.concurrent.atomic.AtomicLong DIRECT_MEMORY_COUNTER
      • DIRECT_MEMORY_LIMIT

        private static final long DIRECT_MEMORY_LIMIT
      • CLEANER

        private static final Cleaner CLEANER
      • UNINITIALIZED_ARRAY_ALLOCATION_THRESHOLD

        private static final int UNINITIALIZED_ARRAY_ALLOCATION_THRESHOLD
      • OS_RELEASE_FILES

        private static final java.lang.String[] OS_RELEASE_FILES
      • LINUX_ID_LIKE_PREFIX

        private static final java.lang.String LINUX_ID_LIKE_PREFIX
        See Also:
        Constant Field Values
      • BIG_ENDIAN_NATIVE_ORDER

        public static final boolean BIG_ENDIAN_NATIVE_ORDER
      • NOOP

        private static final Cleaner NOOP
    • Constructor Detail

      • PlatformDependent

        private PlatformDependent()
    • Method Detail

      • addFilesystemOsClassifiers

        static void addFilesystemOsClassifiers​(java.util.Set<java.lang.String> allowedClassifiers,
                                               java.util.Set<java.lang.String> availableClassifiers)
      • addPropertyOsClassifiers

        static boolean addPropertyOsClassifiers​(java.util.Set<java.lang.String> allowedClassifiers,
                                                java.util.Set<java.lang.String> availableClassifiers)
      • byteArrayBaseOffset

        public static long byteArrayBaseOffset()
      • hasDirectBufferNoCleanerConstructor

        public static boolean hasDirectBufferNoCleanerConstructor()
      • allocateUninitializedArray

        public static byte[] allocateUninitializedArray​(int size)
      • isAndroid

        public static boolean isAndroid()
        Returns true if and only if the current platform is Android
      • isWindows

        public static boolean isWindows()
        Return true if the JVM is running on Windows
      • isOsx

        public static boolean isOsx()
        Return true if the JVM is running on OSX / MacOS
      • maybeSuperUser

        public static boolean maybeSuperUser()
        Return true if the current user may be a super-user. Be aware that this is just an hint and so it may return false-positives.
      • javaVersion

        public static int javaVersion()
        Return the version of Java under which this library is used.
      • canEnableTcpNoDelayByDefault

        public static boolean canEnableTcpNoDelayByDefault()
        Returns true if and only if it is fine to enable TCP_NODELAY socket option by default.
      • hasUnsafe

        public static boolean hasUnsafe()
        Return true if sun.misc.Unsafe was found on the classpath and can be used for accelerated direct memory access.
      • getUnsafeUnavailabilityCause

        public static java.lang.Throwable getUnsafeUnavailabilityCause()
        Return the reason (if any) why sun.misc.Unsafe was not available.
      • isUnaligned

        public static boolean isUnaligned()
        true if and only if the platform supports unaligned access.
        See Also:
        Wikipedia on segfault
      • directBufferPreferred

        public static boolean directBufferPreferred()
        Returns true if the platform has reliable low-level direct buffer access API and a user has not specified -Dio.netty.noPreferDirect option.
      • maxDirectMemory

        public static long maxDirectMemory()
        Returns the maximum memory reserved for direct buffer allocation.
      • usedDirectMemory

        public static long usedDirectMemory()
        Returns the current memory reserved for direct buffer allocation. This method returns -1 in case that a value is not available.
        See Also:
        maxDirectMemory()
      • tmpdir

        public static java.io.File tmpdir()
        Returns the temporary directory.
      • bitMode

        public static int bitMode()
        Returns the bit mode of the current VM (usually 32 or 64.)
      • addressSize

        public static int addressSize()
        Return the address size of the OS. 4 (for 32 bits systems ) and 8 (for 64 bits systems).
      • allocateMemory

        public static long allocateMemory​(long size)
      • freeMemory

        public static void freeMemory​(long address)
      • reallocateMemory

        public static long reallocateMemory​(long address,
                                            long newSize)
      • throwException

        public static void throwException​(java.lang.Throwable t)
        Raises an exception bypassing compiler checks for checked exceptions.
      • throwException0

        private static <E extends java.lang.Throwable> void throwException0​(java.lang.Throwable t)
                                                                     throws E extends java.lang.Throwable
        Throws:
        E extends java.lang.Throwable
      • newConcurrentHashMap

        public static <K,​V> java.util.concurrent.ConcurrentMap<K,​V> newConcurrentHashMap()
        Creates a new fastest ConcurrentMap implementation for the current platform.
      • newLongCounter

        public static LongCounter newLongCounter()
        Creates a new fastest LongCounter implementation for the current platform.
      • newConcurrentHashMap

        public static <K,​V> java.util.concurrent.ConcurrentMap<K,​V> newConcurrentHashMap​(int initialCapacity)
        Creates a new fastest ConcurrentMap implementation for the current platform.
      • newConcurrentHashMap

        public static <K,​V> java.util.concurrent.ConcurrentMap<K,​V> newConcurrentHashMap​(int initialCapacity,
                                                                                                     float loadFactor)
        Creates a new fastest ConcurrentMap implementation for the current platform.
      • newConcurrentHashMap

        public static <K,​V> java.util.concurrent.ConcurrentMap<K,​V> newConcurrentHashMap​(int initialCapacity,
                                                                                                     float loadFactor,
                                                                                                     int concurrencyLevel)
        Creates a new fastest ConcurrentMap implementation for the current platform.
      • newConcurrentHashMap

        public static <K,​V> java.util.concurrent.ConcurrentMap<K,​V> newConcurrentHashMap​(java.util.Map<? extends K,​? extends V> map)
        Creates a new fastest ConcurrentMap implementation for the current platform.
      • freeDirectBuffer

        public static void freeDirectBuffer​(java.nio.ByteBuffer buffer)
        Try to deallocate the specified direct ByteBuffer. Please note this method does nothing if the current platform does not support this operation or the specified buffer is not a direct buffer.
      • directBufferAddress

        public static long directBufferAddress​(java.nio.ByteBuffer buffer)
      • directBuffer

        public static java.nio.ByteBuffer directBuffer​(long memoryAddress,
                                                       int size)
      • getObject

        public static java.lang.Object getObject​(java.lang.Object object,
                                                 long fieldOffset)
      • getInt

        public static int getInt​(java.lang.Object object,
                                 long fieldOffset)
      • safeConstructPutInt

        static void safeConstructPutInt​(java.lang.Object object,
                                        long fieldOffset,
                                        int value)
      • getIntVolatile

        public static int getIntVolatile​(long address)
      • putIntOrdered

        public static void putIntOrdered​(long adddress,
                                         int newValue)
      • getByte

        public static byte getByte​(long address)
      • getShort

        public static short getShort​(long address)
      • getInt

        public static int getInt​(long address)
      • getLong

        public static long getLong​(long address)
      • getByte

        public static byte getByte​(byte[] data,
                                   int index)
      • getByte

        public static byte getByte​(byte[] data,
                                   long index)
      • getShort

        public static short getShort​(byte[] data,
                                     int index)
      • getInt

        public static int getInt​(byte[] data,
                                 int index)
      • getInt

        public static int getInt​(int[] data,
                                 long index)
      • getLong

        public static long getLong​(byte[] data,
                                   int index)
      • getLong

        public static long getLong​(long[] data,
                                   long index)
      • getLongSafe

        private static long getLongSafe​(byte[] bytes,
                                        int offset)
      • getIntSafe

        private static int getIntSafe​(byte[] bytes,
                                      int offset)
      • getShortSafe

        private static short getShortSafe​(byte[] bytes,
                                          int offset)
      • putByte

        public static void putByte​(long address,
                                   byte value)
      • putShort

        public static void putShort​(long address,
                                    short value)
      • putInt

        public static void putInt​(long address,
                                  int value)
      • putLong

        public static void putLong​(long address,
                                   long value)
      • putByte

        public static void putByte​(byte[] data,
                                   int index,
                                   byte value)
      • putByte

        public static void putByte​(java.lang.Object data,
                                   long offset,
                                   byte value)
      • putShort

        public static void putShort​(byte[] data,
                                    int index,
                                    short value)
      • putInt

        public static void putInt​(byte[] data,
                                  int index,
                                  int value)
      • putLong

        public static void putLong​(byte[] data,
                                   int index,
                                   long value)
      • putObject

        public static void putObject​(java.lang.Object o,
                                     long offset,
                                     java.lang.Object x)
      • objectFieldOffset

        public static long objectFieldOffset​(java.lang.reflect.Field field)
      • copyMemory

        public static void copyMemory​(long srcAddr,
                                      long dstAddr,
                                      long length)
      • copyMemory

        public static void copyMemory​(byte[] src,
                                      int srcIndex,
                                      long dstAddr,
                                      long length)
      • copyMemory

        public static void copyMemory​(byte[] src,
                                      int srcIndex,
                                      byte[] dst,
                                      int dstIndex,
                                      long length)
      • copyMemory

        public static void copyMemory​(long srcAddr,
                                      byte[] dst,
                                      int dstIndex,
                                      long length)
      • setMemory

        public static void setMemory​(byte[] dst,
                                     int dstIndex,
                                     long bytes,
                                     byte value)
      • setMemory

        public static void setMemory​(long address,
                                     long bytes,
                                     byte value)
      • allocateDirectNoCleaner

        public static java.nio.ByteBuffer allocateDirectNoCleaner​(int capacity)
        Allocate a new ByteBuffer with the given capacity. ByteBuffers allocated with this method MUST be deallocated via freeDirectNoCleaner(ByteBuffer).
      • reallocateDirectNoCleaner

        public static java.nio.ByteBuffer reallocateDirectNoCleaner​(java.nio.ByteBuffer buffer,
                                                                    int capacity)
        Reallocate a new ByteBuffer with the given capacity. ByteBuffers reallocated with this method MUST be deallocated via freeDirectNoCleaner(ByteBuffer).
      • freeDirectNoCleaner

        public static void freeDirectNoCleaner​(java.nio.ByteBuffer buffer)
        This method MUST only be called for ByteBuffers that were allocated via allocateDirectNoCleaner(int).
      • hasAlignDirectByteBuffer

        public static boolean hasAlignDirectByteBuffer()
      • alignDirectBuffer

        public static java.nio.ByteBuffer alignDirectBuffer​(java.nio.ByteBuffer buffer,
                                                            int alignment)
      • align

        public static long align​(long value,
                                 int alignment)
      • incrementMemoryCounter

        private static void incrementMemoryCounter​(int capacity)
      • decrementMemoryCounter

        private static void decrementMemoryCounter​(int capacity)
      • useDirectBufferNoCleaner

        public static boolean useDirectBufferNoCleaner()
      • equals

        public static boolean equals​(byte[] bytes1,
                                     int startPos1,
                                     byte[] bytes2,
                                     int startPos2,
                                     int length)
        Compare two byte arrays for equality. For performance reasons no bounds checking on the parameters is performed.
        Parameters:
        bytes1 - the first byte array.
        startPos1 - the position (inclusive) to start comparing in bytes1.
        bytes2 - the second byte array.
        startPos2 - the position (inclusive) to start comparing in bytes2.
        length - the amount of bytes to compare. This is assumed to be validated as not going out of bounds by the caller.
      • isZero

        public static boolean isZero​(byte[] bytes,
                                     int startPos,
                                     int length)
        Determine if a subsection of an array is zero.
        Parameters:
        bytes - The byte array.
        startPos - The starting index (inclusive) in bytes.
        length - The amount of bytes to check for zero.
        Returns:
        false if bytes[startPos:startsPos+length) contains a value other than zero.
      • equalsConstantTime

        public static int equalsConstantTime​(byte[] bytes1,
                                             int startPos1,
                                             byte[] bytes2,
                                             int startPos2,
                                             int length)
        Compare two byte arrays for equality without leaking timing information. For performance reasons no bounds checking on the parameters is performed.

        The int return type is intentional and is designed to allow cascading of constant time operations:

             byte[] s1 = new {1, 2, 3};
             byte[] s2 = new {1, 2, 3};
             byte[] s3 = new {1, 2, 3};
             byte[] s4 = new {4, 5, 6};
             boolean equals = (equalsConstantTime(s1, 0, s2, 0, s1.length) &
                               equalsConstantTime(s3, 0, s4, 0, s3.length)) != 0;
         
        Parameters:
        bytes1 - the first byte array.
        startPos1 - the position (inclusive) to start comparing in bytes1.
        bytes2 - the second byte array.
        startPos2 - the position (inclusive) to start comparing in bytes2.
        length - the amount of bytes to compare. This is assumed to be validated as not going out of bounds by the caller.
        Returns:
        0 if not equal. 1 if equal.
      • hashCodeAscii

        public static int hashCodeAscii​(byte[] bytes,
                                        int startPos,
                                        int length)
        Calculate a hash code of a byte array assuming ASCII character encoding. The resulting hash code will be case insensitive.
        Parameters:
        bytes - The array which contains the data to hash.
        startPos - What index to start generating a hash code in bytes
        length - The amount of bytes that should be accounted for in the computation.
        Returns:
        The hash code of bytes assuming ASCII character encoding. The resulting hash code will be case insensitive.
      • hashCodeAscii

        public static int hashCodeAscii​(java.lang.CharSequence bytes)
        Calculate a hash code of a byte array assuming ASCII character encoding. The resulting hash code will be case insensitive.

        This method assumes that bytes is equivalent to a byte[] but just using CharSequence for storage. The upper most byte of each char from bytes is ignored.

        Parameters:
        bytes - The array which contains the data to hash (assumed to be equivalent to a byte[]).
        Returns:
        The hash code of bytes assuming ASCII character encoding. The resulting hash code will be case insensitive.
      • newMpscQueue

        public static <T> java.util.Queue<T> newMpscQueue()
        Create a new Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!).
        Returns:
        A MPSC queue which may be unbounded.
      • newMpscQueue

        public static <T> java.util.Queue<T> newMpscQueue​(int maxCapacity)
        Create a new Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!).
      • newMpscQueue

        public static <T> java.util.Queue<T> newMpscQueue​(int chunkSize,
                                                          int maxCapacity)
        Create a new Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!). The queue will grow and shrink its capacity in units of the given chunk size.
      • newSpscQueue

        public static <T> java.util.Queue<T> newSpscQueue()
        Create a new Queue which is safe to use for single producer (one thread!) and a single consumer (one thread!).
      • newFixedMpscQueue

        public static <T> java.util.Queue<T> newFixedMpscQueue​(int capacity)
        Create a new Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!) with the given fixes capacity.
      • getClassLoader

        public static java.lang.ClassLoader getClassLoader​(java.lang.Class<?> clazz)
        Return the ClassLoader for the given Class.
      • getContextClassLoader

        public static java.lang.ClassLoader getContextClassLoader()
        Return the context ClassLoader for the current Thread.
      • getSystemClassLoader

        public static java.lang.ClassLoader getSystemClassLoader()
        Return the system ClassLoader.
      • newConcurrentDeque

        public static <C> java.util.Deque<C> newConcurrentDeque()
        Returns a new concurrent Deque.
      • threadLocalRandom

        public static java.util.Random threadLocalRandom()
        Return a Random which is not-threadsafe and so can only be used from the same thread.
      • isWindows0

        private static boolean isWindows0()
      • isOsx0

        private static boolean isOsx0()
      • maybeSuperUser0

        private static boolean maybeSuperUser0()
      • unsafeUnavailabilityCause0

        private static java.lang.Throwable unsafeUnavailabilityCause0()
      • isJ9Jvm

        public static boolean isJ9Jvm()
        Returns true if the running JVM is either IBM J9 or Eclipse OpenJ9, false otherwise.
      • isJ9Jvm0

        private static boolean isJ9Jvm0()
      • isIkvmDotNet

        public static boolean isIkvmDotNet()
        Returns true if the running JVM is IKVM.NET, false otherwise.
      • isIkvmDotNet0

        private static boolean isIkvmDotNet0()
      • estimateMaxDirectMemory

        public static long estimateMaxDirectMemory()
        Compute an estimate of the maximum amount of direct memory available to this JVM.

        The computation is not cached, so you probably want to use maxDirectMemory() instead.

        This will produce debug log output when called.

        Returns:
        The estimated max direct memory, in bytes.
      • tmpdir0

        private static java.io.File tmpdir0()
      • toDirectory

        private static java.io.File toDirectory​(java.lang.String path)
      • bitMode0

        private static int bitMode0()
      • addressSize0

        private static int addressSize0()
      • byteArrayBaseOffset0

        private static long byteArrayBaseOffset0()
      • equalsSafe

        private static boolean equalsSafe​(byte[] bytes1,
                                          int startPos1,
                                          byte[] bytes2,
                                          int startPos2,
                                          int length)
      • isZeroSafe

        private static boolean isZeroSafe​(byte[] bytes,
                                          int startPos,
                                          int length)
      • hashCodeAsciiSafe

        static int hashCodeAsciiSafe​(byte[] bytes,
                                     int startPos,
                                     int length)
        Package private for testing purposes only!
      • normalizedArch

        public static java.lang.String normalizedArch()
      • normalizedOs

        public static java.lang.String normalizedOs()
      • normalizedLinuxClassifiers

        public static java.util.Set<java.lang.String> normalizedLinuxClassifiers()
      • createTempFile

        public static java.io.File createTempFile​(java.lang.String prefix,
                                                  java.lang.String suffix,
                                                  java.io.File directory)
                                           throws java.io.IOException
        Throws:
        java.io.IOException
      • addClassifier

        private static void addClassifier​(java.util.Set<java.lang.String> allowed,
                                          java.util.Set<java.lang.String> dest,
                                          java.lang.String... maybeClassifiers)
        Adds only those classifier strings to dest which are present in allowed.
        Parameters:
        allowed - allowed classifiers
        dest - destination set
        maybeClassifiers - potential classifiers to add
      • normalizeOsReleaseVariableValue

        private static java.lang.String normalizeOsReleaseVariableValue​(java.lang.String value)
      • normalize

        private static java.lang.String normalize​(java.lang.String value)
      • normalizeArch

        private static java.lang.String normalizeArch​(java.lang.String value)
      • normalizeOs

        private static java.lang.String normalizeOs​(java.lang.String value)