This class may be removed in the future. Consider the replacements in JEP 193 'Variable Handles': http://openjdk.java.net/jeps/193
static void setMemory(long address, long bytes, byte value) { UNSAFE.setMemory(address, bytes, value); }
static void setMemory(Object o, long offset, long bytes, byte value) { UNSAFE.setMemory(o, offset, bytes, value); }
public void clear() { unsafe.setMemory(baseAdress,length, (byte) 0); } }
static void setMemory(long address, long bytes, byte value) { UNSAFE.setMemory(address, bytes, value); }
static void setMemory(Object o, long offset, long bytes, byte value) { UNSAFE.setMemory(o, offset, bytes, value); }
/** * Fills memory with given value. * * @param addr Address. * @param len Length. * @param val Value. */ public static void setMemory(long addr, long len, byte val) { UNSAFE.setMemory(addr, len, val); }
static void setMemory(Object o, long offset, long bytes, byte value) { UNSAFE.setMemory(o, offset, bytes, value); }
static void setMemory(long address, long bytes, byte value) { UNSAFE.setMemory(address, bytes, value); }
public void setMemory(long addr, long size, byte v) { this.unsafe.setMemory(addr, size, v); } }
/** * Set the given number of bytes to the given value, starting from the given address. */ public static void setMemory( long address, long bytes, byte value ) { if ( 0 == (address & 1) && bytes > 64 ) { unsafe.putByte( address, value ); unsafe.setMemory( address + 1, bytes - 1, value ); } else { unsafe.setMemory( address, bytes, value ); } }
public void clear() { unsafe.setMemory(baseAdress,length, (byte) 0); } }
public void setMemory(final int index, final int length, final byte value) { if (SHOULD_BOUNDS_CHECK) { boundsCheck0(index, length); } final long indexOffset = addressOffset + index; if (0 == (indexOffset & 1) && length > 64) { // This horrible filth is to encourage the JVM to call memset() when address is even. // TODO: check if this still applies for versions beyond Java 11. UNSAFE.putByte(byteArray, indexOffset, value); UNSAFE.setMemory(byteArray, indexOffset + 1, length - 1, value); } else { UNSAFE.setMemory(byteArray, indexOffset, length, value); } }
public void setMemory(final long index, final int length, final byte value) { if (SHOULD_BOUNDS_CHECK) { boundsCheck0(index, length); } UNSAFE.setMemory(null, addressOffset + index, length, value); }
public void setMemory(final int index, final int length, final byte value) { lengthCheck(length); ensureCapacity(index, length); final long indexOffset = address + index; if (0 == (indexOffset & 1) && length > 64) { // This horrible filth is to encourage the JVM to call memset() when address is even. // TODO: check if this still applies when Java 9 is out!!! UNSAFE.putByte(null, indexOffset, value); UNSAFE.setMemory(null, indexOffset + 1, length - 1, value); } else { UNSAFE.setMemory(null, indexOffset, length, value); } }
final boolean ensureCapacity(long bytes, boolean clearNewMem) { long oldCap = getCapacity(); long newBytes = bytes - oldCap; if (newBytes <= 0) return false; // avoid frequent increase of allocation area, instead increase by segment size int allSegments = (int) (bytes / segmentSizeInBytes); if (bytes % segmentSizeInBytes != 0) allSegments++; capacity = allSegments * segmentSizeInBytes; try { address = UNSAFE.reallocateMemory(address, capacity); } catch (OutOfMemoryError err) { throw new OutOfMemoryError(err.getMessage() + " - problem when allocating new memory. Old capacity: " + oldCap + ", new bytes:" + newBytes + ", segmentSizeIntsPower:" + segmentSizePower); } if (clearNewMem) UNSAFE.setMemory(address + oldCap, capacity - oldCap, (byte) 0); return true; }
static void setMemory(long address, long bytes, byte value) { UNSAFE.setMemory(address, bytes, value); }
static void setMemory(Object o, long offset, long bytes, byte value) { UNSAFE.setMemory(o, offset, bytes, value); }
public void setMemory(long offset, long bytes, byte b) { checkBounds(offset, offset + bytes); // check if the last element will fit into the memory unsafe.setMemory(peer + offset, bytes, b); }
static void setMemory(long address, long offset, long len, byte val) { validate(address, offset, len); unsafe.setMemory(address + offset, len, val); }
/** * Set all bytes to 0. */ public void clear() { MemoryUtil.unsafe.setMemory(address(), size(), (byte) 0); }