/** * Checks if we can run fast path: we got well known buffer is already aligned. * * @param srcBuf buffer to check if it is known buffer. * @return {@code true} if this buffer was allocated with alignment, may be used directly. */ private boolean isKnownAligned(ByteBuffer srcBuf) { return srcBuf.isDirect() && managedAlignedBuffers != null && managedAlignedBuffers.containsKey(GridUnsafe.bufferAddress(srcBuf)); }
/** * @param ptr Pointer. * @param off Offset. * @return Value. */ public static byte readByte(long ptr, int off) { return GridUnsafe.getByte(ptr + off); }
/** * Writes byte array into memory location. * * @param ptr Pointer. * @param arr Array. */ public void writeBytes(long ptr, byte[] arr) { GridUnsafe.copyHeapOffheap(arr, GridUnsafe.BYTE_ARR_OFF, ptr, arr.length); }
/** * @param len Length. * @return Allocated direct buffer. */ public static ByteBuffer allocateBuffer(int len) { long ptr = allocateMemory(len); return wrapPointer(ptr, len); }
/** {@inheritDoc} */ @Override public void start() throws IgniteException { trackingArrPtr = GridUnsafe.allocateMemory(trackingSize * 8); GridUnsafe.setMemory(trackingArrPtr, trackingSize * 8, (byte)0); }
long ptr = GridUnsafe.allocateMemory(arr.length + 5); GridUnsafe.putBoolean(null, ptr0++, false); GridUnsafe.putIntLE(ptr0, len); else GridUnsafe.putInt(ptr0, len); GridUnsafe.copyHeapOffheap(arr, GridUnsafe.BYTE_ARR_OFF, ptr0 + 4, arr.length); GridUnsafe.freeMemory(ptr);
/** * * @param buf Buffer. * @param len New length. * @return Reallocated direct buffer. */ public static ByteBuffer reallocateBuffer(ByteBuffer buf, int len) { long ptr = bufferAddress(buf); long newPtr = reallocateMemory(ptr, len); return wrapPointer(newPtr, len); }
/** * @param record page snapshot record. * @return string identifier of page (IO) type. */ private static String getPageType(PageSnapshot record) { byte[] pageData = record.pageData(); ByteBuffer buf = ByteBuffer.allocateDirect(pageData.length); try { buf.order(ByteOrder.nativeOrder()); buf.put(pageData); long addr = GridUnsafe.bufferAddress(buf); int type = PageIO.getType(addr); int ver = PageIO.getVersion(addr); return PageIO.getPageIO(type, ver).getClass().getSimpleName(); } catch (IgniteCheckedException ignored) { } finally { GridUnsafe.cleanDirectBuffer(buf); } return ""; }
/** * Test unsafe vs. new. */ private static void testUnsafe() throws InterruptedException { X.println("Testing unsafe..."); int MAX = 1000000; long[] addrs = new long[MAX]; System.gc(); GridTimer t = new GridTimer("unsafe"); int mem = 1024; for (int i = 0; i < MAX; i++) { addrs[i] = GridUnsafe.allocateMemory(mem); GridUnsafe.putByte(addrs[i] + RAND.nextInt(mem), (byte)RAND.nextInt(mem)); v = GridUnsafe.getByte(addrs[i] + RAND.nextInt(mem)); } X.println("Unsafe [time=" + t.stop() + "ms, v=" + v + ']'); Thread.sleep(5000L); for (long l : addrs) GridUnsafe.freeMemory(l); }
/** * @return Instance. * @throws BinaryObjectException In case of error. */ private Object newInstance() throws BinaryObjectException { try { return ctor != null ? ctor.newInstance() : GridUnsafe.allocateInstance(cls); } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) { throw new BinaryObjectException("Failed to instantiate instance: " + cls, e); } }
long ptr = GridUnsafe.allocateMemory(NUM_TASKS * pageSize); ByteBuffer buf = GridUnsafe.wrapPointer(pageAdr, pageSize); GridUnsafe.freeMemory(ptr);
/** * @param buf Direct buffer allocated by {@link #allocateBuffer(int)}. */ public static void freeBuffer(ByteBuffer buf) { long ptr = bufferAddress(buf); freeMemory(ptr); }
/** * Allocate unpooled memory chunk. * * @param cap Minimum capacity. * @return New memory pointer. */ public static long allocateUnpooled(int cap) { assert cap > 0; long memPtr = GridUnsafe.allocateMemory(MEM_HDR_LEN); long dataPtr = GridUnsafe.allocateMemory(cap); GridUnsafe.putLong(memPtr, dataPtr); // Write address. GridUnsafe.putInt(memPtr + MEM_HDR_OFF_CAP, cap); // Write capacity. GridUnsafe.putInt(memPtr + MEM_HDR_OFF_LEN, 0); // Write length. GridUnsafe.putInt(memPtr + MEM_HDR_OFF_FLAGS, 0); // Write flags. return memPtr; }
/** {@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; }
/** * @param obj Object. * @return Offheap address. */ private long copyOffheap(BinaryObjectImpl obj) { byte[] arr = obj.array(); long ptr = GridUnsafe.allocateMemory(arr.length); GridUnsafe.copyHeapOffheap(arr, GridUnsafe.BYTE_ARR_OFF, ptr, arr.length); return ptr; }
/** * Will zero memory in buf * @param buf Buffer. * @param off Offset. * @param len Length. */ public static void zeroMemory(ByteBuffer buf, int off, int len) { if (buf.isDirect()) GridUnsafe.setMemory(GridUnsafe.bufferAddress(buf) + off, len, (byte)0); else { for (int i = off; i < off + len; i++) buf.put(i, (byte)0); //TODO Optimize! } }
/** {@inheritDoc} */ @Override public ByteBuffer pageBuffer(long pageAddr) { return wrapPointer(pageAddr, pageSize()); }
/** */ @Test public void testBuffers() { ByteBuffer b1 = GridUnsafe.allocateBuffer(10); ByteBuffer b2 = GridUnsafe.allocateBuffer(20); assertEquals(GridUnsafe.NATIVE_BYTE_ORDER, b2.order()); assertTrue(b2.isDirect()); assertEquals(20, b2.capacity()); assertEquals(20, b2.limit()); assertEquals(0, b2.position()); assertEquals(GridUnsafe.NATIVE_BYTE_ORDER, b1.order()); assertTrue(b1.isDirect()); assertEquals(10, b1.capacity()); assertEquals(10, b1.limit()); assertEquals(0, b1.position()); b1.putLong(1L); b1.putShort((short)7); b2.putLong(2L); GridUnsafe.freeBuffer(b1); b2.putLong(3L); b2.putInt(9); for (int i = 0; i <= 16; i++) b2.putInt(i, 100500); GridUnsafe.freeBuffer(b2); }
/** * @param base Entry base address. * @param grpId Group ID to be stored in entry. */ private void setGrpId(long base, int grpId) { putInt(base + GRP_ID_OFFSET, grpId); }