/** * Release memory. * * @param ptr Pointer. */ protected void release(long ptr) { GridUnsafe.freeMemory(ptr); } }
/** {@inheritDoc} */ @Override public void stop() throws IgniteException { GridUnsafe.freeMemory(trackingArrPtr); }
/** {@inheritDoc} */ @Override public void stop() throws IgniteException { GridUnsafe.freeMemory(trackingArrPtr); }
/** * @param buf Direct buffer allocated by {@link #allocateBuffer(int)}. */ public static void freeBuffer(ByteBuffer buf) { long ptr = bufferAddress(buf); freeMemory(ptr); }
/** * Release pool memory. * * @param poolPtr Pool pointer. */ public static void releasePool(long poolPtr) { // Clean predefined memory chunks. long mem = GridUnsafe.getLong(poolPtr + POOL_HDR_OFF_MEM_1); if (mem != 0) GridUnsafe.freeMemory(mem); mem = GridUnsafe.getLong(poolPtr + POOL_HDR_OFF_MEM_2); if (mem != 0) GridUnsafe.freeMemory(mem); mem = GridUnsafe.getLong(poolPtr + POOL_HDR_OFF_MEM_3); if (mem != 0) GridUnsafe.freeMemory(mem); // Clean pool chunk. GridUnsafe.freeMemory(poolPtr); }
/** {@inheritDoc} */ @Override public void shutdown(boolean deallocate) { if (regions != null) { for (Iterator<DirectMemoryRegion> it = regions.iterator(); it.hasNext(); ) { DirectMemoryRegion chunk = it.next(); if (deallocate) { GridUnsafe.freeMemory(chunk.address()); // Safety. it.remove(); } } if (!deallocate) used = 0; } }
/** * Release unpooled memory chunk. * * @param memPtr Memory pointer. */ public static void releaseUnpooled(long memPtr) { assert !isExternal(memPtr) : "Attempt to release external memory chunk directly: " + memPtr; assert !isPooled(memPtr) : "Attempt to release pooled memory chunk directly: " + memPtr; GridUnsafe.freeMemory(data(memPtr)); GridUnsafe.freeMemory(memPtr); }
/** * Internal release procedure. Decreases size of corresponding counter. * * @param ptr Address of memory block to deallocate. * @param size Size of allocated block. * @param cnt Counter to update. */ private void release0(long ptr, long size, AtomicLong cnt) { if (ptr != 0) { if (SAFE_RELEASE) fill(ptr, size, (byte)0xAB); GridUnsafe.freeMemory(ptr); cnt.addAndGet(-size); if (lsnr != null) lsnr.onEvent(RELEASE); } }
/** {@inheritDoc} */ @Override protected void afterTest() throws Exception { for (Long ptr : ptrs) GridUnsafe.freeMemory(ptr); super.afterTest(); }
/** {@inheritDoc} */ @Override protected void afterTest() throws Exception { for (Long ptr : ptrs) GridUnsafe.freeMemory(ptr); super.afterTest(); }
/** {@inheritDoc} */ @Override protected void afterTest() throws Exception { super.afterTest(); // Cleanup allocated objects. for (Long ptr : ptrs) GridUnsafe.freeMemory(ptr); ptrs.clear(); }
/** {@inheritDoc} */ @Override protected void afterTest() throws Exception { super.afterTest(); // Cleanup allocated objects. for (Long ptr : ptrs) GridUnsafe.freeMemory(ptr); ptrs.clear(); }
/** * @param tester map test code * @param cap required map capacity. */ private void withMap(Consumer<RobinHoodBackwardShiftHashMap> tester, int cap) { long memSize = RobinHoodBackwardShiftHashMap.requiredMemoryByBuckets(cap); long addr = GridUnsafe.allocateMemory(memSize); RobinHoodBackwardShiftHashMap map = new RobinHoodBackwardShiftHashMap(addr, memSize); boolean success = false; try { tester.accept(map); success = true; } finally { if (!success) System.err.println(map.dump()); GridUnsafe.freeMemory(addr); } }
/** * 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); }
GridUnsafe.freeMemory(ptr);
GridUnsafe.freeMemory(tmpAddr);
GridUnsafe.freeMemory(ptr);
GridUnsafe.freeMemory(binObjOffheap0.offheapAddress()); binObjOffheap0 = null; GridUnsafe.freeMemory(binObjOffheap1.offheapAddress()); binObjOffheap1 = null; GridUnsafe.freeMemory(binObjWithRawOffheap0.offheapAddress()); binObjOffheap1 = null; GridUnsafe.freeMemory(binObjWithRawOffheap1.offheapAddress()); binObjOffheap1 = null; GridUnsafe.freeMemory(binObjRawOffheap0.offheapAddress()); binObjOffheap1 = null; GridUnsafe.freeMemory(binObjRawOffheap1.offheapAddress()); binObjOffheap1 = null;
GridUnsafe.freeMemory(ptr); GridUnsafe.freeMemory(ptr1); GridUnsafe.freeMemory(ptr2);
/** * Release unpooled memory chunk. * * @param memPtr Memory pointer. */ public static void releaseUnpooled(long memPtr) { assert !isExternal(memPtr) : "Attempt to release external memory chunk directly: " + memPtr; assert !isPooled(memPtr) : "Attempt to release pooled memory chunk directly: " + memPtr; GridUnsafe.freeMemory(data(memPtr)); GridUnsafe.freeMemory(memPtr); }