/** * Reads cache group ID from the page at the given absolute pointer. * * @param absPtr Absolute memory pointer to the page header. * @return Cache group ID written to the page. */ private static int readPageGroupId(final long absPtr) { return GridUnsafe.getInt(absPtr + PAGE_CACHE_ID_OFFSET); }
/** {@inheritDoc} */ @Override protected int readIntFast() { long addr = ptr + pos; return BIG_ENDIAN ? GridUnsafe.getIntLE(addr) : GridUnsafe.getInt(addr); }
/** * Gets flags for the given memory chunk. * * @param memPtr Memory pointer. * @return Flags. */ public static int flags(long memPtr) { return GridUnsafe.getInt(memPtr + MEM_HDR_OFF_FLAGS); }
/** {@inheritDoc} */ @Override protected int readIntPositioned0(int pos) { long off = GridUnsafe.BYTE_ARR_OFF + pos; return BIG_ENDIAN ? GridUnsafe.getIntLE(data, off) : GridUnsafe.getInt(data, off); } }
/** * @param base address of current cell. * @return number of ideal bucket (cell) to store this value. */ private int getIdealBucket(long base) { return getInt(base + IDEAL_BUCKET_OFFSET); }
/** {@inheritDoc} */ @Override public int readInt() throws IOException { fromStream(4); long off = BYTE_ARR_OFF + offset(4); return BIG_ENDIAN ? GridUnsafe.getIntLE(buf, off) : GridUnsafe.getInt(buf, off); }
/** * @return Total number of acquired pages. */ private int acquiredPages() { return GridUnsafe.getInt(acquiredPagesPtr); }
/** * Gets capacity for the given memory chunk. * * @param memPtr Memory pointer. * @return Capacity. */ public static int capacity(long memPtr) { return GridUnsafe.getInt(memPtr + MEM_HDR_OFF_CAP); }
/** * @param base Entry base address. * @return Group ID stored in entry. */ private int getGrpId(long base) { return getInt(base + GRP_ID_OFFSET); }
/** * @param base Bucket base address. * @return Entry version associated with bucket. */ private int getVersion(long base) { return getInt(base + VERSION_OFFSET); }
/** * Gets length for the given memory chunk. * * @param memPtr Memory pointer. * @return Length. */ public static int length(long memPtr) { return GridUnsafe.getInt(memPtr + MEM_HDR_OFF_LEN); }
/** {@inheritDoc} */ @Override public int readInt() { lastFinished = buf.remaining() >= 4; if (lastFinished) { int pos = buf.position(); buf.position(pos + 4); return GridUnsafe.getInt(heapArr, baseOff + pos); } else return 0; }
/** * @param ptr Pointer to update. * @param delta Delta. */ private static int updateAtomicInt(long ptr, int delta) { while (true) { int old = GridUnsafe.getInt(ptr); int updated = old + delta; if (GridUnsafe.compareAndSwapInt(null, ptr, old, updated)) return updated; } }
/** * */ private void decrementSize() { GridUnsafe.putInt(valPtr, GridUnsafe.getInt(valPtr) - 1); } }
/** {@inheritDoc} */ @Override public int getInt(int idx) { ensure(idx, 4); return GridUnsafe.getInt(ptr + idx); }
/** * */ private void incrementSize() { GridUnsafe.putInt(valPtr, GridUnsafe.getInt(valPtr) + 1); }
/** {@inheritDoc} */ @Override public int readInt() { ensureEnoughData(4); int res = GridUnsafe.getInt(data + pos); shift(4); return res; }
/** * @param idx cell index, normalized. * @return {@code true} if cell with index idx has state 'Empty'. */ private boolean isEmpty(int idx) { long base = entryBase(idx); int grpId = GridUnsafe.getInt(base); long pageId = GridUnsafe.getLong(base + PAGE_ID_OFFSET); return isEmpty(grpId, pageId); }
/** {@inheritDoc} */ @Override public void forEach(BiConsumer<FullPageId, Long> act) { for (int i = 0; i < capacity; i++) { if (isValuePresentAt(i)) { long base = entryBase(i); int cacheId = GridUnsafe.getInt(base); long pageId = GridUnsafe.getLong(base + PAGE_ID_OFFSET); long val = GridUnsafe.getLong(base + VALUE_OFFSET); act.accept(new FullPageId(pageId, cacheId), val); } } }
/** * @param idx Index to test. * @return {@code True} if value set for index. */ private boolean isValuePresentAt(final int idx) { long base = entryBase(idx); int grpId = GridUnsafe.getInt(base); long pageId = GridUnsafe.getLong(base + PAGE_ID_OFFSET); return !isRemoved(grpId, pageId) && !isEmpty(grpId, pageId); }