/** * */ private void init() { mem = new GridUnsafeMemory(memSize); lru = new GridUnsafeLru(stripes, mem); }
/** {@inheritDoc} */ @Override public void destruct() { for (GridUnsafeMap m : partMap) m.destruct(); if (lru != null) lru.destruct(); }
@Override public void run() { int id = idGen.getAndIncrement(); int step = 10; assert cnt % step == 0; int start = id * cnt; int end = start + cnt; Collection<Long> set = new HashSet<>(step); for (int i = start; i < end; i++) lru.offer(0, i, i); for (int i = start; i < end; i += step) { for (int j = 0; j < step; j++) { long qAddr = lru.prePoll(); assertTrue(qAddr != 0); assertTrue(set.add(qAddr)); } for (long qAddr : set) lru.poll(qAddr); set.clear(); } } }, 10);
@Override public void lruPoll(int size) { if (lru == null) return; int left = size; while (left > 0) { // Pre-poll outside of lock. long qAddr = lru.prePoll(); if (qAddr == 0) return; // LRU is empty. short order = lru.order(qAddr); int part = lru.partition(order, qAddr); int released = partMap[part].freeSpace(order, qAddr); if (released == 0) return; left -= released; } } }
@Override public void lruPoll(int size) { if (lru == null) return; int left = size; while (left > 0) { // Pre-poll outside of lock. long qAddr = lru.prePoll(); if (qAddr == 0) return; // LRU is empty. short order = lru.order(qAddr); int released = freeSpace(order, qAddr); if (released == 0) return; left -= released; } } };
/** * @param cnt Count. */ private void checkPoll(int cnt) { init(); int step = 10; assert cnt % step == 0; Collection<Long> set = new HashSet<>(step); for (int i = 0; i < cnt; i++) lru.offer(0, i, i); assertEquals(cnt, lru.size()); for (int i = 0; i < cnt; i += step) { for (int j = 0; j < step; j++) { long qAddr = lru.prePoll(); assertTrue(qAddr != 0); assertTrue(set.add(qAddr)); } for (long qAddr : set) lru.poll(qAddr); set.clear(); } assertEquals(0, lru.size()); }
/** * Gets number of elements in LRU queue. * * @return Number of elements in LRU queue. */ public long lruSize() { return lru.size(); }
/** * @param hash Hash. * @param keyBytes Key bytes. */ void enableEviction(int hash, byte[] keyBytes) { assert lru != null; long binAddr = writeLock(hash); try { long addr = Bin.first(binAddr, mem); while (addr != 0) { if (Entry.keyEquals(addr, keyBytes, mem)) { long qAddr = Entry.queueAddress(addr, mem); if (qAddr == 0) { qAddr = lru.offer(part, addr, hash); Entry.queueAddress(addr, qAddr, mem); } return; } addr = Entry.nextAddress(addr, mem); } } finally { writeUnlock(); } }
/** * @param hash Hash. * @param keyBytes Key bytes. * @return Value pointer. */ @Nullable IgniteBiTuple<Long, Integer> valuePointer(int hash, byte[] keyBytes) { long binAddr = readLock(hash); try { long addr = Bin.first(binAddr, mem); while (addr != 0) { if (Entry.keyEquals(addr, keyBytes, mem)) { if (lru != null) { long qAddr = Entry.queueAddress(addr, mem); if (qAddr != 0 && Entry.clearQueueAddress(addr, qAddr, mem)) lru.remove(qAddr); } int keyLen = Entry.readKeyLength(addr, mem); int valLen = Entry.readValueLength(addr, mem); return new IgniteBiTuple<>(addr + HEADER_SIZE + keyLen, valLen); } addr = Entry.nextAddress(addr, mem); } return null; } finally { readUnlock(); } }
/** * Gets number of LRU stripes. * * @return Number of LRU stripes. */ public short lruStripes() { return lru.concurrency(); }
/** * 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); }
@Override public void lruPoll(int size) { if (lru == null) return; int left = size; while (left > 0) { // Pre-poll outside of lock. long qAddr = lru.prePoll(); if (qAddr == 0) return; // LRU is empty. short order = lru.order(qAddr); int part = lru.partition(order, qAddr); int released = partMap[part].freeSpace(order, qAddr); if (released == 0) return; left -= released; } } }
/** * Gets number of elements in LRU queue. * * @return Number of elements in LRU queue. */ public long lruSize() { return lru.size(); }
@Override public void lruPoll(int size) { if (lru == null) return; int left = size; while (left > 0) { // Pre-poll outside of lock. long qAddr = lru.prePoll(); if (qAddr == 0) return; // LRU is empty. short order = lru.order(qAddr); int released = freeSpace(order, qAddr); if (released == 0) return; left -= released; } } };