org.neo4j.kernel.impl.util.collection.MutableLinearProbeLongHashSet Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-kernel Show documentation
Show all versions of neo4j-kernel Show documentation
Neo4j kernel is a lightweight, embedded Java database designed to
store data structured as graphs rather than tables. For more
information, see http://neo4j.org.
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [https://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see
* - It is not thread-safe
*
- It has to be closed to prevent native memory leakage
*
- Iterators returned by this set are fail-fast
*
*/
class MutableLinearProbeLongHashSet extends AbstractLinearProbeLongHashSet implements MutableLongSet, Resource {
static final int DEFAULT_CAPACITY = 32;
static final int REMOVALS_RATIO = 4;
private static final double LOAD_FACTOR = 0.75;
private final MemoryAllocator allocator;
private final MemoryTracker memoryTracker;
private final MutableMultimap frozenCopies = Multimaps.mutable.list.empty();
private int resizeOccupancyThreshold;
private int resizeRemovalsThreshold;
private int removals;
private boolean frozen;
MutableLinearProbeLongHashSet(MemoryAllocator allocator, MemoryTracker memoryTracker) {
this.allocator = requireNonNull(allocator);
this.memoryTracker = memoryTracker;
allocateMemory(DEFAULT_CAPACITY);
}
@Override
public boolean add(long element) {
++modCount;
if (element == 0) {
final boolean hadZero = hasZero;
hasZero = true;
return hadZero != hasZero;
}
if (element == 1) {
final boolean hadOne = hasOne;
hasOne = true;
return hadOne != hasOne;
}
return addToMemory(element);
}
@Override
public boolean addAll(long... elements) {
++modCount;
final int prevSize = size();
for (final long element : elements) {
add(element);
}
return prevSize != size();
}
@Override
public boolean addAll(LongIterable elements) {
++modCount;
final int prevSize = size();
elements.forEach(this::add);
return prevSize != size();
}
@Override
public boolean remove(long element) {
++modCount;
if (element == 0) {
final boolean hadZero = hasZero;
hasZero = false;
return hadZero != hasZero;
}
if (element == 1) {
final boolean hadOne = hasOne;
hasOne = false;
return hadOne != hasOne;
}
return removeFromMemory(element);
}
@Override
public boolean removeAll(LongIterable elements) {
++modCount;
final int prevSize = size();
elements.forEach(this::remove);
return prevSize != size();
}
@Override
public boolean removeAll(long... elements) {
++modCount;
final int prevSize = size();
for (final long element : elements) {
remove(element);
}
return prevSize != size();
}
@Override
public boolean retainAll(LongIterable elements) {
throw new UnsupportedOperationException();
}
@Override
public boolean retainAll(long... source) {
throw new UnsupportedOperationException();
}
@Override
public void clear() {
++modCount;
copyIfFrozen();
memory.clear();
hasZero = false;
hasOne = false;
elementsInMemory = 0;
removals = 0;
}
@Override
public MutableLongIterator longIterator() {
return new FailFastIterator();
}
@Override
public void close() {
++modCount;
if (memory != null) {
frozenCopies.forEachKeyMultiValues((mem, copies) -> {
mem.free(memoryTracker);
copies.forEach(FrozenCopy::invalidate);
});
if (!frozenCopies.containsKey(memory)) {
memory.free(memoryTracker);
}
memory = null;
frozenCopies.clear();
}
}
@Override
public MutableLongSet tap(LongProcedure procedure) {
each(procedure);
return this;
}
@Override
public MutableLongSet with(long element) {
add(element);
return this;
}
@Override
public MutableLongSet without(long element) {
remove(element);
return this;
}
@Override
public MutableLongSet withAll(LongIterable elements) {
addAll(elements);
return this;
}
@Override
public MutableLongSet withoutAll(LongIterable elements) {
removeAll(elements);
return this;
}
@Override
public MutableLongSet asUnmodifiable() {
return new UnmodifiableLongSet(this);
}
@Override
public MutableLongSet asSynchronized() {
return new SynchronizedLongSet(this);
}
@Override
public LongSet freeze() {
frozen = true;
final FrozenCopy frozenCopy = new FrozenCopy();
frozenCopies.put(memory, frozenCopy);
return frozenCopy;
}
@Override
public ImmutableLongSet toImmutable() {
throw new UnsupportedOperationException();
}
private boolean removeFromMemory(long element) {
final int idx = indexOf(element);
final long valueAtIdx = memory.readLong((long) idx * Long.BYTES);
if (valueAtIdx != element) {
return false;
}
copyIfFrozen();
memory.writeLong((long) idx * Long.BYTES, REMOVED);
--elementsInMemory;
++removals;
if (removals >= resizeRemovalsThreshold) {
rehashWithoutGrow();
}
return true;
}
private boolean addToMemory(long element) {
final int idx = indexOf(element);
final long valueAtIdx = valueAt(idx);
if (valueAtIdx == element) {
return false;
}
if (valueAtIdx == REMOVED) {
--removals;
}
copyIfFrozen();
memory.writeLong((long) idx * Long.BYTES, element);
++elementsInMemory;
if (elementsInMemory >= resizeOccupancyThreshold) {
growAndRehash();
}
return true;
}
@VisibleForTesting
void growAndRehash() {
final int newCapacity = capacity * 2;
if (newCapacity < capacity) {
throw new RuntimeException("LongSet reached capacity limit");
}
rehash(newCapacity);
}
@VisibleForTesting
void rehashWithoutGrow() {
rehash(capacity);
}
private void allocateMemory(int newCapacity) {
requirePowerOfTwo(newCapacity);
capacity = newCapacity;
resizeOccupancyThreshold = (int) (newCapacity * LOAD_FACTOR);
resizeRemovalsThreshold = newCapacity / REMOVALS_RATIO;
memory = allocator.allocate((long) newCapacity * Long.BYTES, true, memoryTracker);
}
private void rehash(int newCapacity) {
final int prevCapacity = capacity;
final Memory prevMemory = memory;
elementsInMemory = 0;
removals = 0;
allocateMemory(newCapacity);
for (int i = 0; i < prevCapacity; i++) {
final long value = prevMemory.readLong((long) i * Long.BYTES);
if (isRealValue(value)) {
add(value);
}
}
prevMemory.free(memoryTracker);
}
private void copyIfFrozen() {
if (frozen) {
frozen = false;
memory = memory.copy(memoryTracker);
}
}
class FrozenCopy extends AbstractLinearProbeLongHashSet {
FrozenCopy() {
super(MutableLinearProbeLongHashSet.this);
}
@Override
public LongSet union(LongSet set) {
throw new UnsupportedOperationException();
}
@Override
public LongSet intersect(LongSet set) {
throw new UnsupportedOperationException();
}
@Override
public LongSet difference(LongSet set) {
throw new UnsupportedOperationException();
}
@Override
public LongSet symmetricDifference(LongSet set) {
throw new UnsupportedOperationException();
}
@Override
public LongSet freeze() {
return this;
}
@Override
public ImmutableLongSet toImmutable() {
throw new UnsupportedOperationException();
}
void invalidate() {
++FrozenCopy.this.modCount;
}
}
}