private void putLong( long p, long value ) { if ( UnsafeUtil.allowUnalignedMemoryAccess ) { UnsafeUtil.putLong( p, value ); } else { UnsafeUtil.putLongByteWiseLittleEndian( p, value ); } }
private void putLongBigEndian( long value, long p ) { UnsafeUtil.putByte( p , (byte)( value >> 56 ) ); UnsafeUtil.putByte( p + 1, (byte)( value >> 48 ) ); UnsafeUtil.putByte( p + 2, (byte)( value >> 40 ) ); UnsafeUtil.putByte( p + 3, (byte)( value >> 32 ) ); UnsafeUtil.putByte( p + 4, (byte)( value >> 24 ) ); UnsafeUtil.putByte( p + 5, (byte)( value >> 16 ) ); UnsafeUtil.putByte( p + 6, (byte)( value >> 8 ) ); UnsafeUtil.putByte( p + 7, (byte) value ); }
protected static long alignmentSafeGetLongAsTwoInts( long address ) { if ( UnsafeUtil.allowUnalignedMemoryAccess ) { return UnsafeUtil.getLong( address ); } // See javadoc in constructor as to why we do this long lsb = UnsafeUtil.getInt( address ) & 0xFFFFFFFFL; long msb = UnsafeUtil.getInt( address + Integer.BYTES ) & 0xFFFFFFFFL; return lsb | (msb << Integer.SIZE); } }
Grab( Grab next, long size, MemoryAllocationTracker memoryTracker ) { this.next = next; this.address = UnsafeUtil.allocateMemory( size, memoryTracker ); this.limit = address + size; this.memoryTracker = memoryTracker; nextPointer = address; }
private void putInt( long p, int value ) { if ( UnsafeUtil.allowUnalignedMemoryAccess ) { UnsafeUtil.putInt( p, value ); } else { UnsafeUtil.putIntByteWiseLittleEndian( p, value ); } }
@Override public void clear() { setMemory( block.unalignedAddr, block.unalignedSize, (byte) 0 ); }
@Override protected long internalKey( long keyAddress ) { return UnsafeUtil.getInt( keyAddress ); }
@Override public long readLong( long offset ) { return getLong( block.addr + offset ); }
private static void verifyHacks() { // Make sure that we have access to theUnsafe. UnsafeUtil.assertHasUnsafe(); }
private short getShort( long p ) { if ( UnsafeUtil.allowUnalignedMemoryAccess ) { return UnsafeUtil.getShort( p ); } return UnsafeUtil.getShortByteWiseLittleEndian( p ); }
private void putShort( long p, short value ) { if ( UnsafeUtil.allowUnalignedMemoryAccess ) { UnsafeUtil.putShort( p, value ); } else { UnsafeUtil.putShortByteWiseLittleEndian( p, value ); } }
public PageListTest( int pageId ) { this.pageId = pageId; this.prevPageId = pageId == 0 ? pageIds.length - 1 : (pageId - 1) % pageIds.length; this.nextPageId = (pageId + 1) % pageIds.length; pageSize = UnsafeUtil.pageSize(); }
private void initialiseLastPageId( long lastPageIdFromFile ) { if ( lastPageIdFromFile < 0 ) { // MIN_VALUE only has the sign bit raised, and the rest of the bits are zeros. UnsafeUtil.putLongVolatile( this, headerStateOffset, Long.MIN_VALUE ); } else { UnsafeUtil.putLongVolatile( this, headerStateOffset, lastPageIdFromFile ); } }
static long computeChunkOffset( long filePageId ) { int index = (int) (filePageId & translationTableChunkSizeMask); return UnsafeUtil.arrayOffset( index, translationTableChunkArrayBase, translationTableChunkArrayScale ); } }
private boolean compareAndSetFreelistHead( Object expected, Object update ) { return UnsafeUtil.compareAndSwapObject( this, freelistOffset, expected, update ); }
private static void checkFree( long pointer ) { if ( CHECK_NATIVE_ACCESS ) { doCheckFree( pointer ); } }
private long getLongBigEndian( long p ) { long a = UnsafeUtil.getByte( p ) & 0xFF; long b = UnsafeUtil.getByte( p + 1 ) & 0xFF; long c = UnsafeUtil.getByte( p + 2 ) & 0xFF; long d = UnsafeUtil.getByte( p + 3 ) & 0xFF; long e = UnsafeUtil.getByte( p + 4 ) & 0xFF; long f = UnsafeUtil.getByte( p + 5 ) & 0xFF; long g = UnsafeUtil.getByte( p + 6 ) & 0xFF; long h = UnsafeUtil.getByte( p + 7 ) & 0xFF; return (a << 56) | (b << 48) | (c << 40) | (d << 32) | (e << 24) | (f << 16) | (g << 8) | h; }