mirror of
https://github.com/OpenHFT/Chronicle-Map.git
synced 2021-09-13 01:26:12 +00:00
2042 lines
59 KiB
Java
2042 lines
59 KiB
Java
/*
|
|
* Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package net.openhft.chronicle.map;
|
|
|
|
import net.openhft.chronicle.hash.hashing.LongHashFunction;
|
|
import net.openhft.chronicle.hash.locks.IllegalInterProcessLockStateException;
|
|
import net.openhft.chronicle.hash.locks.InterProcessLock;
|
|
import net.openhft.chronicle.hash.serialization.BytesReader;
|
|
import net.openhft.chronicle.hash.serialization.internal.BytesBytesInterop;
|
|
import net.openhft.chronicle.hash.serialization.internal.DelegatingMetaBytesInterop;
|
|
import net.openhft.chronicle.hash.serialization.internal.MetaBytesInterop;
|
|
import net.openhft.lang.collection.DirectBitSet;
|
|
import net.openhft.lang.collection.SingleThreadedDirectBitSet;
|
|
import net.openhft.lang.io.ByteBufferBytes;
|
|
import net.openhft.lang.io.Bytes;
|
|
import net.openhft.lang.io.MultiStoreBytes;
|
|
import net.openhft.lang.threadlocal.ThreadLocalCopies;
|
|
import org.jetbrains.annotations.NotNull;
|
|
|
|
import java.lang.ref.Reference;
|
|
import java.lang.ref.ReferenceQueue;
|
|
import java.lang.ref.WeakReference;
|
|
import java.nio.ByteBuffer;
|
|
import java.util.ArrayList;
|
|
import java.util.ConcurrentModificationException;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.locks.Condition;
|
|
|
|
import static net.openhft.chronicle.map.VanillaContext.SearchState.*;
|
|
import static net.openhft.lang.io.NativeBytes.UNSAFE;
|
|
|
|
class VanillaContext<K, KI, MKI extends MetaBytesInterop<K, ? super KI>,
|
|
V, VI, MVI extends MetaBytesInterop<V, ? super VI>>
|
|
implements MapKeyContext<K, V> {
|
|
|
|
static interface ContextFactory<T extends VanillaContext> {
|
|
T createContext(VanillaContext root, int indexInContextCache);
|
|
T createRootContext();
|
|
Class<T> contextClass();
|
|
}
|
|
|
|
static final ThreadLocal<VanillaContext> threadLocalContextCache =
|
|
new ThreadLocal<>();
|
|
|
|
public static <T extends VanillaContext> T get(ContextFactory<T> contextFactory) {
|
|
VanillaContext cache = threadLocalContextCache.get();
|
|
if (cache != null)
|
|
return (T) cache.getContext(contextFactory);
|
|
T rootContext = contextFactory.createRootContext();
|
|
threadLocalContextCache.set(rootContext);
|
|
return rootContext;
|
|
}
|
|
|
|
enum VanillaChronicleMapContextFactory implements ContextFactory<VanillaContext> {
|
|
INSTANCE;
|
|
|
|
@Override
|
|
public VanillaContext createContext(VanillaContext root,
|
|
int indexInContextCache) {
|
|
return new VanillaContext(root, indexInContextCache);
|
|
}
|
|
|
|
@Override
|
|
public VanillaContext createRootContext() {
|
|
return new VanillaContext();
|
|
}
|
|
|
|
@Override
|
|
public Class<VanillaContext> contextClass() {
|
|
return VanillaContext.class;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// Inner state
|
|
final ArrayList<VanillaContext> contexts;
|
|
final ReferenceQueue<ChronicleMap> mapAndContextLocalsQueue;
|
|
final Thread owner;
|
|
final ThreadLocalCopies copies;
|
|
final VanillaContext<K, KI, MKI, V, VI, MVI> contextCache;
|
|
final int indexInContextCache;
|
|
boolean used;
|
|
|
|
VanillaContext() {
|
|
contexts = new ArrayList<>(1);
|
|
contextCache = this;
|
|
indexInContextCache = 0;
|
|
contexts.add(this);
|
|
mapAndContextLocalsQueue = new ReferenceQueue<>();
|
|
owner = Thread.currentThread();
|
|
copies = new ThreadLocalCopies();
|
|
used = true;
|
|
}
|
|
|
|
VanillaContext(VanillaContext contextCache, int indexInContextCache) {
|
|
contexts = null;
|
|
mapAndContextLocalsQueue = null;
|
|
owner = Thread.currentThread();
|
|
copies = new ThreadLocalCopies();
|
|
this.contextCache = contextCache;
|
|
this.indexInContextCache = indexInContextCache;
|
|
}
|
|
|
|
<T extends VanillaContext> T getContext(ContextFactory<T> contextFactory) {
|
|
for (VanillaContext context : contexts) {
|
|
if (context.getClass() == contextFactory.contextClass() &&
|
|
!context.used) {
|
|
context.used = true;
|
|
return (T) context;
|
|
}
|
|
}
|
|
if (contexts.size() > (1 << 16)) {
|
|
throw new IllegalStateException("More than " + (1 << 16) +
|
|
" nested ChronicleHash contexts are not supported. Very probable that " +
|
|
"you simply forgot to close context somewhere (recommended to use " +
|
|
"try-with-resources statement). " +
|
|
"Otherwise this is a bug, please report with this " +
|
|
"stack trace on https://github.com/OpenHFT/Chronicle-Map/issues");
|
|
}
|
|
T context = contextFactory.createContext(this, contexts.size());
|
|
context.used = true;
|
|
contexts.add(context);
|
|
return context;
|
|
}
|
|
|
|
boolean used() {
|
|
return used;
|
|
}
|
|
|
|
void checkOnEachPublicOperation() {
|
|
if (owner != Thread.currentThread()) {
|
|
throw new ConcurrentModificationException(
|
|
"Context shouldn't be accessed from multiple threads");
|
|
}
|
|
if (!used)
|
|
throw new IllegalStateException("Context shouldn't be accessed after close()");
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Map
|
|
VanillaChronicleMap<K, KI, MKI, V, VI, MVI> m;
|
|
|
|
boolean mapInit() {
|
|
return m != null;
|
|
}
|
|
|
|
void initMap(VanillaChronicleMap map) {
|
|
initMapDependencies();
|
|
initMap0(map);
|
|
}
|
|
|
|
void initMapDependencies() {
|
|
// no dependencies
|
|
}
|
|
|
|
void initMap0(VanillaChronicleMap<K, KI, MKI, V, VI, MVI> map) {
|
|
m = map;
|
|
}
|
|
|
|
void checkMapInit() {
|
|
if (!mapInit())
|
|
throw new IllegalStateException("Map should be init");
|
|
}
|
|
|
|
void closeMap() {
|
|
if (!mapInit())
|
|
return;
|
|
closeMapDependants();
|
|
closeMap0();
|
|
}
|
|
|
|
void closeMapDependants() {
|
|
// TODO update dependants
|
|
closeMapAndContextLocals();
|
|
closeSegmentHeader();
|
|
closeKeyModel();
|
|
closeValueModel();
|
|
closeKey();
|
|
closeValue();
|
|
closeKeyReader();
|
|
closeValueReader();
|
|
closeSegmentIndex();
|
|
closeLocks();
|
|
}
|
|
|
|
void closeMap0() {
|
|
m = null;
|
|
}
|
|
|
|
@Override
|
|
public void close() {
|
|
checkOnEachPublicOperation();
|
|
doClose();
|
|
}
|
|
|
|
void doClose() {
|
|
closeMap();
|
|
used = false;
|
|
totalCheckClosed();
|
|
}
|
|
|
|
void totalCheckClosed() {
|
|
assert !mapInit() : "map not closed";
|
|
assert !mapAndContextLocalsInit() : "map&context locals not closed";
|
|
assert !keyModelInit() : "key model not closed";
|
|
assert !keyReaderInit() : "key reader not closed";
|
|
assert !keyInit() : "key not closed";
|
|
assert !keyHashInit() : "key hash not closed";
|
|
assert !segmentIndexInit() : "segment index not closed";
|
|
assert !segmentHeaderInit() : "segment header not closed";
|
|
assert !locksInit() : "locks not closed";
|
|
assert !segmentInit() : "segment not closed";
|
|
assert !hashLookupInit() : "hash lookup not closed";
|
|
assert !keySearchInit() : "key search not closed";
|
|
assert !valueBytesInit() : "value bytes not closed";
|
|
assert !valueReaderInit() : "value reader not closed";
|
|
assert !valueInit() : "value not closed";
|
|
assert !valueModelInit() : "value model not closed";
|
|
assert !newValueInit() : "new value not closed";
|
|
assert !entrySizeInChunksInit() : "entry size in chunks not closed";
|
|
}
|
|
|
|
synchronized void closeFromAnotherThread() {
|
|
if (!used)
|
|
throw new IllegalStateException("Already not used");
|
|
doClose();
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Map and context locals
|
|
final ArrayList<MapAndContextLocalsReference<K, V>> mapAndContextLocalsCache =
|
|
new ArrayList<>(1);
|
|
MapAndContextLocalsReference<K, V> mapAndContextLocalsReference;
|
|
|
|
static class MapAndContextLocals<K, V> {
|
|
K reusableKey;
|
|
V reusableValue;
|
|
MapAndContextLocals(ChronicleMap<K, V> map) {
|
|
// TODO why not using map.newKeyInstance() and newValueInstance()
|
|
if (map.keyClass() == CharSequence.class)
|
|
reusableKey = (K) new StringBuilder();
|
|
if (map.valueClass() == CharSequence.class)
|
|
reusableValue = (V) new StringBuilder();
|
|
}
|
|
}
|
|
|
|
static class MapAndContextLocalsReference<K, V>
|
|
extends WeakReference<ChronicleMap<K, V>> {
|
|
MapAndContextLocals<K, V> mapAndContextLocals;
|
|
public MapAndContextLocalsReference(
|
|
ChronicleMap<K, V> map, ReferenceQueue<ChronicleMap> mapAndContextLocalsQueue,
|
|
MapAndContextLocals<K, V> mapAndContextLocals) {
|
|
super(map, mapAndContextLocalsQueue);
|
|
this.mapAndContextLocals = mapAndContextLocals;
|
|
}
|
|
}
|
|
|
|
boolean mapAndContextLocalsInit() {
|
|
return mapAndContextLocalsReference != null;
|
|
}
|
|
|
|
void initMapAndContextLocals() {
|
|
if (mapAndContextLocalsInit())
|
|
return;
|
|
initMapAndContextLocalsDependencies();
|
|
initMapAndContextLocals0();
|
|
}
|
|
|
|
void initMapAndContextLocalsDependencies() {
|
|
checkMapInit();
|
|
}
|
|
|
|
void initMapAndContextLocals0() {
|
|
pollLocalsQueue();
|
|
int firstEmptyIndex = -1;
|
|
int cacheSize = mapAndContextLocalsCache.size();
|
|
for (int i = 0; i < cacheSize; i++) {
|
|
MapAndContextLocalsReference<K, V> ref = mapAndContextLocalsCache.get(i);
|
|
ChronicleMap<K, V> referencedMap;
|
|
if (ref == null || (referencedMap = ref.get()) == null) {
|
|
if (firstEmptyIndex < 0)
|
|
firstEmptyIndex = i;
|
|
if (ref != null)
|
|
mapAndContextLocalsCache.set(i, null);
|
|
continue;
|
|
}
|
|
if (referencedMap == m) {
|
|
mapAndContextLocalsReference = ref;
|
|
return;
|
|
}
|
|
}
|
|
MapAndContextLocals<K, V> mapAndContextLocals = new MapAndContextLocals<>(m);
|
|
int indexToInsert = firstEmptyIndex < 0 ? cacheSize : firstEmptyIndex;
|
|
MapAndContextLocalsReference<K, V> ref = new MapAndContextLocalsReference<>(m,
|
|
contextCache.mapAndContextLocalsQueue, mapAndContextLocals);
|
|
mapAndContextLocalsReference = ref;
|
|
mapAndContextLocalsCache.add(indexToInsert, ref);
|
|
}
|
|
|
|
void pollLocalsQueue() {
|
|
Reference<? extends ChronicleMap> ref;
|
|
while ((ref = contextCache.mapAndContextLocalsQueue.poll()) != null) {
|
|
// null object pointing to potentially large cached instances, for GC
|
|
((MapAndContextLocalsReference) ref).mapAndContextLocals = null;
|
|
}
|
|
}
|
|
|
|
void closeMapAndContextLocals() {
|
|
if (!mapAndContextLocalsInit())
|
|
return;
|
|
closeMapContextAndLocalsDependants();
|
|
closeMapAndContextLocals0();
|
|
}
|
|
|
|
void closeMapContextAndLocalsDependants() {
|
|
// TODO determine dependencies
|
|
closeValue();
|
|
}
|
|
|
|
void closeMapAndContextLocals0() {
|
|
mapAndContextLocalsReference = null;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Key model
|
|
KI keyInterop;
|
|
|
|
void initKeyModel() {
|
|
if (keyModelInit())
|
|
return;
|
|
initKeyModelDependencies();
|
|
initKeyModel0();
|
|
}
|
|
|
|
boolean keyModelInit() {
|
|
return keyInterop != null;
|
|
}
|
|
|
|
void initKeyModelDependencies() {
|
|
checkMapInit();
|
|
}
|
|
|
|
void initKeyModel0() {
|
|
keyInterop = m.keyInteropProvider.get(copies, m.originalKeyInterop);
|
|
}
|
|
|
|
void closeKeyModel() {
|
|
if (!keyModelInit())
|
|
return;
|
|
closeKeyModelDependants();
|
|
closeKeyModel0();
|
|
}
|
|
|
|
void closeKeyModelDependants() {
|
|
closeKey();
|
|
}
|
|
|
|
void closeKeyModel0() {
|
|
keyInterop = null;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Key reader
|
|
BytesReader<K> keyReader;
|
|
|
|
void initKeyReader() {
|
|
if (keyReaderInit())
|
|
return;
|
|
initKeyReaderDependencies();
|
|
initKeyReader0();
|
|
}
|
|
|
|
boolean keyReaderInit() {
|
|
return keyReader != null;
|
|
}
|
|
|
|
void initKeyReaderDependencies() {
|
|
checkMapInit();
|
|
}
|
|
|
|
void initKeyReader0() {
|
|
keyReader = m.keyReaderProvider.get(copies, m.originalKeyReader);
|
|
}
|
|
|
|
void closeKeyReader() {
|
|
if (!keyReaderInit())
|
|
return;
|
|
closeKeyReaderDependants();
|
|
closeKeyReader0();
|
|
}
|
|
|
|
void closeKeyReaderDependants() {
|
|
closeKey();
|
|
}
|
|
|
|
void closeKeyReader0() {
|
|
keyReader = null;
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// Key
|
|
K key;
|
|
MKI metaKeyInterop;
|
|
long keySize;
|
|
|
|
void initKey(K key) {
|
|
initKeyDependencies();
|
|
initKey0(key);
|
|
}
|
|
|
|
boolean keyInit() {
|
|
return key != null;
|
|
}
|
|
|
|
void initKeyDependencies() {
|
|
initKeyModel();
|
|
}
|
|
|
|
void initKey0(K key) {
|
|
m.checkKey(key);
|
|
this.key = key;
|
|
metaKeyInterop = m.metaKeyInteropProvider.get(
|
|
copies, m.originalMetaKeyInterop, keyInterop, key);
|
|
keySize = metaKeyInterop.size(keyInterop, key);
|
|
}
|
|
|
|
void checkKeyInit() {
|
|
if (!keyInit())
|
|
throw new IllegalStateException("Key should be init");
|
|
}
|
|
|
|
void closeKey() {
|
|
if (!keyInit())
|
|
return;
|
|
closeKeyDependants();
|
|
closeKey0();
|
|
}
|
|
|
|
void closeKeyDependants() {
|
|
closeKeyHash();
|
|
}
|
|
|
|
void closeKey0() {
|
|
key = null;
|
|
metaKeyInterop = null;
|
|
}
|
|
|
|
@Override
|
|
public long keySize() {
|
|
checkOnEachPublicOperation();
|
|
checkKeyInit();
|
|
return keySize;
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public K key() {
|
|
if (keyInit())
|
|
return key;
|
|
initKeySearch();
|
|
initMapAndContextLocals();
|
|
mapAndContextLocalsReference.mapAndContextLocals.reusableKey =
|
|
key0(mapAndContextLocalsReference.mapAndContextLocals.reusableKey);
|
|
assert key != null;
|
|
return key;
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// Key hash
|
|
long hash;
|
|
|
|
void initKeyHash() {
|
|
if (keyHashInit())
|
|
return;
|
|
initKeyHashDependencies();
|
|
initKeyHash0();
|
|
}
|
|
|
|
boolean keyHashInit() {
|
|
return hash != 0;
|
|
}
|
|
|
|
void initKeyHashDependencies() {
|
|
checkKeyInit();
|
|
initKeyModel();
|
|
}
|
|
|
|
void initKeyHash0() {
|
|
hash = metaKeyInterop.hash(keyInterop, LongHashFunction.city_1_1(), key);
|
|
}
|
|
|
|
void closeKeyHash() {
|
|
// don't skip closing if hash = 0 because this is a valid hash also
|
|
closeKeyHashDependants();
|
|
closeKeyHash0();
|
|
}
|
|
|
|
void closeKeyHashDependants() {
|
|
closeSegmentIndex();
|
|
}
|
|
|
|
void closeKeyHash0() {
|
|
hash = 0L;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Segment index
|
|
int segmentIndex = -1;
|
|
|
|
void initSegmentIndex() {
|
|
if (segmentIndexInit())
|
|
return;
|
|
initSegmentIndexDependencies();
|
|
initSegmentIndex0();
|
|
}
|
|
|
|
boolean segmentIndexInit() {
|
|
return segmentIndex >= 0;
|
|
}
|
|
|
|
void initSegmentIndexDependencies() {
|
|
initKeyHash();
|
|
}
|
|
|
|
void initSegmentIndex0() {
|
|
segmentIndex = m.hashSplitting.segmentIndex(hash);
|
|
}
|
|
|
|
void closeSegmentIndex() {
|
|
if (!segmentIndexInit())
|
|
return;
|
|
closeSegmentIndexDependants();
|
|
closeSegmentIndex0();
|
|
}
|
|
|
|
void closeSegmentIndexDependants() {
|
|
closeSegmentHeader();
|
|
}
|
|
|
|
void closeSegmentIndex0() {
|
|
segmentIndex = -1;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Segment header
|
|
long segmentHeaderAddress;
|
|
SegmentHeader segmentHeader;
|
|
|
|
void initSegmentHeader() {
|
|
if (segmentHeaderInit())
|
|
return;
|
|
initSegmentHeaderDependencies();
|
|
initSegmentHeader0();
|
|
}
|
|
|
|
boolean segmentHeaderInit() {
|
|
return segmentHeader != null;
|
|
}
|
|
|
|
void initSegmentHeaderDependencies() {
|
|
initSegmentIndex();
|
|
}
|
|
|
|
void initSegmentHeader0() {
|
|
segmentHeaderAddress = m.ms.address() + m.segmentHeaderOffset(segmentIndex);
|
|
segmentHeader = BigSegmentHeader.INSTANCE;
|
|
}
|
|
|
|
void closeSegmentHeader() {
|
|
if (!segmentHeaderInit())
|
|
return;
|
|
closeSegmentHeaderDependants();
|
|
closeSegmentHeader0();
|
|
}
|
|
|
|
void closeSegmentHeaderDependants() {
|
|
closeLocks();
|
|
closeSegment();
|
|
}
|
|
|
|
void closeSegmentHeader0() {
|
|
segmentHeader = null;
|
|
}
|
|
|
|
long size() {
|
|
initSegmentHeader();
|
|
return segmentHeader.size(segmentHeaderAddress);
|
|
}
|
|
|
|
void size(long size) {
|
|
segmentHeader.size(segmentHeaderAddress, size);
|
|
}
|
|
|
|
long nextPosToSearchFrom() {
|
|
return segmentHeader.nextPosToSearchFrom(segmentHeaderAddress);
|
|
}
|
|
|
|
void nextPosToSearchFrom(long nextPosToSearchFrom) {
|
|
segmentHeader.nextPosToSearchFrom(segmentHeaderAddress, nextPosToSearchFrom);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Locks
|
|
VanillaContext rootContextOnThisSegment;
|
|
int readLockCount;
|
|
int updateLockCount;
|
|
int writeLockCount;
|
|
int totalReadLockCount;
|
|
int totalUpdateLockCount;
|
|
int totalWriteLockCount;
|
|
|
|
final InterProcessLock readLock = new ReadLock();
|
|
final InterProcessLock updateLock = new UpdateLock();
|
|
final InterProcessLock writeLock = new WriteLock();
|
|
|
|
void initLocks() {
|
|
if (locksInit())
|
|
return;
|
|
initLocksDependencies();
|
|
initLocks0();
|
|
}
|
|
|
|
boolean locksInit() {
|
|
return rootContextOnThisSegment != null;
|
|
}
|
|
|
|
void initLocksDependencies() {
|
|
initSegmentHeader();
|
|
}
|
|
|
|
void initLocks0() {
|
|
readLockCount = 0;
|
|
updateLockCount = 0;
|
|
writeLockCount = 0;
|
|
for (int i = 0; i < indexInContextCache; i++) {
|
|
VanillaContext parentContext = contextCache.contexts.get(i);
|
|
if (parentContext.segmentHeader != null &&
|
|
parentContext.segmentHeaderAddress == segmentHeaderAddress) {
|
|
rootContextOnThisSegment = parentContext;
|
|
return;
|
|
}
|
|
}
|
|
rootContextOnThisSegment = this;
|
|
totalReadLockCount = 0;
|
|
totalUpdateLockCount = 0;
|
|
totalWriteLockCount = 0;
|
|
}
|
|
|
|
void closeLocks() {
|
|
if (!locksInit())
|
|
return;
|
|
closeLocksDependants();
|
|
closeLocks0();
|
|
}
|
|
|
|
void closeLocksDependants() {
|
|
// TODO determine
|
|
closeKeySearch();
|
|
}
|
|
|
|
void closeLocks0() {
|
|
// TODO should throw ISE on attempt to close root context when children not closed
|
|
if (rootContextOnThisSegment == this) {
|
|
if (totalWriteLockCount > 0) {
|
|
segmentHeader.writeUnlock(segmentHeaderAddress);
|
|
closeKeySearch();
|
|
} else if (totalUpdateLockCount > 0) {
|
|
segmentHeader.updateUnlock(segmentHeaderAddress);
|
|
closeKeySearch();
|
|
} else if (totalReadLockCount > 0) {
|
|
segmentHeader.readUnlock(segmentHeaderAddress);
|
|
closeKeySearch();
|
|
}
|
|
} else {
|
|
if (writeLockCount > 0 &&
|
|
rootContextOnThisSegment.totalReadLockCount == writeLockCount) {
|
|
if (shouldUpdateUnlock()) {
|
|
if (shouldReadUnlock()) {
|
|
segmentHeader.writeUnlock(segmentHeaderAddress);
|
|
closeKeySearch();
|
|
} else {
|
|
segmentHeader.downgradeWriteToReadLock(segmentHeaderAddress);
|
|
}
|
|
} else {
|
|
segmentHeader.downgradeWriteToUpdateLock(segmentHeaderAddress);
|
|
}
|
|
} else if (shouldUpdateUnlock()) {
|
|
if (shouldReadUnlock()) {
|
|
segmentHeader.updateUnlock(segmentHeaderAddress);
|
|
closeKeySearch();
|
|
} else {
|
|
segmentHeader.downgradeUpdateToReadLock(segmentHeaderAddress);
|
|
}
|
|
} else if (shouldReadUnlock()) {
|
|
segmentHeader.readUnlock(segmentHeaderAddress);
|
|
closeKeySearch();
|
|
}
|
|
}
|
|
rootContextOnThisSegment.totalReadLockCount -= readLockCount;
|
|
rootContextOnThisSegment.totalUpdateLockCount -= updateLockCount;
|
|
rootContextOnThisSegment.totalWriteLockCount -= writeLockCount;
|
|
readLockCount = updateLockCount = writeLockCount = 0;
|
|
rootContextOnThisSegment = null;
|
|
}
|
|
|
|
boolean isReadLocked() {
|
|
return rootContextOnThisSegment.totalReadLockCount > 0;
|
|
}
|
|
|
|
boolean isUpdateLocked() {
|
|
return rootContextOnThisSegment.totalUpdateLockCount > 0;
|
|
}
|
|
|
|
boolean isWriteLocked() {
|
|
return rootContextOnThisSegment.totalWriteLockCount > 0;
|
|
}
|
|
|
|
void upgradeToWriteLock() {
|
|
if (!isWriteLocked())
|
|
writeLock();
|
|
}
|
|
|
|
boolean shouldReadUnlock() {
|
|
return readLockCount > 0 &&
|
|
rootContextOnThisSegment.totalReadLockCount == readLockCount;
|
|
}
|
|
|
|
boolean shouldUpdateUnlock() {
|
|
return updateLockCount > 0 &&
|
|
rootContextOnThisSegment.totalUpdateLockCount == updateLockCount;
|
|
}
|
|
|
|
void incrementReadCounts() {
|
|
rootContextOnThisSegment.totalReadLockCount++;
|
|
readLockCount++;
|
|
}
|
|
|
|
void decrementReadCounts() {
|
|
rootContextOnThisSegment.totalReadLockCount--;
|
|
readLockCount--;
|
|
}
|
|
|
|
void incrementUpdateCounts() {
|
|
incrementReadCounts();
|
|
rootContextOnThisSegment.totalUpdateLockCount++;
|
|
updateLockCount++;
|
|
}
|
|
|
|
void decrementUpdateCounts() {
|
|
decrementReadCounts();
|
|
rootContextOnThisSegment.totalUpdateLockCount--;
|
|
updateLockCount--;
|
|
}
|
|
|
|
void incrementWriteCounts() {
|
|
incrementUpdateCounts();
|
|
rootContextOnThisSegment.totalWriteLockCount++;
|
|
writeLockCount++;
|
|
}
|
|
|
|
void decrementWriteCounts() {
|
|
decrementUpdateCounts();
|
|
rootContextOnThisSegment.totalWriteLockCount--;
|
|
writeLockCount--;
|
|
}
|
|
|
|
abstract class AbstractLock implements InterProcessLock {
|
|
abstract boolean fastLock();
|
|
abstract void doLock();
|
|
abstract void doLockInterruptibly();
|
|
abstract boolean doTryLock(long time, TimeUnit unit);
|
|
abstract void incrementCounts();
|
|
|
|
@Override
|
|
public void lock() {
|
|
checkOnEachPublicOperation();
|
|
if (!fastLock())
|
|
doLock();
|
|
incrementCounts();
|
|
}
|
|
|
|
@Override
|
|
public void lockInterruptibly() throws InterruptedException {
|
|
checkOnEachPublicOperation();
|
|
if (!fastLock())
|
|
doLockInterruptibly();
|
|
incrementCounts();
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock(long time, @NotNull TimeUnit unit) throws InterruptedException {
|
|
checkOnEachPublicOperation();
|
|
if (fastLock() || doTryLock(time, unit)) {
|
|
incrementCounts();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public Condition newCondition() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|
|
|
|
class ReadLock extends AbstractLock {
|
|
@Override
|
|
boolean fastLock() {
|
|
return isReadLocked();
|
|
}
|
|
|
|
@Override
|
|
public boolean isHeldByCurrentThread() {
|
|
return fastLock();
|
|
}
|
|
|
|
@Override
|
|
void doLock() {
|
|
segmentHeader.readLock(segmentHeaderAddress);
|
|
}
|
|
|
|
@Override
|
|
void doLockInterruptibly() {
|
|
segmentHeader.readLockInterruptibly(segmentHeaderAddress);
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock() {
|
|
checkOnEachPublicOperation();
|
|
if (fastLock() || segmentHeader.tryReadLock(segmentHeaderAddress)) {
|
|
incrementCounts();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
boolean doTryLock(long time, TimeUnit unit) {
|
|
return segmentHeader.tryReadLock(segmentHeaderAddress, time, unit);
|
|
}
|
|
|
|
@Override
|
|
void incrementCounts() {
|
|
incrementReadCounts();
|
|
}
|
|
|
|
@Override
|
|
public void unlock() {
|
|
if (readLockCount == 0)
|
|
throw new IllegalInterProcessLockStateException("Read lock is not held");
|
|
if (rootContextOnThisSegment.totalReadLockCount == 1) {
|
|
segmentHeader.readUnlock(segmentHeaderAddress);
|
|
closeKeySearch();
|
|
}
|
|
decrementReadCounts();
|
|
}
|
|
}
|
|
|
|
class UpdateLock extends AbstractLock {
|
|
@Override
|
|
boolean fastLock() {
|
|
if (rootContextOnThisSegment.totalUpdateLockCount == 0) {
|
|
if (rootContextOnThisSegment.totalReadLockCount != 0) {
|
|
throw new IllegalInterProcessLockStateException("Must not acquire update " +
|
|
"lock, while read lock is already held by this thread");
|
|
}
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isHeldByCurrentThread() {
|
|
return isUpdateLocked();
|
|
}
|
|
|
|
@Override
|
|
void doLock() {
|
|
segmentHeader.updateLock(segmentHeaderAddress);
|
|
}
|
|
|
|
@Override
|
|
void doLockInterruptibly() {
|
|
segmentHeader.updateLockInterruptibly(segmentHeaderAddress);
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock() {
|
|
checkOnEachPublicOperation();
|
|
if (doTryLock()) {
|
|
incrementCounts();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
boolean doTryLock() {
|
|
if (rootContextOnThisSegment.totalUpdateLockCount == 0) {
|
|
if (rootContextOnThisSegment.totalReadLockCount > 0) {
|
|
return segmentHeader.tryUpgradeReadToUpdateLock(segmentHeaderAddress);
|
|
} else {
|
|
return segmentHeader.tryUpdateLock(segmentHeaderAddress);
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
boolean doTryLock(long time, TimeUnit unit) {
|
|
return segmentHeader.tryUpdateLock(segmentHeaderAddress, time, unit);
|
|
}
|
|
|
|
@Override
|
|
void incrementCounts() {
|
|
incrementUpdateCounts();
|
|
}
|
|
|
|
@Override
|
|
public void unlock() {
|
|
if (updateLockCount == 0)
|
|
throw new IllegalInterProcessLockStateException("Update lock is not held");
|
|
if (rootContextOnThisSegment.totalUpdateLockCount == 1) {
|
|
if (rootContextOnThisSegment.totalReadLockCount == 1) {
|
|
segmentHeader.updateUnlock(segmentHeaderAddress);
|
|
closeKeySearch();
|
|
} else {
|
|
segmentHeader.downgradeUpdateToReadLock(segmentHeaderAddress);
|
|
}
|
|
}
|
|
decrementUpdateCounts();
|
|
}
|
|
}
|
|
|
|
class WriteLock extends AbstractLock {
|
|
@Override
|
|
boolean fastLock() {
|
|
if (rootContextOnThisSegment.totalWriteLockCount == 0) {
|
|
if (rootContextOnThisSegment.totalUpdateLockCount == 0 &&
|
|
rootContextOnThisSegment.totalReadLockCount != 0) {
|
|
throw new IllegalInterProcessLockStateException("Must not acquire write " +
|
|
"lock, while read lock is already held by this thread");
|
|
}
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isHeldByCurrentThread() {
|
|
return isWriteLocked();
|
|
}
|
|
|
|
@Override
|
|
void doLock() {
|
|
if (rootContextOnThisSegment.totalUpdateLockCount > 0) {
|
|
segmentHeader.upgradeUpdateToWriteLock(segmentHeaderAddress);
|
|
} else {
|
|
segmentHeader.writeLock(segmentHeaderAddress);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
void doLockInterruptibly() {
|
|
if (rootContextOnThisSegment.totalUpdateLockCount > 0) {
|
|
segmentHeader.upgradeUpdateToWriteLockInterruptibly(segmentHeaderAddress);
|
|
} else {
|
|
segmentHeader.writeLockInterruptibly(segmentHeaderAddress);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock() {
|
|
checkOnEachPublicOperation();
|
|
if (doTryLock()) {
|
|
incrementCounts();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
boolean doTryLock() {
|
|
if (rootContextOnThisSegment.totalWriteLockCount == 0) {
|
|
if (rootContextOnThisSegment.totalUpdateLockCount > 0) {
|
|
return segmentHeader.tryUpgradeUpdateToWriteLock(segmentHeaderAddress);
|
|
} else if (rootContextOnThisSegment.totalReadLockCount > 0) {
|
|
return segmentHeader.tryUpgradeReadToWriteLock(segmentHeaderAddress);
|
|
} else {
|
|
return segmentHeader.tryWriteLock(segmentHeaderAddress);
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
boolean doTryLock(long time, TimeUnit unit) {
|
|
if (rootContextOnThisSegment.totalUpdateLockCount > 0) {
|
|
return segmentHeader.tryUpgradeUpdateToWriteLock(
|
|
segmentHeaderAddress, time, unit);
|
|
} else {
|
|
return segmentHeader.tryWriteLock(segmentHeaderAddress, time, unit);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
void incrementCounts() {
|
|
incrementWriteCounts();
|
|
}
|
|
|
|
@Override
|
|
public void unlock() {
|
|
if (writeLockCount == 0)
|
|
throw new IllegalInterProcessLockStateException("Write lock is not held");
|
|
if (rootContextOnThisSegment.totalWriteLockCount == 1) {
|
|
if (rootContextOnThisSegment.totalUpdateLockCount == 1) {
|
|
if (rootContextOnThisSegment.totalReadLockCount == 1) {
|
|
segmentHeader.writeUnlock(segmentHeaderAddress);
|
|
closeKeySearch();
|
|
} else {
|
|
segmentHeader.downgradeWriteToReadLock(segmentHeaderAddress);
|
|
}
|
|
} else {
|
|
segmentHeader.downgradeWriteToUpdateLock(segmentHeaderAddress);
|
|
}
|
|
}
|
|
decrementWriteCounts();
|
|
}
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public InterProcessLock readLock() {
|
|
checkOnEachPublicOperation();
|
|
initLocks();
|
|
return readLock;
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public InterProcessLock updateLock() {
|
|
checkOnEachPublicOperation();
|
|
initLocks();
|
|
return updateLock;
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public InterProcessLock writeLock() {
|
|
checkOnEachPublicOperation();
|
|
initLocks();
|
|
return writeLock;
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// Segment
|
|
final HashLookup hashLookup = new HashLookup();
|
|
final MultiStoreBytes freeListBytes = new MultiStoreBytes();
|
|
final SingleThreadedDirectBitSet freeList = new SingleThreadedDirectBitSet();
|
|
long entrySpaceOffset;
|
|
|
|
void initSegment() {
|
|
if (segmentInit())
|
|
return;
|
|
initSegmentDependencies();
|
|
initSegment0();
|
|
}
|
|
|
|
boolean segmentInit() {
|
|
return entrySpaceOffset != 0;
|
|
}
|
|
|
|
void initSegmentDependencies() {
|
|
initSegmentHeader();
|
|
}
|
|
|
|
void initSegment0() {
|
|
long hashLookupOffset = m.segmentOffset(segmentIndex);
|
|
hashLookup.reuse(m.ms.address() + hashLookupOffset,
|
|
m.segmentHashLookupCapacity, m.segmentHashLookupEntrySize,
|
|
m.segmentHashLookupKeyBits, m.segmentHashLookupValueBits);
|
|
long freeListOffset = hashLookupOffset + m.segmentHashLookupOuterSize;
|
|
freeListBytes.storePositionAndSize(m.ms, freeListOffset, m.segmentFreeListInnerSize);
|
|
freeList.reuse(freeListBytes);
|
|
entrySpaceOffset = freeListOffset + m.segmentFreeListOuterSize +
|
|
m.segmentEntrySpaceInnerOffset;
|
|
}
|
|
|
|
void closeSegment() {
|
|
if (!segmentInit())
|
|
return;
|
|
closeSegmentDependants();
|
|
closeSegment0();
|
|
}
|
|
|
|
void closeSegmentDependants() {
|
|
closeHashLookup();
|
|
}
|
|
|
|
void closeSegment0() {
|
|
entrySpaceOffset = 0L;
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// Hash lookup
|
|
public void initHashLookup() {
|
|
if (hashLookupInit())
|
|
return;
|
|
initHashLookupDependencies();
|
|
hashLookup.init0(m.hashSplitting.segmentHash(hash));
|
|
}
|
|
|
|
boolean hashLookupInit() {
|
|
return hashLookup.isInit();
|
|
}
|
|
|
|
void initHashLookupDependencies() {
|
|
initSegment();
|
|
}
|
|
|
|
public void closeHashLookup() {
|
|
if (!hashLookupInit())
|
|
return;
|
|
closeHashLookupDependants();
|
|
hashLookup.close0();
|
|
}
|
|
|
|
void closeHashLookupDependants() {
|
|
closeKeySearch();
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// Key search, key bytes and entry
|
|
static enum SearchState {
|
|
PRESENT,
|
|
ABSENT,
|
|
DELETED
|
|
}
|
|
SearchState state;
|
|
long pos;
|
|
long keyOffset;
|
|
final MultiStoreBytes entryCache = new MultiStoreBytes();
|
|
MultiStoreBytes entry;
|
|
|
|
void initKeySearch() {
|
|
if (keySearchInit())
|
|
return;
|
|
initKeySearchDependencies();
|
|
initKeySearch0();
|
|
}
|
|
|
|
boolean keySearchInit() {
|
|
return state != null;
|
|
}
|
|
|
|
void initKeySearchDependencies() {
|
|
initHashLookup();
|
|
initLocks();
|
|
if (!isReadLocked())
|
|
readLock().lock();
|
|
}
|
|
|
|
void initKeySearch0() {
|
|
hashLookup.initSearch0();
|
|
while ((pos = hashLookup.nextPos()) >= 0L) {
|
|
reuse(pos);
|
|
if (!keyEquals())
|
|
continue;
|
|
hashLookup.found();
|
|
initKeyOffset0();
|
|
keyFound();
|
|
return;
|
|
}
|
|
state = ABSENT;
|
|
}
|
|
|
|
void initKeyOffset0() {
|
|
keyOffset = entry.position();
|
|
}
|
|
|
|
void keyFound() {
|
|
state = PRESENT;
|
|
}
|
|
|
|
void closeKeySearch() {
|
|
if (!keySearchInit())
|
|
return;
|
|
closeKeySearchDependants();
|
|
closeKeySearch0();
|
|
}
|
|
|
|
void closeKeySearchDependants() {
|
|
// TODO determine dependencies
|
|
closeValueBytes();
|
|
}
|
|
|
|
void closeKeySearch0() {
|
|
state = null;
|
|
pos = -1;
|
|
entry = null;
|
|
hashLookup.closeSearch0();
|
|
}
|
|
|
|
@Override
|
|
public boolean containsKey() {
|
|
checkOnEachPublicOperation();
|
|
initKeySearch();
|
|
return state == PRESENT;
|
|
}
|
|
|
|
void checkContainsKey() {
|
|
if (!containsKey())
|
|
throw new IllegalStateException("Key is absent");
|
|
}
|
|
|
|
@Override
|
|
public Bytes entry() {
|
|
checkContainsKey();
|
|
return entry;
|
|
}
|
|
|
|
@Override
|
|
public long keyOffset() {
|
|
checkContainsKey();
|
|
return keyOffset;
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// Value bytes
|
|
long valueSizeOffset;
|
|
long valueOffset;
|
|
long valueSize;
|
|
|
|
void initValueBytes() {
|
|
if (valueBytesInit())
|
|
return;
|
|
initValueBytesDependencies();
|
|
initValueBytes0();
|
|
}
|
|
|
|
boolean valueBytesInit() {
|
|
return valueSizeOffset != 0;
|
|
}
|
|
|
|
void initValueBytesDependencies() {
|
|
initKeySearch();
|
|
}
|
|
|
|
void initValueBytes0() {
|
|
if (state == ABSENT)
|
|
throw new IllegalStateException("Key should be present");
|
|
initValueSizeOffset0();
|
|
entry.position(valueSizeOffset);
|
|
valueSize = m.readValueSize(entry);
|
|
m.alignment.alignPositionAddr(entry);
|
|
valueOffset = entry.position();
|
|
}
|
|
|
|
void initValueSizeOffset0() {
|
|
valueSizeOffset = keyOffset + keySize;
|
|
}
|
|
|
|
void closeValueBytes() {
|
|
if (!valueBytesInit())
|
|
return;
|
|
closeValueBytesDependants();
|
|
closeValueBytes0();
|
|
}
|
|
|
|
void closeValueBytesDependants() {
|
|
closeValue();
|
|
closeEntrySizeInChunks();
|
|
}
|
|
|
|
void closeValueBytes0() {
|
|
valueSizeOffset = 0L;
|
|
}
|
|
|
|
@Override
|
|
public long valueOffset() {
|
|
checkContainsKey();
|
|
initValueBytes();
|
|
return valueOffset;
|
|
}
|
|
|
|
@Override
|
|
public long valueSize() {
|
|
checkContainsKey();
|
|
initValueBytes();
|
|
return valueSize;
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// Value reader
|
|
BytesReader<V> valueReader;
|
|
|
|
void initValueReader() {
|
|
if (valueReaderInit())
|
|
return;
|
|
initValueReaderDependencies();
|
|
initValueReader0();
|
|
}
|
|
|
|
boolean valueReaderInit() {
|
|
return valueReader != null;
|
|
}
|
|
|
|
void initValueReaderDependencies() {
|
|
checkMapInit();
|
|
}
|
|
|
|
void initValueReader0() {
|
|
valueReader = m.valueReaderProvider.get(copies, m.originalValueReader);
|
|
}
|
|
|
|
void closeValueReader() {
|
|
if (!valueReaderInit())
|
|
return;
|
|
closeValueReaderDependants();
|
|
closeValueReader0();
|
|
}
|
|
|
|
void closeValueReaderDependants() {
|
|
closeValue();
|
|
}
|
|
|
|
void closeValueReader0() {
|
|
valueReader = null;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Value
|
|
V value;
|
|
|
|
@Override
|
|
public V get() {
|
|
checkOnEachPublicOperation();
|
|
if (valueInit())
|
|
return value;
|
|
initKeySearch();
|
|
if (state != PRESENT)
|
|
return null;
|
|
initValueDependencies();
|
|
initMapAndContextLocals();
|
|
initValue0(mapAndContextLocalsReference.mapAndContextLocals.reusableValue);
|
|
mapAndContextLocalsReference.mapAndContextLocals.reusableValue = value;
|
|
return value;
|
|
}
|
|
|
|
boolean valueInit() {
|
|
return value != null;
|
|
}
|
|
|
|
void initValueDependencies() {
|
|
initValueBytes();
|
|
initValueReader();
|
|
}
|
|
|
|
@Override
|
|
public V getUsing(V usingValue) {
|
|
checkOnEachPublicOperation();
|
|
// no check, because getUsing MUST try to use the given usingValue
|
|
// if (value != null)
|
|
// return value;
|
|
initKeySearch();
|
|
if (state != PRESENT)
|
|
return null;
|
|
initValueDependencies();
|
|
initValue0(usingValue);
|
|
return value;
|
|
}
|
|
|
|
void initValue0(V usingValue) {
|
|
entry.position(valueOffset);
|
|
value = valueReader.read(entry, valueSize, usingValue);
|
|
}
|
|
|
|
void closeValue() {
|
|
if (!valueInit())
|
|
return;
|
|
closeValueDependants();
|
|
closeValue0();
|
|
}
|
|
|
|
void closeValueDependants() {
|
|
// TODO no dependants?
|
|
}
|
|
|
|
void closeValue0() {
|
|
closeInstanceValue0();
|
|
}
|
|
|
|
void closeInstanceValue0() {
|
|
value = null;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Value model
|
|
VI valueInterop;
|
|
|
|
void initValueModel() {
|
|
if (valueModelInit())
|
|
return;
|
|
initValueModelDependencies();
|
|
initValueModel0();
|
|
}
|
|
|
|
boolean valueModelInit() {
|
|
return valueInterop != null;
|
|
}
|
|
|
|
void initValueModelDependencies() {
|
|
checkMapInit();
|
|
}
|
|
|
|
void initValueModel0() {
|
|
initInstanceValueModel0();
|
|
}
|
|
|
|
void initInstanceValueModel0() {
|
|
valueInterop = m.valueInteropProvider.get(copies, m.originalValueInterop);
|
|
}
|
|
|
|
void closeValueModel() {
|
|
if (!valueModelInit())
|
|
return;
|
|
closeValueModelDependants();
|
|
closeValueModel0();
|
|
}
|
|
|
|
void closeValueModelDependants() {
|
|
closeNewValue();
|
|
}
|
|
|
|
void closeValueModel0() {
|
|
valueInterop = null;
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
// New value
|
|
V newValue;
|
|
MVI metaValueInterop;
|
|
long newValueSize;
|
|
|
|
void initNewValue(V newValue) {
|
|
initNewValueDependencies();
|
|
initNewValue0(newValue);
|
|
}
|
|
|
|
boolean newValueInit() {
|
|
return newValue != null;
|
|
}
|
|
|
|
void initNewValueDependencies() {
|
|
initValueModel();
|
|
}
|
|
|
|
void initNewValue0(V newValue) {
|
|
initNewInstanceValue0(newValue);
|
|
}
|
|
|
|
void initNewInstanceValue0(V newValue) {
|
|
m.checkValue(newValue);
|
|
this.newValue = newValue;
|
|
metaValueInterop = m.metaValueInteropProvider.get(
|
|
copies, m.originalMetaValueInterop, valueInterop, newValue);
|
|
newValueSize = metaValueInterop.size(valueInterop, newValue);
|
|
}
|
|
|
|
void closeNewValue() {
|
|
if (!newValueInit())
|
|
return;
|
|
closeNewValueDependants();
|
|
closeNewValue0();
|
|
}
|
|
|
|
void closeNewValueDependants() {
|
|
// TODO no dependants?
|
|
}
|
|
|
|
void closeNewValue0() {
|
|
metaValueInterop = null;
|
|
newValue = null;
|
|
}
|
|
|
|
@Override
|
|
public boolean valueEqualTo(V value) {
|
|
checkOnEachPublicOperation();
|
|
initValueBytes();
|
|
initNewValue(value);
|
|
try {
|
|
if (newValueSize != valueSize)
|
|
return false;
|
|
entry.position(valueOffset);
|
|
return metaValueInterop.startsWith(valueInterop, entry, newValue);
|
|
} finally {
|
|
closeNewValue();
|
|
}
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Entry size in chunks
|
|
int entrySizeInChunks;
|
|
|
|
void initEntrySizeInChunks() {
|
|
if (entrySizeInChunksInit())
|
|
return;
|
|
initEntrySizeInChunksDependencies();
|
|
initEntrySizeInChunks0();
|
|
}
|
|
|
|
boolean entrySizeInChunksInit() {
|
|
return entrySizeInChunks != 0;
|
|
}
|
|
|
|
void initEntrySizeInChunksDependencies() {
|
|
initValueBytes();
|
|
}
|
|
|
|
void initEntrySizeInChunks0() {
|
|
entrySizeInChunks = inChunks(valueOffset + valueSize);
|
|
}
|
|
|
|
void closeEntrySizeInChunks() {
|
|
if (!entrySizeInChunksInit())
|
|
return;
|
|
closeEntrySizeInChunksDependants();
|
|
closeEntrySizeInChunks0();
|
|
}
|
|
|
|
void closeEntrySizeInChunksDependants() {
|
|
// TODO no dependants?
|
|
}
|
|
|
|
void closeEntrySizeInChunks0() {
|
|
entrySizeInChunks = 0;
|
|
}
|
|
|
|
void updateLockIfNeeded() {
|
|
if (!isUpdateLocked())
|
|
updateLock().lock();
|
|
}
|
|
|
|
public boolean put(V newValue) {
|
|
return doPut(newValue);
|
|
}
|
|
|
|
boolean doPut(V newValue) {
|
|
checkOnEachPublicOperation();
|
|
initPutDependencies();
|
|
initNewValue(newValue);
|
|
return put0();
|
|
}
|
|
|
|
void initPutDependencies() {
|
|
initLocks();
|
|
updateLockIfNeeded();
|
|
initKeySearch();
|
|
initValueModel();
|
|
initKeyModel();
|
|
}
|
|
|
|
boolean put0() {
|
|
switch (state) {
|
|
case PRESENT:
|
|
case DELETED:
|
|
initValueBytes();
|
|
putValue();
|
|
break;
|
|
case ABSENT:
|
|
putEntry();
|
|
}
|
|
state = PRESENT;
|
|
return true;
|
|
}
|
|
|
|
void putEntry() {
|
|
long entrySize = entrySize(keySize, newValueSize);
|
|
int allocatedChunks = inChunks(entrySize);
|
|
pos = alloc(allocatedChunks);
|
|
reuse(pos);
|
|
|
|
m.keySizeMarshaller.writeSize(entry, keySize);
|
|
initKeyOffset0();
|
|
metaKeyInterop.write(keyInterop, entry, key);
|
|
initValueSizeOffset0();
|
|
writeValueAndPutPos(allocatedChunks);
|
|
}
|
|
|
|
void writeValueAndPutPos(int allocatedChunks) {
|
|
writeNewValueSize();
|
|
writeNewValueAndSwitch();
|
|
|
|
if (state != PRESENT) {
|
|
// update the size before the store fence
|
|
size(size() + 1L);
|
|
}
|
|
beforePutPos();
|
|
// put + store fence, guarantees if concurrent readers see the new entry
|
|
// in the hashLookup => they will also see written entry bytes
|
|
hashLookup.putVolatile(pos);
|
|
|
|
freeExtraAllocatedChunks(allocatedChunks);
|
|
}
|
|
|
|
void beforePutPos() {
|
|
}
|
|
|
|
void putValue() {
|
|
initEntrySizeInChunks();
|
|
int lesserChunks = -1;
|
|
if (newValueSize != valueSize) {
|
|
long newSizeOfEverythingBeforeValue =
|
|
valueSizeOffset + m.valueSizeMarshaller.sizeEncodingSize(newValueSize);
|
|
long entryStartAddr = entry.address();
|
|
long newValueAddr = m.alignment.alignAddr(
|
|
entryStartAddr + newSizeOfEverythingBeforeValue);
|
|
long newEntrySize = newValueAddr + newValueSize - entryStartAddr;
|
|
int newSizeInChunks = inChunks(newEntrySize);
|
|
newValueDoesNotFit:
|
|
if (newSizeInChunks > entrySizeInChunks) {
|
|
if (newSizeInChunks > m.maxChunksPerEntry) {
|
|
throw new IllegalArgumentException("Value too large: " +
|
|
"entry takes " + newSizeInChunks + " chunks, " +
|
|
m.maxChunksPerEntry + " is maximum.");
|
|
}
|
|
if (freeList.allClear(pos + entrySizeInChunks, pos + newSizeInChunks)) {
|
|
long setFrom = freeListBitsSet() ? pos + entrySizeInChunks : pos;
|
|
freeList.set(setFrom, pos + newSizeInChunks);
|
|
break newValueDoesNotFit;
|
|
}
|
|
// RELOCATION
|
|
beforeRelocation();
|
|
if (freeListBitsSet())
|
|
free(pos, entrySizeInChunks);
|
|
int allocatedChunks =
|
|
inChunks(innerEntrySize(newSizeOfEverythingBeforeValue, newValueSize));
|
|
pos = alloc(allocatedChunks);
|
|
reuse(pos);
|
|
UNSAFE.copyMemory(entryStartAddr, entry.address(), valueSizeOffset);
|
|
writeValueAndPutPos(allocatedChunks);
|
|
return;
|
|
} else if (newSizeInChunks < entrySizeInChunks) {
|
|
// Freeing extra chunks
|
|
if (freeListBitsSet())
|
|
freeList.clear(pos + newSizeInChunks, pos + entrySizeInChunks);
|
|
lesserChunks = newSizeInChunks;
|
|
// Do NOT reset nextPosToSearchFrom, because if value
|
|
// once was larger it could easily became larger again,
|
|
// But if these chunks will be taken by that time,
|
|
// this entry will need to be relocated.
|
|
}
|
|
// new size != old size => size is not constant => size is actually written =>
|
|
// to prevent (at least) this execution:
|
|
// 1. concurrent reader thread reads the size
|
|
// 2. this thread updates the size and the value
|
|
// 3. concurrent reader reads the value
|
|
// We MUST upgrade to exclusive lock
|
|
upgradeToWriteLock();
|
|
writeNewValueSize();
|
|
} else {
|
|
entry.position(valueOffset);
|
|
// TODO to turn the following block on, JLANG-46 is required. Also unclear what happens
|
|
// if the value is DataValue generated with 2, 4 or 8 distinct bytes, putting on-heap
|
|
// implementation of such value is also not atomic currently, however there is a way
|
|
// to make is atomic, we should identify such cases and make a single write:
|
|
// state = UNSAFE.getLong(onHeapValueObject, offsetToTheFirstField);
|
|
// bytes.writeLong(state);
|
|
// boolean newValueSizeIsPowerOf2 = ((newValueSize - 1L) & newValueSize) != 0;
|
|
// if (!newValueSizeIsPowerOf2 || newValueSize > 8L) {
|
|
// // if the new value size is 1, 2, 4, or 8, it is written not atomically only if
|
|
// // the user provided own marshaller and writes value byte-by-byte, that is very
|
|
// // unlikely. in this case the user should update acquire write lock before write
|
|
// // updates himself
|
|
// upgradeToWriteLock();
|
|
// }
|
|
upgradeToWriteLock();
|
|
}
|
|
writeNewValueAndSwitch();
|
|
if (state != PRESENT) {
|
|
if (!freeListBitsSet())
|
|
freeList.set(pos, pos + entrySizeInChunks);
|
|
size(size() + 1L);
|
|
beforePutPos();
|
|
hashLookup.putVolatile(pos);
|
|
}
|
|
if (lesserChunks > 0)
|
|
freeExtraAllocatedChunks(lesserChunks);
|
|
}
|
|
|
|
boolean freeListBitsSet() {
|
|
return state == PRESENT;
|
|
}
|
|
|
|
void beforeRelocation() {
|
|
}
|
|
|
|
void writeNewValueSize() {
|
|
entry.position(valueSizeOffset);
|
|
m.valueSizeMarshaller.writeSize(entry, newValueSize);
|
|
valueSize = newValueSize;
|
|
m.alignment.alignPositionAddr(entry);
|
|
valueOffset = entry.position();
|
|
}
|
|
|
|
void writeNewValueAndSwitch() {
|
|
entry.position(valueOffset);
|
|
metaValueInterop.write(valueInterop, entry, newValue);
|
|
value = newValue;
|
|
closeNewValue0();
|
|
}
|
|
|
|
@Override
|
|
public boolean remove() {
|
|
checkOnEachPublicOperation();
|
|
initRemoveDependencies();
|
|
try {
|
|
return remove0();
|
|
} finally {
|
|
closeRemove();
|
|
}
|
|
}
|
|
|
|
boolean remove0() {
|
|
if (containsKey()) {
|
|
initEntrySizeInChunks();
|
|
upgradeToWriteLock();
|
|
hashLookupRemove();
|
|
free(pos, entrySizeInChunks);
|
|
size(size() - 1L);
|
|
state = DELETED;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
boolean forEachEntry;
|
|
|
|
void hashLookupRemove() {
|
|
if (!forEachEntry)
|
|
hashLookup.remove();
|
|
}
|
|
|
|
void initRemoveDependencies() {
|
|
initSegment();
|
|
initLocks();
|
|
updateLockIfNeeded();
|
|
}
|
|
|
|
void closeRemove() {
|
|
}
|
|
|
|
void checkMultiMapsAndBitSetsConsistency() {
|
|
class EntryChecker implements HashLookup.EntryConsumer {
|
|
long size = 0;
|
|
@Override
|
|
public void accept(long key, long value) {
|
|
if (freeList.isClear(value))
|
|
throw new IllegalStateException("Position " + value + " is present in " +
|
|
"multiMap but available in the free chunk list");
|
|
}
|
|
}
|
|
EntryChecker entryChecker = new EntryChecker();
|
|
hashLookup.forEach(entryChecker);
|
|
if (size() != entryChecker.size) {
|
|
throw new IllegalStateException("Segment inconsistent: " +
|
|
"size by Segment counter: " + size() +
|
|
", size by multiMap records present in bit set: " + entryChecker.size);
|
|
}
|
|
}
|
|
|
|
final MultiStoreBytes reuse(MultiStoreBytes entry, long pos) {
|
|
long offsetWithinEntrySpace = pos * m.chunkSize;
|
|
entry.setBytesOffset(m.bytes, entrySpaceOffset + offsetWithinEntrySpace);
|
|
entry.limit(m.segmentEntrySpaceInnerSize - offsetWithinEntrySpace);
|
|
entry.position(m.metaDataBytes);
|
|
return entry;
|
|
}
|
|
|
|
final void reuse(long pos) {
|
|
entry = reuse(entryCache, pos);
|
|
}
|
|
|
|
final long entrySize(long keySize, long valueSize) {
|
|
long sizeOfEverythingBeforeValue = sizeOfEverythingBeforeValue(keySize, valueSize);
|
|
return innerEntrySize(sizeOfEverythingBeforeValue, valueSize);
|
|
}
|
|
|
|
long innerEntrySize(long sizeOfEverythingBeforeValue, long valueSize) {
|
|
if (m.constantlySizedEntry) {
|
|
return m.alignment.alignAddr(sizeOfEverythingBeforeValue + valueSize);
|
|
} else if (m.couldNotDetermineAlignmentBeforeAllocation) {
|
|
return sizeOfEverythingBeforeValue + m.worstAlignment + valueSize;
|
|
} else {
|
|
return m.alignment.alignAddr(sizeOfEverythingBeforeValue) + valueSize;
|
|
}
|
|
}
|
|
|
|
long sizeOfEverythingBeforeValue(long keySize, long valueSize) {
|
|
return m.metaDataBytes +
|
|
m.keySizeMarshaller.sizeEncodingSize(keySize) + keySize +
|
|
m.valueSizeMarshaller.sizeEncodingSize(valueSize);
|
|
}
|
|
|
|
final int inChunks(long sizeInBytes) {
|
|
// TODO optimize for the case when chunkSize is power of 2, that is default (and often) now
|
|
if (sizeInBytes <= m.chunkSize)
|
|
return 1;
|
|
// int division is MUCH faster than long on Intel CPUs
|
|
sizeInBytes -= 1L;
|
|
if (sizeInBytes <= Integer.MAX_VALUE)
|
|
return (((int) sizeInBytes) / (int) m.chunkSize) + 1;
|
|
return (int) (sizeInBytes / m.chunkSize) + 1;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// For bytes contexts
|
|
static final Bytes DUMMY_BYTES = new ByteBufferBytes(ByteBuffer.allocate(0));
|
|
private final MultiStoreBytes keyCopy = new MultiStoreBytes();
|
|
private final MultiStoreBytes valueCopy = new MultiStoreBytes();
|
|
TcpReplicator.TcpSocketChannelEntryWriter output;
|
|
|
|
void initBytesKeyModel0() {
|
|
keyInterop = (KI) BytesBytesInterop.INSTANCE;
|
|
}
|
|
|
|
void initBytesKey0(Bytes key) {
|
|
keySize = m.keySizeMarshaller.readSize(key);
|
|
key.limit(key.position() + keySize);
|
|
initBytesKey00(key);
|
|
metaKeyInterop = (MKI) DelegatingMetaBytesInterop.instance();
|
|
}
|
|
|
|
void initBytesKey00(Bytes key) {
|
|
keyCopy.setBytesOffset(key, key.position());
|
|
keyCopy.limit(keySize);
|
|
this.key = (K) keyCopy;
|
|
}
|
|
|
|
void initBytesValueModel0() {
|
|
valueInterop = (VI) BytesBytesInterop.INSTANCE;
|
|
}
|
|
|
|
void initNewBytesValue0(Bytes entry) {
|
|
metaValueInterop = (MVI) DelegatingMetaBytesInterop.instance();
|
|
entry.position(entry.limit());
|
|
entry.limit(entry.capacity());
|
|
newValueSize = m.valueSizeMarshaller.readSize(entry);
|
|
entry.limit(entry.position() + newValueSize);
|
|
initNewBytesValue00(entry);
|
|
}
|
|
|
|
void initNewBytesValue00(Bytes value) {
|
|
valueCopy.setBytesOffset(value, value.position());
|
|
valueCopy.limit(newValueSize);
|
|
newValue = (V) valueCopy;
|
|
}
|
|
|
|
void closeBytesValue0() {
|
|
closeInstanceValue0();
|
|
output = null;
|
|
}
|
|
|
|
Bytes getBytes() {
|
|
return getBytesUsing(null);
|
|
}
|
|
|
|
Bytes getBytesUsing(Bytes usingValue) {
|
|
initKeySearch();
|
|
if (state != PRESENT) {
|
|
if (output != null) {
|
|
output.ensureBufferSize(1L);
|
|
output.in().writeBoolean(true);
|
|
}
|
|
return null;
|
|
}
|
|
if (output != null) {
|
|
initValueBytes();
|
|
long totalSize = 1L + m.valueSizeMarshaller.sizeEncodingSize(valueSize) + valueSize;
|
|
output.ensureBufferSize(totalSize);
|
|
output.in().writeBoolean(false);
|
|
m.valueSizeMarshaller.writeSize(output.in(), valueSize);
|
|
output.in().write(entry, valueOffset, valueSize);
|
|
}
|
|
return DUMMY_BYTES;
|
|
}
|
|
|
|
|
|
final void freeExtraAllocatedChunks(int allocatedChunks) {
|
|
int actuallyUsedChunks;
|
|
// fast path
|
|
if (!m.constantlySizedEntry && m.couldNotDetermineAlignmentBeforeAllocation &&
|
|
(actuallyUsedChunks = inChunks(entry.position())) < allocatedChunks) {
|
|
free(pos + actuallyUsedChunks, allocatedChunks - actuallyUsedChunks);
|
|
entrySizeInChunks = actuallyUsedChunks;
|
|
} else {
|
|
entrySizeInChunks = allocatedChunks;
|
|
}
|
|
}
|
|
|
|
//TODO refactor/optimize
|
|
final long alloc(int chunks) {
|
|
if (chunks > m.maxChunksPerEntry)
|
|
throw new IllegalArgumentException("Entry is too large: requires " + chunks +
|
|
" entry size chucks, " + m.maxChunksPerEntry + " is maximum.");
|
|
long ret = freeList.setNextNContinuousClearBits(nextPosToSearchFrom(), chunks);
|
|
if (ret == DirectBitSet.NOT_FOUND || ret + chunks > m.actualChunksPerSegment) {
|
|
if (ret != DirectBitSet.NOT_FOUND &&
|
|
ret + chunks > m.actualChunksPerSegment && ret < m.actualChunksPerSegment)
|
|
freeList.clear(ret, m.actualChunksPerSegment);
|
|
ret = freeList.setNextNContinuousClearBits(0L, chunks);
|
|
if (ret == DirectBitSet.NOT_FOUND || ret + chunks > m.actualChunksPerSegment) {
|
|
if (ret != DirectBitSet.NOT_FOUND &&
|
|
ret + chunks > m.actualChunksPerSegment &&
|
|
ret < m.actualChunksPerSegment)
|
|
freeList.clear(ret, m.actualChunksPerSegment);
|
|
if (chunks == 1) {
|
|
throw new IllegalStateException(
|
|
"Segment is full, no free entries found");
|
|
} else {
|
|
throw new IllegalStateException(
|
|
"Segment is full or has no ranges of " + chunks
|
|
+ " continuous free chunks"
|
|
);
|
|
}
|
|
}
|
|
updateNextPosToSearchFrom(ret, chunks);
|
|
} else {
|
|
// if bit at nextPosToSearchFrom is clear, it was skipped because
|
|
// more than 1 chunk was requested. Don't move nextPosToSearchFrom
|
|
// in this case. chunks == 1 clause is just a fast path.
|
|
if (chunks == 1 || freeList.isSet(nextPosToSearchFrom())) {
|
|
updateNextPosToSearchFrom(ret, chunks);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void updateNextPosToSearchFrom(long allocated, int chunks) {
|
|
long nextPosToSearchFrom = allocated + chunks;
|
|
if (nextPosToSearchFrom >= m.actualChunksPerSegment)
|
|
nextPosToSearchFrom = 0L;
|
|
nextPosToSearchFrom(nextPosToSearchFrom);
|
|
}
|
|
|
|
void free(long fromPos, int chunks) {
|
|
freeList.clear(fromPos, fromPos + chunks);
|
|
if (fromPos < nextPosToSearchFrom())
|
|
nextPosToSearchFrom(fromPos);
|
|
}
|
|
|
|
boolean keyEquals() {
|
|
return keySize == m.keySizeMarshaller.readSize(entry) &&
|
|
metaKeyInterop.startsWith(keyInterop, entry, key);
|
|
}
|
|
|
|
void clear() {
|
|
writeLock();
|
|
initSegment();
|
|
hashLookup.clear();
|
|
freeList.clear();
|
|
nextPosToSearchFrom(0L);
|
|
size(0L);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Iteration
|
|
|
|
void initKeyFromPos() {
|
|
reuse(pos);
|
|
keySize = m.keySizeMarshaller.readSize(entry);
|
|
initKeyOffset0();
|
|
keyFound();
|
|
initValueBytes();
|
|
}
|
|
|
|
K immutableKey() {
|
|
return key0(null);
|
|
}
|
|
|
|
K key0(K usingKey) {
|
|
initKeyReader();
|
|
entry.position(keyOffset);
|
|
key = keyReader.read(entry, keySize, usingKey);
|
|
return key;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////
|
|
// Acquire context
|
|
|
|
boolean acquirePut(V newValue) {
|
|
throw new UnsupportedOperationException("Acquire context doesn't support explicit put. " +
|
|
"Use simple lazy context (map.context()) instead.");
|
|
}
|
|
|
|
boolean acquireRemove() {
|
|
throw new UnsupportedOperationException("Acquire context doesn't support remove. " +
|
|
"Use simple lazy context (map.context()) instead.");
|
|
}
|
|
|
|
void acquireClose() {
|
|
checkOnEachPublicOperation();
|
|
doPut(value);
|
|
doClose();
|
|
}
|
|
}
|