/** * @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(); } }
int hash = Entry.hash(entryAddr, mem); long next = Entry.nextAddress(entryAddr, mem); Entry.nextAddress(entryAddr, newFirst, mem);
private void advance() { assert bin.isEmpty(); long tblEnd = tblAddr + memCap; for (long binAddr = tblAddr; binAddr < tblEnd; binAddr += 8) { long entryAddr = Bin.first(binAddr, mem); if (entryAddr == 0) continue; while (entryAddr != 0) { // Read key and value bytes. // TODO: GG-8123: Inlined as a workaround. Revert when 7u60 is released. // bin.add(F.t(Entry.readKeyBytes(entryAddr, mem), Entry.readValueBytes(entryAddr, mem))); { int keyLen = Entry.readKeyLength(entryAddr, mem); int valLen = Entry.readValueLength(entryAddr, mem); byte[] valBytes = mem.readBytes(entryAddr + HEADER_SIZE + keyLen, valLen); bin.add(F.t(Entry.readKeyBytes(entryAddr, mem), valBytes)); } entryAddr = Entry.nextAddress(entryAddr, mem); } } }
long next = Entry.nextAddress(cur, mem); if (Entry.keyEquals(cur, keyBytes, mem)) { if (Entry.readValueLength(cur, mem) == valBytes.length) { Entry.writeValueBytes(cur, valBytes, mem); qAddr = Entry.queueAddress(cur, mem); Entry.queueAddress(cur, qAddr, mem); Entry.nextAddress(prev, next, mem); // Unlink. else first = next; qAddr = Entry.queueAddress(cur, mem); Entry.queueAddress(cur, qAddr, mem); relSize = Entry.size(cur, mem); relAddr = cur; lru.touch(qAddr, addr); Entry.write(addr, hash, keyBytes, valBytes, qAddr, first, mem);
int hash = Entry.hash(entryAddr, mem); long next = Entry.nextAddress(entryAddr, mem); Entry.nextAddress(entryAddr, newFirst, mem);
prev = cur; cur = Entry.nextAddress(cur, mem); long qAddr0 = Entry.queueAddress(cur, mem); keyBytes = Entry.readKeyBytes(cur, mem); int keyLen = Entry.readKeyLength(cur, mem); int valLen = Entry.readValueLength(cur, mem); long a; assert qAddr == (a = Entry.queueAddress(cur, mem)) : "Queue node address mismatch " + "[qAddr=" + qAddr + ", entryQueueAddr=" + a + ']'; long next = Entry.nextAddress(cur, mem); Entry.nextAddress(prev, next, mem); // Relink. else { if (next == 0) relSize = Entry.size(cur, mem); relAddr = cur; boolean clear = Entry.clearQueueAddress(cur, qAddr, mem); relSize = Entry.size(cur, mem);
long next = Entry.nextAddress(cur, mem); if (Entry.keyEquals(cur, keyBytes, mem)) { int keyLen = 0; int valLen = 0; keyLen = Entry.readKeyLength(cur, mem); valLen = Entry.readValueLength(cur, mem); Entry.nextAddress(prev, next, mem); // Relink. else { if (next == 0) keyLen = Entry.readKeyLength(cur, mem); valLen = Entry.readValueLength(cur, mem); qAddr = Entry.queueAddress(cur, mem); relSize = Entry.size(cur, mem); relAddr = cur;
Entry.write(addr, hash, keyBytes, valBytes, mem); long first = Bin.first(binAddr, mem); Entry.nextAddress(addr, first, mem); Entry.queueAddress(addr, qAddr, mem);
/** * Releases allocated table. */ void destruct() { lock.writeLock().lock(); try { if (tblAddr == 0) return; for (long binAddr = tblAddr, tblEnd = (tblAddr + memCap); binAddr < tblEnd; binAddr += 8) { long entryAddr = Bin.first(binAddr, mem); if (entryAddr == 0) continue; while (true) { long next = Entry.nextAddress(entryAddr, mem); mem.release(entryAddr, Entry.size(entryAddr, mem)); if (next == 0) break; else entryAddr = next; } } mem.releaseSystem(tblAddr, memCap); } finally { tblAddr = 0; lock.writeLock().unlock(); } }
if (Entry.keyEquals(addr, keyBytes, mem)) { int keyLen = Entry.readKeyLength(addr, mem); int valLen = Entry.readValueLength(addr, mem); addr = Entry.nextAddress(addr, mem);
/** * @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(); } }
/** * @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(); } }
/** * Writes entry. * * @param ptr Pointer. * @param hash Hash. * @param keyBytes Key bytes. * @param valBytes Value bytes. * @param queueAddr Queue address. * @param next Next address. * @param mem Memory. */ static void write(long ptr, int hash, byte[] keyBytes, byte[] valBytes, long queueAddr, long next, GridUnsafeMemory mem) { hash(ptr, hash, mem); writeKeyLength(ptr, keyBytes.length, mem); writeValueLength(ptr, valBytes.length, mem); queueAddress(ptr, queueAddr, mem); nextAddress(ptr, next, mem); writeKeyBytes(ptr, keyBytes, mem); writeValueBytes(ptr, keyBytes.length, valBytes, mem); }
private void advance() { assert bin.isEmpty(); long tblEnd = tblAddr + memCap; for (long binAddr = tblAddr; binAddr < tblEnd; binAddr += 8) { long entryAddr = Bin.first(binAddr, mem); if (entryAddr == 0) continue; while (entryAddr != 0) { // Read key and value bytes. // TODO: GG-8123: Inlined as a workaround. Revert when 7u60 is released. // bin.add(F.t(Entry.readKeyBytes(entryAddr, mem), Entry.readValueBytes(entryAddr, mem))); { int keyLen = Entry.readKeyLength(entryAddr, mem); int valLen = Entry.readValueLength(entryAddr, mem); byte[] valBytes = mem.readBytes(entryAddr + HEADER_SIZE + keyLen, valLen); bin.add(F.t(Entry.readKeyBytes(entryAddr, mem), valBytes)); } entryAddr = Entry.nextAddress(entryAddr, mem); } } }
int keyLen = Entry.readKeyLength(entryAddr, mem); int valLen = Entry.readValueLength(entryAddr, mem); entryAddr = Entry.nextAddress(entryAddr, mem);
/** * Writes entry. * * @param ptr Pointer. * @param hash Hash. * @param keyBytes Key bytes. * @param valBytes Value bytes. * @param mem Memory. */ static void write(long ptr, int hash, byte[] keyBytes, byte[] valBytes, GridUnsafeMemory mem) { hash(ptr, hash, mem); writeKeyLength(ptr, keyBytes.length, mem); writeValueLength(ptr, valBytes.length, mem); writeKeyBytes(ptr, keyBytes, mem); writeValueBytes(ptr, keyBytes.length, valBytes, mem); }
/** * @param hash Hash. * @param keyBytes Key bytes. * @return {@code True} if contains key. */ boolean contains(int hash, byte[] keyBytes) { long binAddr = readLock(hash); try { long addr = Bin.first(binAddr, mem); while (addr != 0) { if (Entry.keyEquals(addr, keyBytes, mem)) return true; addr = Entry.nextAddress(addr, mem); } return false; } finally { readUnlock(); } }
/** * 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 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); }
/** * @param ptr Pointer. * @param valBytes Value bytes. * @param mem Memory. */ static void writeValueBytes(long ptr, byte[] valBytes, GridUnsafeMemory mem) { writeValueBytes(ptr, readKeyLength(ptr, mem), valBytes, mem); }