synchronized boolean remove(long hash, K key) { int h = smallMap.startSearch(hash); boolean found = false; while (true) { int pos = smallMap.nextPos(); if (pos < 0) { break; } bytes.storePositionAndSize(store, pos * smallEntrySize, smallEntrySize); K key2 = getKey(); if (equals(key, key2)) { usedSet.clear(pos); smallMap.remove(h, pos); found = true; this.size--; break; } } K key2 = key instanceof CharSequence ? (K) key.toString() : key; DirectStore remove = map.remove(key2); if (remove == null) return found; offHeapUsed -= remove.size(); remove.free(); this.size--; return true; }
synchronized V get(long hash, K key, V value) { smallMap.startSearch(hash); while (true) { int pos = smallMap.nextPos(); if (pos < 0) { K key2 = key instanceof CharSequence ? (K) key.toString() : key; final DirectStore store = map.get(key2); if (store == null) return null; bytes.storePositionAndSize(store, 0, store.size()); break; } else { bytes.storePositionAndSize(store, pos * smallEntrySize, smallEntrySize); K key2 = getKey(); if (equals(key, key2)) break; } } if (bytesMarshallable) { try { V v = value == null ? (V) NativeBytes.UNSAFE.allocateInstance(vClass) : value; ((BytesMarshallable) v).readMarshallable(bytes); return v; } catch (InstantiationException e) { throw new AssertionError(e); } } return (V) bytes.readObject(); }
void clear() { usedSet.clear(); smallMap.clear(); for (DirectStore directStore : map.values()) { directStore.free(); } map.clear(); size = 0; }
Segment( HugeConfig config, Hasher hasher, boolean csKey, boolean bytesMarshallable, Class<V> vClass) { this.csKey = csKey; this.hasher = hasher; this.bytesMarshallable = bytesMarshallable; this.vClass = vClass; smallEntrySize = (config.getSmallEntrySize() + 7) & ~7; // round to next multiple of 8. entriesPerSegment = config.getEntriesPerSegment(); store = new DirectStore(bmf, smallEntrySize * entriesPerSegment, false); usedSet = new BitSet(config.getEntriesPerSegment()); smallMap = new IntIntMultiMap(entriesPerSegment * 2); tmpBytes = new DirectStore(bmf, 64 * smallEntrySize, false).createSlice(); offHeapUsed = tmpBytes.capacity() + store.size(); sbKey = csKey ? new StringBuilder() : null; }
public DirectBitSet create(long size) { return wrap(DirectStore.allocate((size + 7) >>> 3).bytes()); }
synchronized void put(long hash, K key, V value, boolean ifPresent, boolean ifAbsent) { // search for the previous entry int h = smallMap.startSearch(hash); boolean foundSmall = false, foundLarge = false; while (true) { int pos = smallMap.nextPos(); if (pos < 0) { K key2 = key instanceof CharSequence ? (K) key.toString() : key; final DirectStore store = map.get(key2); if (store == null) { if (ifPresent && !ifAbsent) return; break; } if (ifAbsent) return; bytes.storePositionAndSize(store, 0, store.size()); foundLarge = true; break; } else { bytes.storePositionAndSize(store, pos * smallEntrySize, smallEntrySize); K key2 = getKey(); if (equals(key, key2)) { if (ifAbsent && !ifPresent) return; foundSmall = true; break; } } } tmpBytes.clear(); if (csKey) //noinspection ConstantConditions tmpBytes.writeUTFΔ((CharSequence) key); else tmpBytes.writeObject(key); long startOfValuePos = tmpBytes.position(); if (bytesMarshallable) ((BytesMarshallable) value).writeMarshallable(tmpBytes); else tmpBytes.writeObject(value); long size = tmpBytes.position(); if (size <= smallEntrySize) { if (foundSmall) { bytes.position(0); bytes.write(tmpBytes, 0, size); return; } else if (foundLarge) { remove(hash, key); } // look for a free spot. int position = h & (entriesPerSegment - 1); int free = usedSet.nextClearBit(position); if (free >= entriesPerSegment) free = usedSet.nextClearBit(0); if (free < entriesPerSegment) { bytes.storePositionAndSize(store, free * smallEntrySize, smallEntrySize); bytes.write(tmpBytes, 0, size); smallMap.put(h, free); usedSet.set(free); this.size++; return; } } if (foundSmall) { remove(hash, key); } else if (foundLarge) { // can it be reused. if (bytes.capacity() <= size || bytes.capacity() - size < (size >> 3)) { bytes.write(tmpBytes, startOfValuePos, size); return; } remove(hash, key); } size = size - startOfValuePos; DirectStore store = new DirectStore(bmf, size); bytes.storePositionAndSize(store, 0, size); bytes.write(tmpBytes, startOfValuePos, size); K key2 = key instanceof CharSequence ? (K) key.toString() : key; map.put(key2, store); offHeapUsed += size; this.size++; }