/** * @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); }
/** * @param arr Array. * @param off Offset. * @param val Value. */ public static void writeInt(byte[] arr, int off, int val) { long pos = GridUnsafe.BYTE_ARR_OFF + off; if (BIG_ENDIAN) GridUnsafe.putIntLE(arr, pos, val); else GridUnsafe.putInt(arr, pos, val); }
/** * Writes cache group ID from the page at the given absolute pointer. * * @param absPtr Absolute memory pointer to the page header. * @param grpId Cache group ID to write. */ private static void pageGroupId(final long absPtr, final int grpId) { GridUnsafe.putInt(absPtr + PAGE_CACHE_ID_OFFSET, grpId); }
/** * @param ptr Pointer. * @param off Offset. * @param val Value. */ public static void writeInt(long ptr, int off, int val) { if (BIG_ENDIAN) GridUnsafe.putIntLE(ptr + off, val); else GridUnsafe.putInt(ptr + off, val); }
/** * @param base Bucket base address. * @param ver Entry version to set in bucket. */ private void setVersion(long base, int ver) { putInt(base + VERSION_OFFSET, ver); }
/** {@inheritDoc} */ @Override public void unsafeWriteInt(int pos, int val) { long addr = ptr + pos; if (BIG_ENDIAN) GridUnsafe.putIntLE(addr, val); else GridUnsafe.putInt(addr, val); }
/** * Changes collection size. * * @param sz new size to set. */ private void setSize(int sz) { putInt(baseAddr + MAPSIZE_OFFSET, sz); }
/** {@inheritDoc} */ @Override protected void writeIntFast(int val) { long off = GridUnsafe.BYTE_ARR_OFF + pos; if (BIG_ENDIAN) GridUnsafe.putIntLE(data, off, val); else GridUnsafe.putInt(data, off, val); }
/** * @param ptr Pointer. * @param v Integer value. */ public void writeInt(long ptr, int v) { GridUnsafe.putInt(ptr, v); }
/** {@inheritDoc} */ @Override public void unsafeWriteInt(int val) { long addr = ptr + pos; if (BIG_ENDIAN) GridUnsafe.putIntLE(addr, val); else GridUnsafe.putInt(addr, val); shift(4); }
/** * Sets length for the given memory chunk. * * @param memPtr Memory pointer. * @param len Length. */ public static void length(long memPtr, int len) { GridUnsafe.putInt(memPtr + MEM_HDR_OFF_LEN, len); }
/** * @param addr Address. * @param off Offset. * @param v Value. */ public static void putInt(long addr, int off, int v) { assert addr > 0 : addr; assert off >= 0; GridUnsafe.putInt(addr + off, v); }
/** * @param marker Marker. * @param ptr Pointer. * @param size Size. */ private void add(byte marker, long ptr, int size) { buf[off++] = marker; GridUnsafe.putInt(buf, GridUnsafe.BYTE_ARR_OFF + off, size); off += 4; GridUnsafe.copyOffheapHeap(ptr, buf, GridUnsafe.BYTE_ARR_OFF + off, size); off += size; }
/** {@inheritDoc} */ @Override public void writeInt(int val) throws IOException { int writePos = ensure(4); GridUnsafe.putInt(buf, BYTE_ARR_OFF + writePos, val); }
/** * */ private void incrementSize() { GridUnsafe.putInt(valPtr, GridUnsafe.getInt(valPtr) + 1); }
/** * Sets capacity for the given memory chunk. * * @param memPtr Memory pointer. * @param cap Capacity. */ public static void capacity(long memPtr, int cap) { assert !isExternal(memPtr) : "Attempt to update external memory chunk capacity: " + memPtr; GridUnsafe.putInt(memPtr + MEM_HDR_OFF_CAP, cap); }
/** * Sets flags for the given memory chunk. * * @param memPtr Memory pointer. * @param flags Flags. */ public static void flags(long memPtr, int flags) { assert !isExternal(memPtr) : "Attempt to update external memory chunk flags: " + memPtr; GridUnsafe.putInt(memPtr + MEM_HDR_OFF_FLAGS, flags); }
/** * @param idx Index to set tag for. * @param tag Tag to set at the given index. */ private void setTagAt(int idx, int tag) { GridUnsafe.putInt(entryBase(idx) + TAG_OFFSET, tag); }
/** {@inheritDoc} */ @Override public void writeFloatArray(float[] val) { int cnt = val.length << 2; ensureCapacity(pos + cnt); long startPos = data + pos; for (float item : val) { GridUnsafe.putInt(startPos, Integer.reverseBytes(Float.floatToIntBits(item))); startPos += 4; } shift(cnt); }
/** * @param absPtr Absolute pointer to initialize. * @param relative Relative pointer to write. */ private static void initNew(long absPtr, long relative) { relative(absPtr, relative); tempBufferPointer(absPtr, INVALID_REL_PTR); GridUnsafe.putLong(absPtr, PAGE_MARKER); GridUnsafe.putInt(absPtr + PAGE_PIN_CNT_OFFSET, 0); }