java.lang.Object
- io.netty.util.internal.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.

Nested Class Summary

Nested Classes
Modifier and Type Class Description

private static class PlatformDependent.Mpsc

Field Summary

Fields
Modifier and Type	Field	Description
`private static int`	`ADDRESS_SIZE`
`static boolean`	`BIG_ENDIAN_NATIVE_ORDER`
`private static int`	`BIT_MODE`
`private static long`	`BYTE_ARRAY_BASE_OFFSET`
`private static boolean`	`CAN_ENABLE_TCP_NODELAY_BY_DEFAULT`
`private static Cleaner`	`CLEANER`
`private static boolean`	`DIRECT_BUFFER_PREFERRED`
`private static java.util.concurrent.atomic.AtomicLong`	`DIRECT_MEMORY_COUNTER`
`private static long`	`DIRECT_MEMORY_LIMIT`
`private static boolean`	`EXPLICIT_NO_PREFER_DIRECT`
`private static boolean`	`HAS_ALLOCATE_UNINIT_ARRAY`
`private static boolean`	`IGNORE_EXPENSIVE_CLEAN`
`private static boolean`	`IS_IVKVM_DOT_NET`
`private static boolean`	`IS_J9_JVM`
`private static boolean`	`IS_OSX`
`private static boolean`	`IS_WINDOWS`
`private static boolean`	`JFR`
`private static Cleaner`	`LEGACY_CLEANER`
`private static java.lang.String`	`LINUX_ID_LIKE_PREFIX`
`private static java.lang.String`	`LINUX_ID_PREFIX`
`private static java.util.Set<java.lang.String>`	`LINUX_OS_CLASSIFIERS`
`private static InternalLogger`	`logger`
`private static int`	`MAX_ALLOWED_MPSC_CAPACITY`
`private static long`	`MAX_DIRECT_MEMORY`
`private static java.util.regex.Pattern`	`MAX_DIRECT_MEMORY_SIZE_ARG_PATTERN`
`private static boolean`	`MAYBE_SUPER_USER`
`private static int`	`MIN_MAX_MPSC_CAPACITY`
`private static int`	`MPSC_CHUNK_SIZE`
`private static Cleaner`	`NOOP`
`private static java.lang.String`	`NORMALIZED_ARCH`
`private static java.lang.String`	`NORMALIZED_OS`
`private static java.io.File`	`TMPDIR`
`private static java.lang.Throwable`	`UNSAFE_UNAVAILABILITY_CAUSE`
`private static boolean`	`VAR_HANDLE`

Constructor Summary

Constructors
Modifier Constructor Description

private PlatformDependent()

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`static java.nio.ByteBuffer`	`absolutePut(java.nio.ByteBuffer dst, int dstOffset, byte[] src, int srcOffset, int length)`
`static java.nio.ByteBuffer`	`absolutePut(java.nio.ByteBuffer dst, int dstOffset, java.nio.ByteBuffer src, int srcOffset, int length)`
`private static void`	`addClassifier(java.util.Set<java.lang.String> dest, java.lang.String... maybeClassifiers)`	Adds only those classifier strings to `dest` which are present in `allowed`.
`(package private) static void`	`addFilesystemOsClassifiers(java.util.Set<java.lang.String> availableClassifiers)`
`(package private) static boolean`	`addPropertyOsClassifiers(java.util.Set<java.lang.String> availableClassifiers)`
`static int`	`addressSize()`	Return the address size of the OS.
`private static int`	`addressSize0()`
`static long`	`align(long value, int alignment)`
`static java.nio.ByteBuffer`	`alignDirectBuffer(java.nio.ByteBuffer buffer, int alignment)`
`static CleanableDirectBuffer`	`allocateDirect(int capacity)`	Allocate a direct `ByteBuffer` of the given capacity, and return it alongside its deallocation mechanism.
`static CleanableDirectBuffer`	`allocateDirect(int capacity, boolean permitExpensiveClean)`	Allocate a direct `ByteBuffer` of the given capacity, and return it alongside its deallocation mechanism.
`static long`	`allocateMemory(long size)`
`static byte[]`	`allocateUninitializedArray(int size)`
`static int`	`bitMode()`	Returns the bit mode of the current VM (usually 32 or 64.)
`private static int`	`bitMode0()`
`static long`	`byteArrayBaseOffset()`
`private static long`	`byteArrayBaseOffset0()`
`static boolean`	`canEnableTcpNoDelayByDefault()`	Returns `true` if and only if it is fine to enable TCP_NODELAY socket option by default.
`static boolean`	`canReliabilyFreeDirectBuffers()`	Return `true` if the selected cleaner can free direct buffers in a controlled way.
`static boolean`	`canUnalignedAccess()`	`true` if multi-byte access at arbitrary offsets is possible, either natively through `Unsafe` or via `VarHandle` where the JVM handles alignment and byte ordering internally.
`static boolean`	`compareAndSwapInt(java.lang.Object object, long fieldOffset, int expected, int value)`
`static void`	`copyMemory(byte[] src, int srcIndex, byte[] dst, int dstIndex, long length)`
`static void`	`copyMemory(byte[] src, int srcIndex, long dstAddr, long length)`
`static void`	`copyMemory(long srcAddr, byte[] dst, int dstIndex, long length)`
`static void`	`copyMemory(long srcAddr, long dstAddr, long length)`
`static java.io.File`	`createTempFile(java.lang.String prefix, java.lang.String suffix, java.io.File directory)`
`(package private) static void`	`decrementMemoryCounter(int capacity)`
`static java.nio.ByteBuffer`	`directBuffer(long memoryAddress, int size)`
`static long`	`directBufferAddress(java.nio.ByteBuffer buffer)`	Obtain the native memory address of the given direct byte buffer, or throw an exception if it's not possible.
`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.
`static boolean`	`equals(byte[] bytes1, int startPos1, byte[] bytes2, int startPos2, int length)`	Compare two `byte` arrays for equality.
`static int`	`equalsConstantTime(byte[] bytes1, int startPos1, byte[] bytes2, int startPos2, int length)`	Compare two `byte` arrays for equality without leaking timing information.
`private static boolean`	`equalsSafe(byte[] bytes1, int startPos1, byte[] bytes2, int startPos2, int length)`
`static long`	`estimateMaxDirectMemory()`	Compute an estimate of the maximum amount of direct memory available to this JVM.
`static VarHandle`	`findVarHandleOfIntField(java.lang.invoke.MethodHandles.Lookup lookup, java.lang.Class<?> type, java.lang.String fieldName)`
`static void`	`freeDirectBuffer(java.nio.ByteBuffer buffer)`	Deprecated. Use the `CleanableDirectBuffer.clean()` from `allocateDirect(int)` instead.
`static void`	`freeMemory(long address)`
`static int`	`getAndAddInt(java.lang.Object object, long fieldOffset, int delta)`
`static byte`	`getByte(byte[] data, int index)`
`static byte`	`getByte(byte[] data, long index)`
`static byte`	`getByte(long address)`
`static java.lang.ClassLoader`	`getClassLoader(java.lang.Class<?> clazz)`	Return the `ClassLoader` for the given `Class`.
`static java.lang.ClassLoader`	`getContextClassLoader()`	Return the context `ClassLoader` for the current `Thread`.
`static int`	`getInt(byte[] data, int index)`
`static int`	`getInt(int[] data, long index)`
`static int`	`getInt(long address)`
`static int`	`getInt(java.lang.Object object, long fieldOffset)`
`private static int`	`getIntSafe(byte[] bytes, int offset)`
`static long`	`getLong(byte[] data, int index)`
`static long`	`getLong(long address)`
`static long`	`getLong(long[] data, long index)`
`private static long`	`getLongSafe(byte[] bytes, int offset)`
`private static java.util.regex.Pattern`	`getMaxDirectMemorySizeArgPattern()`
`static java.lang.Object`	`getObject(java.lang.Object object, long fieldOffset)`
`static short`	`getShort(byte[] data, int index)`
`static short`	`getShort(long address)`
`private static short`	`getShortSafe(byte[] bytes, int offset)`
`static java.lang.ClassLoader`	`getSystemClassLoader()`	Return the system `ClassLoader`.
`static java.lang.Throwable`	`getUnsafeUnavailabilityCause()`	Return the reason (if any) why `sun.misc.Unsafe` was not available.
`static int`	`getVolatileInt(java.lang.Object object, long fieldOffset)`
`static boolean`	`hasAlignDirectByteBuffer()`
`static boolean`	`hasDirectBufferNoCleanerConstructor()`
`static boolean`	`hasDirectByteBufferAddress(java.nio.ByteBuffer buffer)`	Check if it is possible to call `directBufferAddress(ByteBuffer)` on the given buffer.
`static int`	`hashCodeAscii(byte[] bytes, int startPos, int length)`	Calculate a hash code of a byte array assuming ASCII character encoding.
`static int`	`hashCodeAscii(java.lang.CharSequence bytes)`	Calculate a hash code of a byte array assuming ASCII character encoding.
`private static int`	`hashCodeAsciiCompute(java.lang.CharSequence value, int offset, int hash)`	Identical to `PlatformDependent0.hashCodeAsciiCompute(long, int)` but for `CharSequence`.
`(package private) static int`	`hashCodeAsciiSafe(byte[] bytes, int startPos, int length)`	Package private for testing purposes only!
`private static int`	`hashCodeAsciiSanitizeByte(char value)`	Identical to `PlatformDependent0.hashCodeAsciiSanitize(byte)` but for `CharSequence`.
`private static int`	`hashCodeAsciiSanitizeInt(java.lang.CharSequence value, int offset)`	Identical to `PlatformDependent0.hashCodeAsciiSanitize(int)` but for `CharSequence`.
`private static int`	`hashCodeAsciiSanitizeShort(java.lang.CharSequence value, int offset)`	Identical to `PlatformDependent0.hashCodeAsciiSanitize(short)` but for `CharSequence`.
`(package private) static boolean`	`hasJctoolsVarHandle()`
`static boolean`	`hasUnsafe()`	Return `true` if `sun.misc.Unsafe` was found on the classpath and can be used for accelerated direct memory access.
`static boolean`	`hasVarHandle()`
`(package private) static void`	`incrementMemoryCounter(int capacity)`
`private static boolean`	`initializeVarHandle()`
`static VarHandle`	`intBeArrayView()`
`static VarHandle`	`intBeByteBufferView()`
`static VarHandle`	`intLeArrayView()`
`static VarHandle`	`intLeByteBufferView()`
`private static boolean`	`isAllowedClassifier(java.lang.String classifier)`
`static boolean`	`isAndroid()`	Returns `true` if and only if the current platform is Android
`static boolean`	`isExplicitNoPreferDirect()`	Returns `true` if user has specified `-Dio.netty.noPreferDirect=true` option.
`static boolean`	`isIkvmDotNet()`	Returns `true` if the running JVM is IKVM.NET, `false` otherwise.
`private static boolean`	`isIkvmDotNet0()`
`static boolean`	`isJ9Jvm()`	Returns `true` if the running JVM is either IBM J9 or Eclipse OpenJ9, `false` otherwise.
`private static boolean`	`isJ9Jvm0()`
`static boolean`	`isJfrEnabled()`	Check if JFR events are supported on this platform.
`static boolean`	`isOsx()`	Return `true` if the JVM is running on OSX / MacOS
`private static boolean`	`isOsx0()`
`static boolean`	`isUnaligned()`	`true` if and only if the platform supports unaligned access.
`static boolean`	`isVirtualThread(java.lang.Thread thread)`
`static boolean`	`isWindows()`	Return `true` if the JVM is running on Windows
`private static boolean`	`isWindows0()`
`static boolean`	`isZero(byte[] bytes, int startPos, int length)`	Determine if a subsection of an array is zero.
`private static boolean`	`isZeroSafe(byte[] bytes, int startPos, int length)`
`static int`	`javaVersion()`	Return the version of Java under which this library is used.
`static VarHandle`	`longBeArrayView()`
`static VarHandle`	`longBeByteBufferView()`
`static VarHandle`	`longLeArrayView()`
`static VarHandle`	`longLeByteBufferView()`
`static long`	`maxDirectMemory()`	Returns the maximum memory reserved for direct buffer allocation.
`static boolean`	`maybeSuperUser()`	Return `true` if the current user may be a super-user.
`private static boolean`	`maybeSuperUser0()`
`static <C> java.util.Deque<C>`	`newConcurrentDeque()`	Returns a new concurrent `Deque`.
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`newConcurrentHashMap()`	Deprecated. please use new ConcurrentHashMap() directly.
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`newConcurrentHashMap(int initialCapacity)`	Deprecated. please use new ConcurrentHashMap() directly.
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`newConcurrentHashMap(int initialCapacity, float loadFactor)`	Deprecated. please use new ConcurrentHashMap() directly.
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`newConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)`	Deprecated. please use new ConcurrentHashMap() directly.
`static <K,V> java.util.concurrent.ConcurrentMap<K,V>`	`newConcurrentHashMap(java.util.Map<? extends K,? extends V> map)`	Deprecated. please use new ConcurrentHashMap() directly.
`static <T> java.util.Queue<T>`	`newFixedMpmcQueue(int capacity)`	Create a new `Queue` which is safe to use for multiple producers (different threads) and multiple consumers with the given fixes `capacity`.
`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`.
`static <T> java.util.Queue<T>`	`newFixedMpscUnpaddedQueue(int capacity)`	Create a new un-padded `Queue` which is safe to use for multiple producers (different threads) and a single consumer (one thread!) with the given fixes `capacity`. This should be preferred to `newFixedMpscQueue(int)` when the queue is not to be heavily contended.
`static LongCounter`	`newLongCounter()`	Deprecated. please use `LongAdder` instead.
`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!).
`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!).
`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!).
`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!).
`private static java.lang.String`	`normalize(java.lang.String value)`
`private static java.lang.String`	`normalizeArch(java.lang.String value)`
`static java.lang.String`	`normalizedArch()`
`static java.util.Set<java.lang.String>`	`normalizedLinuxClassifiers()`
`static java.lang.String`	`normalizedOs()`
`private static java.lang.String`	`normalizeOs(java.lang.String value)`
`private static java.lang.String`	`normalizeOsReleaseVariableValue(java.lang.String value)`
`static long`	`objectFieldOffset(java.lang.reflect.Field field)`
`static java.nio.ByteBuffer`	`offsetSlice(java.nio.ByteBuffer buffer, int index, int length)`
`private static boolean`	`processOsReleaseFile(java.lang.String osReleaseFileName, java.util.Set<java.lang.String> availableClassifiers)`
`static void`	`putByte(byte[] data, int index, byte value)`
`static void`	`putByte(long address, byte value)`
`static void`	`putByte(java.lang.Object data, long offset, byte value)`
`static void`	`putInt(byte[] data, int index, int value)`
`static void`	`putInt(long address, int value)`
`static void`	`putLong(byte[] data, int index, long value)`
`static void`	`putLong(long address, long value)`
`static void`	`putObject(java.lang.Object o, long offset, java.lang.Object x)`
`static void`	`putOrderedInt(java.lang.Object object, long fieldOffset, int value)`
`static void`	`putShort(byte[] data, int index, short value)`
`static void`	`putShort(long address, short value)`
`static CleanableDirectBuffer`	`reallocateDirect(CleanableDirectBuffer buffer, int newCapacity)`	Reallocate a direct buffer with the given new capacity.
`static long`	`reallocateMemory(long address, long newSize)`
`(package private) static void`	`safeConstructPutInt(java.lang.Object object, long fieldOffset, int value)`
`static void`	`setMemory(byte[] dst, int dstIndex, long bytes, byte value)`
`static void`	`setMemory(long address, long bytes, byte value)`
`static VarHandle`	`shortBeArrayView()`
`static VarHandle`	`shortBeByteBufferView()`
`static VarHandle`	`shortLeArrayView()`
`static VarHandle`	`shortLeByteBufferView()`
`static void`	`splittableRandomNextBytes(java.util.SplittableRandom rng, byte[] data)`
`static java.util.Random`	`threadLocalRandom()`	Deprecated. Use ThreadLocalRandom.current() instead.
`static void`	`throwException(java.lang.Throwable t)`	Raises an exception bypassing compiler checks for checked exceptions.
`static java.io.File`	`tmpdir()`	Returns the temporary directory.
`private static java.io.File`	`tmpdir0()`
`private static java.io.File`	`toDirectory(java.lang.String path)`
`private static int`	`toIntExact(long value)`
`private static java.lang.Throwable`	`unsafeUnavailabilityCause0()`
`static long`	`usedDirectMemory()`	Returns the current memory reserved for direct buffer allocation.
`static boolean`	`useDirectBufferNoCleaner()`
`static boolean`	`useVarHandleForMultiByteAccess()`	`true` if `VarHandle` should be used for multi-byte access.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

logger

private static final InternalLogger logger

MAX_DIRECT_MEMORY_SIZE_ARG_PATTERN

private static 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

EXPLICIT_NO_PREFER_DIRECT

private static final boolean EXPLICIT_NO_PREFER_DIRECT

MAX_DIRECT_MEMORY

private static final long MAX_DIRECT_MEMORY

MPSC_CHUNK_SIZE
```
private static final int MPSC_CHUNK_SIZE
```
See Also:

Constant Field Values

MIN_MAX_MPSC_CAPACITY
```
private static final int MIN_MAX_MPSC_CAPACITY
```
See Also:

Constant Field Values

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

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
```

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
```

LEGACY_CLEANER

private static final Cleaner LEGACY_CLEANER

HAS_ALLOCATE_UNINIT_ARRAY

private static final boolean HAS_ALLOCATE_UNINIT_ARRAY

LINUX_ID_PREFIX

private static final java.lang.String LINUX_ID_PREFIX

See Also:: Constant Field Values

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

IGNORE_EXPENSIVE_CLEAN

private static final boolean IGNORE_EXPENSIVE_CLEAN

JFR
```
private static final boolean JFR
```

VAR_HANDLE

private static final boolean VAR_HANDLE

NOOP
```
private static final Cleaner NOOP
```

Constructor Detail
- PlatformDependent
```
private PlatformDependent()
```

Method Detail

initializeVarHandle

private static boolean initializeVarHandle()

addFilesystemOsClassifiers

static void addFilesystemOsClassifiers(java.util.Set<java.lang.String> availableClassifiers)

processOsReleaseFile

private static boolean processOsReleaseFile(java.lang.String osReleaseFileName,
                                            java.util.Set<java.lang.String> availableClassifiers)

addPropertyOsClassifiers

static boolean addPropertyOsClassifiers(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.

isVirtualThread
```
public static boolean isVirtualThread(java.lang.Thread thread)
```
Parameters:

thread - The thread to be checked.

Returns:

true if this Thread is a virtual thread, false otherwise.

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.

isExplicitNoPreferDirect
```
public static boolean isExplicitNoPreferDirect()
```
Returns true if user has specified -Dio.netty.noPreferDirect=true option.

canReliabilyFreeDirectBuffers
```
public static boolean canReliabilyFreeDirectBuffers()
```
Return true if the selected cleaner can free direct buffers in a controlled way. This guarantee only applies for buffers allocated via allocateDirect(int) and when using the clean method of the returned CleanableDirectBuffer.

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.

newConcurrentHashMap
```
@Deprecated
public static <K,V> java.util.concurrent.ConcurrentMap<K,V> newConcurrentHashMap()
```
Deprecated.
please use new ConcurrentHashMap() directly.

Creates a new fastest ConcurrentMap implementation for the current platform.

newLongCounter
```
@Deprecated
public static LongCounter newLongCounter()
```
Deprecated.
please use LongAdder instead.

Creates a new fastest LongCounter implementation for the current platform.

newConcurrentHashMap
```
@Deprecated
public static <K,V> java.util.concurrent.ConcurrentMap<K,V> newConcurrentHashMap(int initialCapacity)
```
Deprecated.
please use new ConcurrentHashMap() directly.

Creates a new fastest ConcurrentMap implementation for the current platform.

newConcurrentHashMap

@Deprecated
public static <K,V> java.util.concurrent.ConcurrentMap<K,V> newConcurrentHashMap(int initialCapacity,
                                                                                             float loadFactor)

Deprecated.

please use new ConcurrentHashMap() directly.

Creates a new fastest ConcurrentMap implementation for the current platform.

newConcurrentHashMap

@Deprecated
public static <K,V> java.util.concurrent.ConcurrentMap<K,V> newConcurrentHashMap(int initialCapacity,
                                                                                             float loadFactor,
                                                                                             int concurrencyLevel)

Deprecated.

please use new ConcurrentHashMap() directly.

Creates a new fastest ConcurrentMap implementation for the current platform.

newConcurrentHashMap

@Deprecated
public static <K,V> java.util.concurrent.ConcurrentMap<K,V> newConcurrentHashMap(java.util.Map<? extends K,? extends V> map)

Deprecated.

please use new ConcurrentHashMap() directly.

Creates a new fastest ConcurrentMap implementation for the current platform.

allocateDirect
```
public static CleanableDirectBuffer allocateDirect(int capacity)
```
Allocate a direct ByteBuffer of the given capacity, and return it alongside its deallocation mechanism.

Parameters:

capacity - The desired capacity of the direct byte buffer.

Returns:

The CleanableDirectBuffer instance that contain the buffer and its deallocation mechanism.

allocateDirect
```
public static CleanableDirectBuffer allocateDirect(int capacity,
                                                   boolean permitExpensiveClean)
```
Allocate a direct ByteBuffer of the given capacity, and return it alongside its deallocation mechanism.

Parameters:

capacity - The desired capacity of the direct byte buffer.

permitExpensiveClean - Whether to allow expensive clean operations or not. If expensive clean operations are not permitted (false), then the buffer cleaning may instead be delegated to the GC and reference processing. Pooling allocators would typically permit expensive clean operations, while unpooled buffers would not.

Returns:

The CleanableDirectBuffer instance that contain the buffer and its deallocation mechanism.

reallocateDirect
```
public static CleanableDirectBuffer reallocateDirect(CleanableDirectBuffer buffer,
                                                     int newCapacity)
```
Reallocate a direct buffer with the given new capacity. The old buffer is invalidated and must not be used after this call.

Parameters:

buffer - The old buffer to reallocate.

newCapacity - The desired new capacity.

Returns:

The new CleanableDirectBuffer with the given capacity.

freeDirectBuffer
```
@Deprecated
public static void freeDirectBuffer(java.nio.ByteBuffer buffer)
```
Deprecated.
Use the CleanableDirectBuffer.clean() from allocateDirect(int) instead.

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.

hasDirectByteBufferAddress
```
public static boolean hasDirectByteBufferAddress(java.nio.ByteBuffer buffer)
```
Check if it is possible to call directBufferAddress(ByteBuffer) on the given buffer.

Parameters:

buffer - The specific buffer instance to check for.

Returns:

true if directBufferAddress(ByteBuffer) can be called on the given buffer, otherwise false.

directBufferAddress
```
public static long directBufferAddress(java.nio.ByteBuffer buffer)
```
Obtain the native memory address of the given direct byte buffer, or throw an exception if it's not possible.

Parameters:

buffer - The buffer to get the native memory address for.

Returns:

The native memory address of the give buffer.

directBuffer

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

hasVarHandle
```
public static boolean hasVarHandle()
```

hasJctoolsVarHandle
```
static boolean hasJctoolsVarHandle()
```

useVarHandleForMultiByteAccess
```
public static boolean useVarHandleForMultiByteAccess()
```
true if VarHandle should be used for multi-byte access. The multi-byte access strategy is determined as follows: 1) If the platform supports unaligned access natively, use Unsafe as the fastest option. 2) Otherwise, if VarHandle is available, use it as a fallback. 3) Otherwise, fall back to manual byte-by-byte access.

canUnalignedAccess
```
public static boolean canUnalignedAccess()
```
true if multi-byte access at arbitrary offsets is possible, either natively through Unsafe or via VarHandle where the JVM handles alignment and byte ordering internally.

findVarHandleOfIntField

public static VarHandle findVarHandleOfIntField(java.lang.invoke.MethodHandles.Lookup lookup,
                                                java.lang.Class<?> type,
                                                java.lang.String fieldName)

intBeArrayView

public static VarHandle intBeArrayView()

intLeArrayView

public static VarHandle intLeArrayView()

longBeArrayView

public static VarHandle longBeArrayView()

longLeArrayView

public static VarHandle longLeArrayView()

shortBeArrayView

public static VarHandle shortBeArrayView()

shortLeArrayView

public static VarHandle shortLeArrayView()

longBeByteBufferView

public static VarHandle longBeByteBufferView()

longLeByteBufferView

public static VarHandle longLeByteBufferView()

intBeByteBufferView

public static VarHandle intBeByteBufferView()

intLeByteBufferView

public static VarHandle intLeByteBufferView()

shortBeByteBufferView

public static VarHandle shortBeByteBufferView()

shortLeByteBufferView

public static VarHandle shortLeByteBufferView()

getObject

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

getVolatileInt

public static int getVolatileInt(java.lang.Object object,
                                 long fieldOffset)

getInt

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

putOrderedInt

public static void putOrderedInt(java.lang.Object object,
                                 long fieldOffset,
                                 int value)

getAndAddInt

public static int getAndAddInt(java.lang.Object object,
                               long fieldOffset,
                               int delta)

compareAndSwapInt

public static boolean compareAndSwapInt(java.lang.Object object,
                                        long fieldOffset,
                                        int expected,
                                        int value)

safeConstructPutInt

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

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)

toIntExact

private static int toIntExact(long value)

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)

hashCodeAsciiCompute

private static int hashCodeAsciiCompute(java.lang.CharSequence value,
                                        int offset,
                                        int hash)

Identical to PlatformDependent0.hashCodeAsciiCompute(long, int) but for CharSequence.

hashCodeAsciiSanitizeInt

private static int hashCodeAsciiSanitizeInt(java.lang.CharSequence value,
                                            int offset)

Identical to PlatformDependent0.hashCodeAsciiSanitize(int) but for CharSequence.

hashCodeAsciiSanitizeShort

private static int hashCodeAsciiSanitizeShort(java.lang.CharSequence value,
                                              int offset)

Identical to PlatformDependent0.hashCodeAsciiSanitize(short) but for CharSequence.

hashCodeAsciiSanitizeByte
```
private static int hashCodeAsciiSanitizeByte(char value)
```
Identical to PlatformDependent0.hashCodeAsciiSanitize(byte) but for CharSequence.

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)

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)

offsetSlice

public static java.nio.ByteBuffer offsetSlice(java.nio.ByteBuffer buffer,
                                              int index,
                                              int length)

absolutePut

public static java.nio.ByteBuffer absolutePut(java.nio.ByteBuffer dst,
                                              int dstOffset,
                                              byte[] src,
                                              int srcOffset,
                                              int length)

absolutePut

public static java.nio.ByteBuffer absolutePut(java.nio.ByteBuffer dst,
                                              int dstOffset,
                                              java.nio.ByteBuffer src,
                                              int srcOffset,
                                              int length)

incrementMemoryCounter

static void incrementMemoryCounter(int capacity)

decrementMemoryCounter

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.

newFixedMpscUnpaddedQueue
```
public static <T> java.util.Queue<T> newFixedMpscUnpaddedQueue(int capacity)
```
Create a new un-padded Queue which is safe to use for multiple producers (different threads) and a single consumer (one thread!) with the given fixes capacity.
This should be preferred to newFixedMpscQueue(int) when the queue is not to be heavily contended.

newFixedMpmcQueue
```
public static <T> java.util.Queue<T> newFixedMpmcQueue(int capacity)
```
Create a new Queue which is safe to use for multiple producers (different threads) and multiple consumers 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
```
@Deprecated
public static java.util.Random threadLocalRandom()
```
Deprecated.
Use ThreadLocalRandom.current() instead.

Return a Random which is not-threadsafe and so can only be used from the same thread.

splittableRandomNextBytes

public static void splittableRandomNextBytes(java.util.SplittableRandom rng,
                                             byte[] data)

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()

getMaxDirectMemorySizeArgPattern

private static java.util.regex.Pattern getMaxDirectMemorySizeArgPattern()

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> dest,
                                  java.lang.String... maybeClassifiers)
```
Adds only those classifier strings to dest which are present in allowed.

Parameters:

dest - destination set

maybeClassifiers - potential classifiers to add

isAllowedClassifier

private static boolean isAllowedClassifier(java.lang.String classifier)

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)

isJfrEnabled
```
public static boolean isJfrEnabled()
```
Check if JFR events are supported on this platform.

Class PlatformDependent

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

MAX_DIRECT_MEMORY_SIZE_ARG_PATTERN

MAYBE_SUPER_USER

CAN_ENABLE_TCP_NODELAY_BY_DEFAULT

UNSAFE_UNAVAILABILITY_CAUSE

DIRECT_BUFFER_PREFERRED

EXPLICIT_NO_PREFER_DIRECT

MAX_DIRECT_MEMORY

MPSC_CHUNK_SIZE

MIN_MAX_MPSC_CAPACITY

MAX_ALLOWED_MPSC_CAPACITY

BYTE_ARRAY_BASE_OFFSET

TMPDIR

BIT_MODE

NORMALIZED_ARCH

NORMALIZED_OS

LINUX_OS_CLASSIFIERS

IS_WINDOWS

IS_OSX

IS_J9_JVM

IS_IVKVM_DOT_NET

ADDRESS_SIZE

DIRECT_MEMORY_COUNTER

DIRECT_MEMORY_LIMIT

CLEANER

LEGACY_CLEANER

HAS_ALLOCATE_UNINIT_ARRAY

LINUX_ID_PREFIX

LINUX_ID_LIKE_PREFIX

BIG_ENDIAN_NATIVE_ORDER

IGNORE_EXPENSIVE_CLEAN

JFR

VAR_HANDLE

NOOP

Constructor Detail

PlatformDependent

Method Detail

initializeVarHandle

addFilesystemOsClassifiers

processOsReleaseFile

addPropertyOsClassifiers

byteArrayBaseOffset

hasDirectBufferNoCleanerConstructor

allocateUninitializedArray

isAndroid

isWindows

isOsx

maybeSuperUser

javaVersion

isVirtualThread

canEnableTcpNoDelayByDefault

hasUnsafe

getUnsafeUnavailabilityCause

isUnaligned

directBufferPreferred

isExplicitNoPreferDirect

canReliabilyFreeDirectBuffers

maxDirectMemory

usedDirectMemory

tmpdir

bitMode

addressSize

allocateMemory

freeMemory

reallocateMemory

throwException

newConcurrentHashMap

newLongCounter

newConcurrentHashMap

newConcurrentHashMap

newConcurrentHashMap

newConcurrentHashMap

allocateDirect