/** * Allocate memory. * * @param cap Capacity. * @return Pointer. */ protected long allocate(int cap) { return GridUnsafe.allocateMemory(cap); }
/** * @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 * 4); GridUnsafe.setMemory(trackingArrPtr, trackingSize * 4, (byte)0); }
/** {@inheritDoc} */ @Override public void start() throws IgniteException { trackingArrPtr = GridUnsafe.allocateMemory(trackingSize * 8); GridUnsafe.setMemory(trackingArrPtr, trackingSize * 8, (byte)0); }
/** * 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; }
ptr = GridUnsafe.allocateMemory(chunkSize);
long ptr = GridUnsafe.allocateMemory(size);
/** * Allocate pool memory. * * @return Pool pointer. */ public static long allocatePool() { long poolPtr = GridUnsafe.allocateMemory(POOL_HDR_LEN); GridUnsafe.setMemory(poolPtr, POOL_HDR_LEN, (byte)0); flags(poolPtr + POOL_HDR_OFF_MEM_1, FLAG_POOLED); flags(poolPtr + POOL_HDR_OFF_MEM_2, FLAG_POOLED); flags(poolPtr + POOL_HDR_OFF_MEM_3, FLAG_POOLED); return poolPtr; }
/** * @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; }
/** * @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); }
/** {@inheritDoc} */ @Override protected BinaryObjectExImpl toBinary(BinaryMarshaller marsh, Object obj) throws Exception { byte[] arr = marsh.marshal(obj); long ptr = GridUnsafe.allocateMemory(arr.length); ptrs.add(ptr); GridUnsafe.copyHeapOffheap(arr, GridUnsafe.BYTE_ARR_OFF, ptr, arr.length); return new BinaryObjectOffheapImpl(ctx, ptr, 0, arr.length); } }
/** * 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; }
/** * Convert binary object to it's final state. * * @param obj Object. * @param offheap Offheap flag. * @return Result. */ private BinaryObjectExImpl convert(BinaryObject obj, boolean offheap) { BinaryObjectExImpl obj0 = (BinaryObjectExImpl)obj; if (offheap) { byte[] arr = obj0.array(); long ptr = GridUnsafe.allocateMemory(arr.length); ptrs.add(ptr); GridUnsafe.copyMemory(arr, GridUnsafe.BYTE_ARR_OFF, null, ptr, arr.length); obj0 = new BinaryObjectOffheapImpl(obj0.context(), ptr, 0, obj0.array().length); } return obj0; }
/** {@inheritDoc} */ @Override protected BinaryObjectExImpl toBinary(BinaryMarshaller marsh, Object obj) throws Exception { byte[] arr = marsh.marshal(obj); long ptr = GridUnsafe.allocateMemory(arr.length); ptrs.add(ptr); GridUnsafe.copyHeapOffheap(arr, GridUnsafe.BYTE_ARR_OFF, ptr, arr.length); return new BinaryObjectOffheapImpl(binaryContext(marsh), ptr, 0, arr.length); } }
long ptr = GridUnsafe.allocateMemory(NUM_TASKS * pageSize);
/** * Internal pooled memory chunk allocation routine. * * @param memPtr Memory pointer. * @param cap Capacity. */ private static void allocatePooled0(long memPtr, int cap) { assert !isExternal(memPtr); assert isPooled(memPtr); assert !isAcquired(memPtr); long data = GridUnsafe.getLong(memPtr); if (data == 0) { // First allocation of the chunk. data = GridUnsafe.allocateMemory(cap); GridUnsafe.putLong(memPtr, data); GridUnsafe.putInt(memPtr + MEM_HDR_OFF_CAP, cap); } else { // Ensure that we have enough capacity. int curCap = capacity(memPtr); if (cap > curCap) { data = GridUnsafe.reallocateMemory(data, cap); GridUnsafe.putLong(memPtr, data); GridUnsafe.putInt(memPtr + MEM_HDR_OFF_CAP, cap); } } flags(memPtr, FLAG_POOLED | FLAG_ACQUIRED); }
assert snapshot.pageData().length <= pageSize() : snapshot.pageData().length; tmpAddr = GridUnsafe.allocateMemory(pageSize());
long ptr = GridUnsafe.allocateMemory(arr.length + 5);
/** * Allocate pool memory. * * @return Pool pointer. */ public static long allocatePool() { long poolPtr = GridUnsafe.allocateMemory(POOL_HDR_LEN); GridUnsafe.setMemory(poolPtr, POOL_HDR_LEN, (byte)0); flags(poolPtr + POOL_HDR_OFF_MEM_1, FLAG_POOLED); flags(poolPtr + POOL_HDR_OFF_MEM_2, FLAG_POOLED); flags(poolPtr + POOL_HDR_OFF_MEM_3, FLAG_POOLED); return poolPtr; }