/** * @param ptr Pointer. * @param mem Memory. * @return Key bytes. */ static byte[] readKeyBytes(long ptr, GridUnsafeMemory mem) { int keyLen = readKeyLength(ptr, mem); return mem.readBytes(ptr + HEADER_SIZE, keyLen); }
/** * Adds entry address to LRU queue. * * @param part Entry Entry partition. * @param addr Entry address. * @param hash Entry hash code. * @return Queue node address. * @throws GridOffHeapOutOfMemoryException If failed. */ long offer(int part, long addr, int hash) throws GridOffHeapOutOfMemoryException { return lrus[incrementAndGet(addIdx, maxIdxCnt)].offer(part, addr, hash); }
/** * @param cnt Count. */ private void checkOffer(int cnt) { init(); for (int i = 0; i < cnt; i++) lru.offer(0, i, i); assertEquals(cnt, lru.size()); info("Finished check offer for stripes count: " + stripes); }
/** * @param ptr Pointer. * @param mem Memory. * @return Value bytes. */ static byte[] readValueBytes(long ptr, GridUnsafeMemory mem) { int keyLen = readKeyLength(ptr, mem); int valLen = readValueLength(ptr, mem); return mem.readBytes(ptr + HEADER_SIZE + keyLen, valLen); }
/** * */ private void init() { mem = new GridUnsafeMemory(memSize); lru = new GridUnsafeLru(stripes, mem); }
/** * @param page Page. */ private void deallocate(Page page) { assert page != null; mem.release(page.ptr, page.size); }
/** * Checks if keys are equal. * * @param ptr Pointer. * @param keyBytes Key bytes to compare. * @param mem Memory. * @return {@code True} if equal. */ static boolean keyEquals(long ptr, byte[] keyBytes, GridUnsafeMemory mem) { long len = readKeyLength(ptr, mem); return len == keyBytes.length && GridUnsafeMemory.compare(ptr + HEADER_SIZE, keyBytes); } }
/** * @param meta Meta pointer. * @param collision Collision pointer. */ protected void collision(long meta, long collision) { assert meta != collision : meta; mem.writeLong(meta + 24, collision); }
/** * @param valPtr Value page pointer. * @param size Size. */ protected void valueSize(long valPtr, int size) { mem.writeInt(valPtr + 8, size); }
/** {@inheritDoc} */ @Override public byte[] get(int hash, byte[] keyBytes) { return segmentFor(hash).get(hash, keyBytes); }
/** {@inheritDoc} */ @Override public void enableEviction(int hash, byte[] keyBytes) { assert lru != null; segmentFor(hash).enableEviction(hash, keyBytes); }
/** {@inheritDoc} */ @Override public boolean eventListener(GridOffHeapEventListener evtLsnr) { if (this.evtLsnr != null) return false; this.evtLsnr = evtLsnr; for (GridUnsafeMap m : partMap) m.eventListener(evtLsnr); mem.listen(evtLsnr); return true; }
/** {@inheritDoc} */ @Override public boolean contains(int hash, byte[] keyBytes) { return segmentFor(hash).contains(hash, keyBytes); }
/** {@inheritDoc} */ @Override public boolean removex(int hash, byte[] keyBytes) { return segmentFor(hash).removex(hash, keyBytes); }
/** {@inheritDoc} */ @Override public byte[] remove(int hash, byte[] keyBytes) { return segmentFor(hash).remove(hash, keyBytes); }
/** {@inheritDoc} */ @Override public void insert(int hash, byte[] keyBytes, byte[] valBytes) { segmentFor(hash).insert(hash, keyBytes, valBytes); }
/** * Frees space by polling entries from LRU queue. * * @param order Queue stripe order. * @param qAddr Queue node address. * @return Released size. */ int freeSpace(short order, long qAddr) { if (lru == null) return 0; int hash = lru.hash(order, qAddr); return segmentFor(hash).freeSpace(hash, order, qAddr); }
/** * @param meta Meta pointer. * @return Value pointer. */ private long value(long meta) { return mem.readLongVolatile(meta + 8); }