/** * @param ptr Address. * @param size Size. * @return Bytes. */ public static byte[] copyMemory(long ptr, int size) { byte[] res = new byte[size]; GridUnsafe.copyMemory(null, ptr, res, GridUnsafe.BYTE_ARR_OFF, size); return res; }
/** * @param addr Address/ * @param off Offset. * @param bytes Bytes. */ public static void putBytes(long addr, int off, byte[] bytes) { assert addr > 0 : addr; assert off >= 0; assert bytes != null; GridUnsafe.copyMemory(bytes, GridUnsafe.BYTE_ARR_OFF, null, addr + off, bytes.length); }
/** * @param fullPageId Full page ID. * @param ptr Pointer to copy from. * @param pageSize Page size. * @param realPageSize Page size without encryption overhead. */ public PageSnapshot(FullPageId fullPageId, long ptr, int pageSize, int realPageSize) { this.fullPageId = fullPageId; this.realPageSize = realPageSize; pageData = new byte[pageSize]; GridUnsafe.copyMemory(null, ptr, pageData, GridUnsafe.BYTE_ARR_OFF, pageSize); }
/** * @param srcAddr Source. * @param srcOff Source offset in bytes. * @param dstAddr Destination. * @param dstOff Destination offset in bytes. * @param cnt Bytes count to copy. */ public static void copyMemory(long srcAddr, long srcOff, long dstAddr, long dstOff, long cnt) { GridUnsafe.copyMemory(null, srcAddr + srcOff, null, dstAddr + dstOff, cnt); }
/** * @param addr Address. * @param off Offset. * @param bytes Bytes array. * @param bytesOff Bytes array offset. */ public static void putBytes(long addr, int off, byte[] bytes, int bytesOff) { assert addr > 0 : addr; assert off >= 0; assert bytes != null; assert bytesOff >= 0 && (bytesOff < bytes.length || bytes.length == 0) : bytesOff; GridUnsafe.copyMemory(bytes, GridUnsafe.BYTE_ARR_OFF + bytesOff, null, addr + off, bytes.length - bytesOff); }
/** * @param addr Start address. * @param off Offset. * @param len Bytes length. * @return Bytes from given address. */ public static byte[] getBytes(long addr, int off, int len) { assert addr > 0 : addr; assert off >= 0; assert len >= 0; byte[] bytes = new byte[len]; GridUnsafe.copyMemory(null, addr + off, bytes, GridUnsafe.BYTE_ARR_OFF, len); return bytes; }
/** * @param addr Address. * @param off Offset. * @param bytes Bytes array. * @param bytesOff Bytes array offset. * @param len Length. */ public static void putBytes(long addr, int off, byte[] bytes, int bytesOff, int len) { assert addr > 0 : addr; assert off >= 0; assert bytes != null; assert bytesOff >= 0 && (bytesOff < bytes.length || bytes.length == 0) : bytesOff; GridUnsafe.copyMemory(bytes, GridUnsafe.BYTE_ARR_OFF + bytesOff, null, addr + off, len); }
/** * @param srcAddr Source address. * @param srcOff Source offset. * @param dst Destination array. * @param dstOff Destination offset. * @param len Length. */ public static void getBytes(long srcAddr, int srcOff, byte[] dst, int dstOff, int len) { assert srcAddr > 0; assert srcOff > 0; assert dst != null; assert dstOff >= 0; assert len >= 0; GridUnsafe.copyMemory(null, srcAddr + srcOff, dst, GridUnsafe.BYTE_ARR_OFF + dstOff, len); }
/** * @param src Buffer to copy from (length included). * @param off Offset in source buffer. * @param resBuf Result buffer. * @param resOff Result offset. * @param len Length. * @return Number of bytes overwritten in {@code bytes} array. */ public static int arrayCopy(byte[] src, int off, byte[] resBuf, int resOff, int len) { assert resBuf.length >= resOff + len; if (UNSAFE_BYTE_ARR_CP) GridUnsafe.copyMemory(src, GridUnsafe.BYTE_ARR_OFF + off, resBuf, GridUnsafe.BYTE_ARR_OFF + resOff, len); else System.arraycopy(src, off, resBuf, resOff, len); return resOff + len; }
/** {@inheritDoc} */ @Override protected void copyAndShift(Object target, long off, int len) { GridUnsafe.copyMemory(data, GridUnsafe.BYTE_ARR_OFF + pos, target, off, len); shift(len); }
/** {@inheritDoc} */ @Override protected void copyAndShift(Object src, long off, int len) { GridUnsafe.copyMemory(src, off, data, GridUnsafe.BYTE_ARR_OFF + pos, len); shift(len); }
/** * @param arr Array. * @param off Offset. * @return Value. */ public static char[] readCharArray(byte[] arr, int off, int len) { char[] arr0 = new char[len]; GridUnsafe.copyMemory(arr, GridUnsafe.BYTE_ARR_OFF + off, arr0, GridUnsafe.CHAR_ARR_OFF, len << 1); if (BIG_ENDIAN) { for (int i = 0; i < len; i++) arr0[i] = Character.reverseBytes(arr0[i]); } return arr0; }
/** * @param src Source. * @param srcOff Source offset in bytes. * @param dst Destination. * @param dstOff Destination offset in bytes. * @param cnt Bytes count to copy. */ public static void copyMemory(ByteBuffer src, long srcOff, ByteBuffer dst, long dstOff, long cnt) { byte[] srcArr = src.hasArray() ? src.array() : null; byte[] dstArr = dst.hasArray() ? dst.array() : null; long srcArrOff = src.hasArray() ? src.arrayOffset() + GridUnsafe.BYTE_ARR_OFF : 0; long dstArrOff = dst.hasArray() ? dst.arrayOffset() + GridUnsafe.BYTE_ARR_OFF : 0; long srcPtr = src.isDirect() ? GridUnsafe.bufferAddress(src) : 0; long dstPtr = dst.isDirect() ? GridUnsafe.bufferAddress(dst) : 0; GridUnsafe.copyMemory(srcArr, srcPtr + srcArrOff + srcOff, dstArr, dstPtr + dstArrOff + dstOff, cnt); }
/** {@inheritDoc} */ @Override public void writePage(FullPageId fullPageId, ByteBuffer byteBuf, int tag) { tracker.lock(fullPageId); ByteBuffer tlb = byteBufThreadLoc.get(); tlb.rewind(); long writeAddr = GridUnsafe.bufferAddress(tlb); long origBufAddr = GridUnsafe.bufferAddress(byteBuf); GridUnsafe.copyMemory(origBufAddr, writeAddr, pageSize); this.fullPageId = fullPageId; this.byteBuf = tlb; this.tag = tag; }
/** {@inheritDoc} */ @Override public int[] readIntArray() throws IOException { int arrSize = readInt(); int bytesToCp = arrSize << 2; fromStream(bytesToCp); int[] arr = new int[arrSize]; long off = BYTE_ARR_OFF + offset(bytesToCp); if (BIG_ENDIAN) { for (int i = 0; i < arr.length; i++) { arr[i] = GridUnsafe.getIntLE(buf, off); off += 4; } } else GridUnsafe.copyMemory(buf, off, arr, INT_ARR_OFF, bytesToCp); return arr; }
/** {@inheritDoc} */ @Override public void writeLongArray(long[] arr) throws IOException { writeInt(arr.length); checkArrayAllocationOverflow(8, arr.length, "long"); int bytesToCp = arr.length << 3; requestFreeSize(bytesToCp); if (BIG_ENDIAN) { long off = BYTE_ARR_OFF + this.off; for (long val : arr) { GridUnsafe.putLongLE(bytes, off, val); off += 8; } } else GridUnsafe.copyMemory(arr, LONG_ARR_OFF, bytes, BYTE_ARR_OFF + off, bytesToCp); onWrite(bytesToCp); }
/** {@inheritDoc} */ @Override public void writeDoubleArray(double[] arr) throws IOException { writeInt(arr.length); checkArrayAllocationOverflow(8, arr.length, "double"); int bytesToCp = arr.length << 3; requestFreeSize(bytesToCp); if (BIG_ENDIAN) { long off = BYTE_ARR_OFF + this.off; for (double val : arr) { GridUnsafe.putDoubleLE(bytes, off, val); off += 8; } } else GridUnsafe.copyMemory(arr, DOUBLE_ARR_OFF, bytes, BYTE_ARR_OFF + off, bytesToCp); onWrite(bytesToCp); }
/** {@inheritDoc} */ @Override public void writeCharArray(char[] arr) throws IOException { writeInt(arr.length); checkArrayAllocationOverflow(2, arr.length, "char"); int bytesToCp = arr.length << 1; requestFreeSize(bytesToCp); if (BIG_ENDIAN) { long off = BYTE_ARR_OFF + this.off; for (char val : arr) { GridUnsafe.putCharLE(bytes, off, val); off += 2; } } else GridUnsafe.copyMemory(arr, CHAR_ARR_OFF, bytes, BYTE_ARR_OFF + off, bytesToCp); onWrite(bytesToCp); }
/** {@inheritDoc} */ @Override public void writeIntArray(int[] arr) throws IOException { writeInt(arr.length); checkArrayAllocationOverflow(4, arr.length, "int"); int bytesToCp = arr.length << 2; requestFreeSize(bytesToCp); if (BIG_ENDIAN) { long off = BYTE_ARR_OFF + this.off; for (int val : arr) { GridUnsafe.putIntLE(bytes, off, val); off += 4; } } else GridUnsafe.copyMemory(arr, INT_ARR_OFF, bytes, BYTE_ARR_OFF + off, bytesToCp); onWrite(bytesToCp); }
/** * Convert binary object to it's final state. * * @param obj Object. * @param offheap Offheap flag. * @return Result. */ private BinaryObjectExImpl convert(BinaryObjectExImpl obj, boolean offheap) { if (offheap) { byte[] arr = obj.array(); long ptr = GridUnsafe.allocateMemory(arr.length); ptrs.add(ptr); GridUnsafe.copyMemory(arr, GridUnsafe.BYTE_ARR_OFF, null, ptr, arr.length); obj = new BinaryObjectOffheapImpl(obj.context(), ptr, 0, obj.array().length); } return obj; }