mirror of
https://github.com/OpenHFT/Chronicle-Map.git
synced 2021-09-13 01:26:12 +00:00
2655 lines
100 KiB
Java
2655 lines
100 KiB
Java
package net.openhft.chronicle.map.impl;
|
|
|
|
import net.openhft.chronicle.bytes.Access;
|
|
import net.openhft.chronicle.bytes.Accessor;
|
|
import net.openhft.chronicle.bytes.Accessor.Full;
|
|
import net.openhft.chronicle.bytes.ReadAccess;
|
|
import net.openhft.chronicle.hash.AbstractData;
|
|
import net.openhft.chronicle.hash.Data;
|
|
import net.openhft.chronicle.hash.HashEntry;
|
|
import net.openhft.chronicle.hash.impl.BigSegmentHeader;
|
|
import net.openhft.chronicle.hash.impl.CopyingInstanceData;
|
|
import net.openhft.chronicle.hash.impl.JavaLangBytesAccessors;
|
|
import net.openhft.chronicle.hash.impl.LocalLockState;
|
|
import net.openhft.chronicle.hash.impl.SegmentHeader;
|
|
import net.openhft.chronicle.hash.impl.VanillaChronicleHash;
|
|
import net.openhft.chronicle.hash.impl.hashlookup.EntryConsumer;
|
|
import net.openhft.chronicle.hash.locks.InterProcessLock;
|
|
import net.openhft.chronicle.hash.locks.InterProcessReadWriteUpdateLock;
|
|
import net.openhft.chronicle.hash.replication.RemoteOperationContext;
|
|
import net.openhft.chronicle.hash.replication.ReplicableEntry;
|
|
import net.openhft.chronicle.hash.replication.TimeProvider;
|
|
import net.openhft.chronicle.hash.serialization.BytesReader;
|
|
import net.openhft.chronicle.hash.serialization.internal.MetaBytesInterop;
|
|
import net.openhft.chronicle.map.ChronicleMap;
|
|
import net.openhft.chronicle.map.MapAbsentEntry;
|
|
import net.openhft.chronicle.map.MapContext;
|
|
import net.openhft.chronicle.map.MapEntry;
|
|
import net.openhft.chronicle.map.MapKeyContext;
|
|
import net.openhft.chronicle.map.ReplicatedChronicleMap;
|
|
import net.openhft.chronicle.map.VanillaChronicleMap;
|
|
import net.openhft.chronicle.map.replication.MapReplicableEntry;
|
|
import net.openhft.lang.Maths;
|
|
import net.openhft.lang.MemoryUnit;
|
|
import net.openhft.lang.collection.DirectBitSet;
|
|
import net.openhft.lang.collection.SingleThreadedDirectBitSet;
|
|
import net.openhft.lang.io.Bytes;
|
|
import net.openhft.lang.io.DirectBytes;
|
|
import net.openhft.lang.io.MultiStoreBytes;
|
|
import net.openhft.lang.io.NativeBytes;
|
|
import net.openhft.lang.threadlocal.ThreadLocalCopies;
|
|
import org.jetbrains.annotations.NotNull;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.ConcurrentModificationException;
|
|
import java.util.List;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.function.Consumer;
|
|
import java.util.function.Predicate;
|
|
|
|
public class CompiledReplicatedMapIterationContext<K, KI, MKI extends MetaBytesInterop<K, ? super KI>, V, VI, MVI extends MetaBytesInterop<V, ? super VI>, R, T> implements AutoCloseable , HashEntry<K> , InterProcessReadWriteUpdateLock , RemoteOperationContext<K> , ReplicableEntry , MapContext<K, V, R> , MapEntry<K, V> , IterationContextInterface<K, V> , ReplicatedChronicleMapHolder<K, KI, MKI, V, VI, MVI, R> , ReplicatedIterationContextInterface<K, V> , MapReplicableEntry<K, V> {
|
|
public void close() {
|
|
CompiledReplicatedMapIterationContext.this.wrappedValueInstanceValue.closeValue();
|
|
CompiledReplicatedMapIterationContext.this.closeReplicationUpdate();
|
|
CompiledReplicatedMapIterationContext.this.closeUsed();
|
|
CompiledReplicatedMapIterationContext.this.closePos();
|
|
CompiledReplicatedMapIterationContext.this.closeKeyOffset();
|
|
CompiledReplicatedMapIterationContext.this.closeAllocatedChunks();
|
|
CompiledReplicatedMapIterationContext.this.wrappedValueInstanceValue.closeNext();
|
|
CompiledReplicatedMapIterationContext.this.closeEntryRemovedOnThisIteration();
|
|
CompiledReplicatedMapIterationContext.this.closeTheSegmentIndex();
|
|
CompiledReplicatedMapIterationContext.this.closeKeySize();
|
|
CompiledReplicatedMapIterationContext.this.closeHashLookupPos();
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedChronicleMapHolderImplContextAtIndexInChainDependants();
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.closeWriteLockForbiddenUpgradeDependants();
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapSegmentIterationCheckEntryNotRemovedOnThisIterationDependants();
|
|
CompiledReplicatedMapIterationContext.this.closeValueBytesInteropValueMetaInteropDependants();
|
|
CompiledReplicatedMapIterationContext.this.closeOwnerThreadHolderCheckAccessingFromOwnerThreadDependants();
|
|
}
|
|
|
|
public void incrementModCountGuarded() {
|
|
if (!(this.locksInit()))
|
|
this.initLocks();
|
|
|
|
incrementModCount();
|
|
}
|
|
|
|
public void setHashLookupPosGuarded(long hashLookupPos) {
|
|
assert this.hashLookupPosInit() : "HashLookupPos should be init";
|
|
setHashLookupPos(hashLookupPos);
|
|
}
|
|
|
|
public void setLocalLockStateGuarded(LocalLockState newState) {
|
|
if (!(this.locksInit()))
|
|
this.initLocks();
|
|
|
|
setLocalLockState(newState);
|
|
}
|
|
|
|
public CompiledReplicatedMapIterationContext(ReplicatedChronicleMap<K, KI, MKI, V, VI, MVI, R> m) {
|
|
contextChain = new ArrayList<CompiledReplicatedMapIterationContext>();
|
|
contextChain.add(this);
|
|
indexInContextChain = 0;
|
|
this.m = m;
|
|
this.wrappedValueInstanceValue = new WrappedValueInstanceData();
|
|
this.innerReadLock = new ReadLock();
|
|
this.copies = ThreadLocalCopies.get();
|
|
this.valueInterop = CompiledReplicatedMapIterationContext.this.m().valueInteropProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.m().originalValueInterop);
|
|
this.valueReader = CompiledReplicatedMapIterationContext.this.m().valueReaderProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.m().originalValueReader);
|
|
this.keyInterop = CompiledReplicatedMapIterationContext.this.h().keyInteropProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.h().originalKeyInterop);
|
|
this.keyReader = CompiledReplicatedMapIterationContext.this.h().keyReaderProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.h().originalKeyReader);
|
|
this.innerUpdateLock = new UpdateLock();
|
|
this.owner = Thread.currentThread();
|
|
this.deprecatedMapKeyContextOnIteration = new DeprecatedMapKeyContextOnIteration();
|
|
this.entryBytes = CompiledReplicatedMapIterationContext.this.h().ms.bytes();
|
|
this.entryBytesAccessor = JavaLangBytesAccessors.uncheckedBytesAccessor(entryBytes);
|
|
this.entryBytesAccessHandle = ((T)(entryBytesAccessor.handle(entryBytes)));
|
|
this.entryBytesAccess = ((Access<T>)(entryBytesAccessor.access(entryBytes)));
|
|
this.entryKey = new EntryKeyBytesData();
|
|
this.innerWriteLock = new WriteLock();
|
|
this.dummyValue = new DummyValueZeroData();
|
|
this.entryValue = new EntryValueBytesData();
|
|
}
|
|
|
|
public CompiledReplicatedMapIterationContext(CompiledReplicatedMapIterationContext c) {
|
|
contextChain = c.contextChain;
|
|
indexInContextChain = contextChain.size();
|
|
contextChain.add(this);
|
|
this.m = ((ReplicatedChronicleMap<K, KI, MKI, V, VI, MVI, R>)(c.m));
|
|
this.wrappedValueInstanceValue = new WrappedValueInstanceData();
|
|
this.innerReadLock = new ReadLock();
|
|
this.copies = ThreadLocalCopies.get();
|
|
this.valueInterop = CompiledReplicatedMapIterationContext.this.m().valueInteropProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.m().originalValueInterop);
|
|
this.valueReader = CompiledReplicatedMapIterationContext.this.m().valueReaderProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.m().originalValueReader);
|
|
this.keyInterop = CompiledReplicatedMapIterationContext.this.h().keyInteropProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.h().originalKeyInterop);
|
|
this.keyReader = CompiledReplicatedMapIterationContext.this.h().keyReaderProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.h().originalKeyReader);
|
|
this.innerUpdateLock = new UpdateLock();
|
|
this.owner = Thread.currentThread();
|
|
this.deprecatedMapKeyContextOnIteration = new DeprecatedMapKeyContextOnIteration();
|
|
this.entryBytes = CompiledReplicatedMapIterationContext.this.h().ms.bytes();
|
|
this.entryBytesAccessor = JavaLangBytesAccessors.uncheckedBytesAccessor(entryBytes);
|
|
this.entryBytesAccessHandle = ((T)(entryBytesAccessor.handle(entryBytes)));
|
|
this.entryBytesAccess = ((Access<T>)(entryBytesAccessor.access(entryBytes)));
|
|
this.entryKey = new EntryKeyBytesData();
|
|
this.innerWriteLock = new WriteLock();
|
|
this.dummyValue = new DummyValueZeroData();
|
|
this.entryValue = new EntryValueBytesData();
|
|
}
|
|
|
|
public class DeprecatedMapKeyContextOnIteration implements MapKeyContext<K, V> {
|
|
@Override
|
|
public void close() {
|
|
throw new UnsupportedOperationException("close() is not supported during iteration");
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public K key() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.key().get();
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public Bytes entry() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.entryBytes;
|
|
}
|
|
|
|
@Override
|
|
public V get() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.value().get();
|
|
}
|
|
|
|
@Override
|
|
public boolean remove() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
CompiledReplicatedMapIterationContext.this.remove(CompiledReplicatedMapIterationContext.this);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean containsKey() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public V getUsing(V usingValue) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.value().getUsing(usingValue);
|
|
}
|
|
|
|
@NotNull
|
|
private UnsupportedOperationException unsupportedLocks() {
|
|
return new UnsupportedOperationException("Lock operations are not supported (and not needed!) during iteration");
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public InterProcessLock writeLock() {
|
|
throw unsupportedLocks();
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public InterProcessLock readLock() {
|
|
throw unsupportedLocks();
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public InterProcessLock updateLock() {
|
|
throw unsupportedLocks();
|
|
}
|
|
|
|
@Override
|
|
public boolean valueEqualTo(V value) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return Data.bytesEquivalent(CompiledReplicatedMapIterationContext.this.entryValue, CompiledReplicatedMapIterationContext.this.context().wrapValueAsValue(value));
|
|
}
|
|
|
|
@Override
|
|
public boolean put(V newValue) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
CompiledReplicatedMapIterationContext.this.replaceValue(CompiledReplicatedMapIterationContext.this, CompiledReplicatedMapIterationContext.this.context().wrapValueAsValue(newValue));
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public long keySize() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.keySize();
|
|
}
|
|
|
|
@Override
|
|
public long valueOffset() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.valueOffset();
|
|
}
|
|
|
|
@Override
|
|
public long valueSize() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.valueSize();
|
|
}
|
|
|
|
@Override
|
|
public long keyOffset() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.keyOffset();
|
|
}
|
|
}
|
|
|
|
public class DummyValueZeroData extends AbstractData<V, Void> {
|
|
@Override
|
|
public long size() {
|
|
return CompiledReplicatedMapIterationContext.this.m().valueSizeMarshaller.minEncodableSize();
|
|
}
|
|
|
|
@Override
|
|
public long offset() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public Void handle() {
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public V getUsing(V usingInstance) {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
@Override
|
|
public ReadAccess<Void> access() {
|
|
return ReadAccess.zeros();
|
|
}
|
|
|
|
@Override
|
|
public V get() {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
}
|
|
|
|
public class EntryKeyBytesData extends AbstractData<K, T> {
|
|
@Override
|
|
public T handle() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.entryBytesAccessHandle;
|
|
}
|
|
|
|
@Override
|
|
public ReadAccess<T> access() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.entryBytesAccess;
|
|
}
|
|
|
|
@Override
|
|
public long size() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.keySize();
|
|
}
|
|
|
|
public void closeEntryKeyBytesDataSizeDependants() {
|
|
EntryKeyBytesData.this.closeEntryKeyBytesDataInnerGetUsingDependants();
|
|
}
|
|
|
|
@Override
|
|
public long offset() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.entryBytesAccessOffset(CompiledReplicatedMapIterationContext.this.keyOffset());
|
|
}
|
|
|
|
private K innerGetUsing(K usingKey) {
|
|
CompiledReplicatedMapIterationContext.this.entryBytes.position(CompiledReplicatedMapIterationContext.this.keyOffset());
|
|
return CompiledReplicatedMapIterationContext.this.keyReader.read(CompiledReplicatedMapIterationContext.this.entryBytes, size(), usingKey);
|
|
}
|
|
|
|
public void closeEntryKeyBytesDataInnerGetUsingDependants() {
|
|
EntryKeyBytesData.this.closeCachedEntryKey();
|
|
}
|
|
|
|
private K cachedEntryKey;
|
|
|
|
private boolean cachedEntryKeyRead = false;
|
|
|
|
public boolean cachedEntryKeyInit() {
|
|
return (this.cachedEntryKeyRead) != false;
|
|
}
|
|
|
|
private void initCachedEntryKey() {
|
|
cachedEntryKey = innerGetUsing(cachedEntryKey);
|
|
cachedEntryKeyRead = true;
|
|
}
|
|
|
|
public K cachedEntryKey() {
|
|
if (!(this.cachedEntryKeyInit()))
|
|
this.initCachedEntryKey();
|
|
|
|
return this.cachedEntryKey;
|
|
}
|
|
|
|
public void closeCachedEntryKey() {
|
|
if (!(this.cachedEntryKeyInit()))
|
|
return ;
|
|
|
|
this.cachedEntryKeyRead = false;
|
|
}
|
|
|
|
@Override
|
|
public K get() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return cachedEntryKey();
|
|
}
|
|
|
|
@Override
|
|
public K getUsing(K usingKey) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return innerGetUsing(usingKey);
|
|
}
|
|
}
|
|
|
|
public class EntryValueBytesData extends AbstractData<V, T> {
|
|
@Override
|
|
public T handle() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.entryBytesAccessHandle;
|
|
}
|
|
|
|
@Override
|
|
public ReadAccess<T> access() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.entryBytesAccess;
|
|
}
|
|
|
|
@Override
|
|
public long offset() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.entryBytesAccessOffset(CompiledReplicatedMapIterationContext.this.valueOffset());
|
|
}
|
|
|
|
@Override
|
|
public long size() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.valueSize();
|
|
}
|
|
|
|
public void closeEntryValueBytesDataSizeDependants() {
|
|
EntryValueBytesData.this.closeEntryValueBytesDataInnerGetUsingDependants();
|
|
}
|
|
|
|
private V innerGetUsing(V usingValue) {
|
|
CompiledReplicatedMapIterationContext.this.entryBytes.position(CompiledReplicatedMapIterationContext.this.valueOffset());
|
|
return CompiledReplicatedMapIterationContext.this.valueReader.read(CompiledReplicatedMapIterationContext.this.entryBytes, size(), usingValue);
|
|
}
|
|
|
|
public void closeEntryValueBytesDataInnerGetUsingDependants() {
|
|
EntryValueBytesData.this.closeCachedEntryValue();
|
|
}
|
|
|
|
private V cachedEntryValue;
|
|
|
|
private boolean cachedEntryValueRead = false;
|
|
|
|
public boolean cachedEntryValueInit() {
|
|
return (this.cachedEntryValueRead) != false;
|
|
}
|
|
|
|
private void initCachedEntryValue() {
|
|
cachedEntryValue = innerGetUsing(cachedEntryValue);
|
|
cachedEntryValueRead = true;
|
|
}
|
|
|
|
public V cachedEntryValue() {
|
|
if (!(this.cachedEntryValueInit()))
|
|
this.initCachedEntryValue();
|
|
|
|
return this.cachedEntryValue;
|
|
}
|
|
|
|
public void closeCachedEntryValue() {
|
|
if (!(this.cachedEntryValueInit()))
|
|
return ;
|
|
|
|
this.cachedEntryValueRead = false;
|
|
}
|
|
|
|
@Override
|
|
public V get() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return cachedEntryValue();
|
|
}
|
|
|
|
@Override
|
|
public V getUsing(V usingValue) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return innerGetUsing(usingValue);
|
|
}
|
|
}
|
|
|
|
public class ReadLock implements InterProcessLock {
|
|
@Override
|
|
public void lockInterruptibly() throws InterruptedException {
|
|
if ((CompiledReplicatedMapIterationContext.this.localLockState()) == (LocalLockState.UNLOCKED)) {
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().readLockInterruptibly(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.READ_LOCKED);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void lock() {
|
|
if ((CompiledReplicatedMapIterationContext.this.localLockState()) == (LocalLockState.UNLOCKED)) {
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().readLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.READ_LOCKED);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void unlock() {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
return ;
|
|
case READ_LOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().readUnlock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
break;
|
|
case UPDATE_LOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().updateUnlock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
break;
|
|
case WRITE_LOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().writeUnlock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
}
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.UNLOCKED);
|
|
CompiledReplicatedMapIterationContext.this.closeHashLookupPos();
|
|
CompiledReplicatedMapIterationContext.this.closePos();
|
|
}
|
|
|
|
@Override
|
|
public boolean isHeldByCurrentThread() {
|
|
return CompiledReplicatedMapIterationContext.this.localLockState().read;
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock(long time, @NotNull
|
|
TimeUnit unit) throws InterruptedException {
|
|
if ((CompiledReplicatedMapIterationContext.this.localLockState()) == (LocalLockState.UNLOCKED)) {
|
|
if (CompiledReplicatedMapIterationContext.this.segmentHeader().tryReadLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress(), time, unit)) {
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.READ_LOCKED);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock() {
|
|
if ((CompiledReplicatedMapIterationContext.this.localLockState()) == (LocalLockState.UNLOCKED)) {
|
|
if (CompiledReplicatedMapIterationContext.this.segmentHeader().tryReadLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress())) {
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.READ_LOCKED);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class UpdateLock implements InterProcessLock {
|
|
@NotNull
|
|
private IllegalMonitorStateException forbiddenUpgrade() {
|
|
return new IllegalMonitorStateException("Cannot upgrade from read to update lock");
|
|
}
|
|
|
|
@Override
|
|
public boolean isHeldByCurrentThread() {
|
|
return CompiledReplicatedMapIterationContext.this.localLockState().update;
|
|
}
|
|
|
|
@Override
|
|
public void lockInterruptibly() throws InterruptedException {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().updateLockInterruptibly(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.UPDATE_LOCKED);
|
|
return ;
|
|
case READ_LOCKED :
|
|
throw forbiddenUpgrade();
|
|
case UPDATE_LOCKED :
|
|
case WRITE_LOCKED :
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock() {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
if (CompiledReplicatedMapIterationContext.this.segmentHeader().tryUpdateLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress())) {
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.UPDATE_LOCKED);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
case READ_LOCKED :
|
|
throw forbiddenUpgrade();
|
|
case UPDATE_LOCKED :
|
|
case WRITE_LOCKED :
|
|
return true;
|
|
}
|
|
throw new AssertionError();
|
|
}
|
|
|
|
@Override
|
|
public void lock() {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().updateLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.UPDATE_LOCKED);
|
|
return ;
|
|
case READ_LOCKED :
|
|
throw forbiddenUpgrade();
|
|
case UPDATE_LOCKED :
|
|
case WRITE_LOCKED :
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void unlock() {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
case READ_LOCKED :
|
|
return ;
|
|
case UPDATE_LOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().downgradeUpdateToReadLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
break;
|
|
case WRITE_LOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().downgradeWriteToReadLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
}
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.READ_LOCKED);
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock(long time, @NotNull
|
|
TimeUnit unit) throws InterruptedException {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
if (CompiledReplicatedMapIterationContext.this.segmentHeader().tryUpdateLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress(), time, unit)) {
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.UPDATE_LOCKED);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
case READ_LOCKED :
|
|
throw forbiddenUpgrade();
|
|
case UPDATE_LOCKED :
|
|
case WRITE_LOCKED :
|
|
return true;
|
|
}
|
|
throw new AssertionError();
|
|
}
|
|
}
|
|
|
|
public class WrappedValueInstanceData extends CopyingInstanceData<V, T> {
|
|
public WrappedValueInstanceData getUnusedWrappedValueGuarded() {
|
|
assert this.nextInit() : "Next should be init";
|
|
return getUnusedWrappedValue();
|
|
}
|
|
|
|
public WrappedValueInstanceData getUnusedWrappedValue() {
|
|
if (!(valueInit()))
|
|
return this;
|
|
|
|
if ((next) == null)
|
|
next = new WrappedValueInstanceData();
|
|
|
|
return next.getUnusedWrappedValue();
|
|
}
|
|
|
|
private WrappedValueInstanceData next;
|
|
|
|
boolean nextInit() {
|
|
return true;
|
|
}
|
|
|
|
void closeNext() {
|
|
if (!(this.nextInit()))
|
|
return ;
|
|
|
|
}
|
|
|
|
private V value;
|
|
|
|
public boolean valueInit() {
|
|
return (value) != null;
|
|
}
|
|
|
|
public void initValue(V value) {
|
|
CompiledReplicatedMapIterationContext.this.m().checkValue(value);
|
|
this.value = value;
|
|
this.closeValueDependants();
|
|
}
|
|
|
|
public V value() {
|
|
assert this.valueInit() : "Value should be init";
|
|
return this.value;
|
|
}
|
|
|
|
public void closeValue() {
|
|
if (!(this.valueInit()))
|
|
return ;
|
|
|
|
this.closeValueDependants();
|
|
value = null;
|
|
if ((next) != null)
|
|
next.closeValue();
|
|
|
|
}
|
|
|
|
public void closeValueDependants() {
|
|
WrappedValueInstanceData.this.closeBuffer();
|
|
}
|
|
|
|
@Override
|
|
public V instance() {
|
|
return value();
|
|
}
|
|
|
|
private boolean marshalled = false;
|
|
|
|
private DirectBytes buf;
|
|
|
|
public boolean bufferInit() {
|
|
return (this.marshalled) != false;
|
|
}
|
|
|
|
private void initBuffer() {
|
|
MVI mvi = CompiledReplicatedMapIterationContext.this.valueMetaInterop(value());
|
|
long size = mvi.size(CompiledReplicatedMapIterationContext.this.valueInterop, value());
|
|
buf = CopyingInstanceData.getBuffer(this.buf, size);
|
|
mvi.write(CompiledReplicatedMapIterationContext.this.valueInterop, buf, value());
|
|
buf.flip();
|
|
marshalled = true;
|
|
}
|
|
|
|
public DirectBytes buf() {
|
|
if (!(this.bufferInit()))
|
|
this.initBuffer();
|
|
|
|
return this.buf;
|
|
}
|
|
|
|
public void closeBuffer() {
|
|
if (!(this.bufferInit()))
|
|
return ;
|
|
|
|
this.marshalled = false;
|
|
}
|
|
|
|
@Override
|
|
public DirectBytes buffer() {
|
|
return buf();
|
|
}
|
|
|
|
@Override
|
|
public V getUsing(V usingValue) {
|
|
buf().position(0);
|
|
return CompiledReplicatedMapIterationContext.this.valueReader.read(buf(), buf().limit(), usingValue);
|
|
}
|
|
}
|
|
|
|
public class WriteLock implements InterProcessLock {
|
|
@NotNull
|
|
private IllegalMonitorStateException forbiddenUpgrade() {
|
|
return new IllegalMonitorStateException("Cannot upgrade from read to write lock");
|
|
}
|
|
|
|
public void closeWriteLockForbiddenUpgradeDependants() {
|
|
WriteLock.this.closeWriteLockLockDependants();
|
|
}
|
|
|
|
@Override
|
|
public void lockInterruptibly() throws InterruptedException {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().writeLockInterruptibly(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.WRITE_LOCKED);
|
|
return ;
|
|
case READ_LOCKED :
|
|
throw forbiddenUpgrade();
|
|
case UPDATE_LOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().upgradeUpdateToWriteLockInterruptibly(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.WRITE_LOCKED);
|
|
case WRITE_LOCKED :
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void unlock() {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
case READ_LOCKED :
|
|
case UPDATE_LOCKED :
|
|
return ;
|
|
case WRITE_LOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().downgradeWriteToUpdateLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
}
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.UPDATE_LOCKED);
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock() {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
if (CompiledReplicatedMapIterationContext.this.segmentHeader().tryWriteLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress())) {
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.WRITE_LOCKED);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
case READ_LOCKED :
|
|
throw forbiddenUpgrade();
|
|
case UPDATE_LOCKED :
|
|
if (CompiledReplicatedMapIterationContext.this.segmentHeader().tryUpgradeUpdateToWriteLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress())) {
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.WRITE_LOCKED);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
case WRITE_LOCKED :
|
|
return true;
|
|
}
|
|
throw new AssertionError();
|
|
}
|
|
|
|
@Override
|
|
public boolean isHeldByCurrentThread() {
|
|
return CompiledReplicatedMapIterationContext.this.localLockState().write;
|
|
}
|
|
|
|
@Override
|
|
public boolean tryLock(long time, @NotNull
|
|
TimeUnit unit) throws InterruptedException {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
if (CompiledReplicatedMapIterationContext.this.segmentHeader().tryWriteLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress(), time, unit)) {
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.WRITE_LOCKED);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
case READ_LOCKED :
|
|
throw forbiddenUpgrade();
|
|
case UPDATE_LOCKED :
|
|
if (CompiledReplicatedMapIterationContext.this.segmentHeader().tryUpgradeUpdateToWriteLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress(), time, unit)) {
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.WRITE_LOCKED);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
case WRITE_LOCKED :
|
|
return true;
|
|
}
|
|
throw new AssertionError();
|
|
}
|
|
|
|
@Override
|
|
public void lock() {
|
|
switch (CompiledReplicatedMapIterationContext.this.localLockState()) {
|
|
case UNLOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().writeLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.WRITE_LOCKED);
|
|
return ;
|
|
case READ_LOCKED :
|
|
throw forbiddenUpgrade();
|
|
case UPDATE_LOCKED :
|
|
CompiledReplicatedMapIterationContext.this.segmentHeader().upgradeUpdateToWriteLock(CompiledReplicatedMapIterationContext.this.segmentHeaderAddress());
|
|
CompiledReplicatedMapIterationContext.this.setLocalLockStateGuarded(LocalLockState.WRITE_LOCKED);
|
|
case WRITE_LOCKED :
|
|
}
|
|
}
|
|
|
|
public void closeWriteLockLockDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeUpdatedReplicationState();
|
|
}
|
|
}
|
|
|
|
public void incrementModCount() {
|
|
contextModCount = rootContextOnThisSegment.latestSameThreadSegmentModCount = (rootContextOnThisSegment.latestSameThreadSegmentModCount) + 1;
|
|
}
|
|
|
|
public void setHashLookupPos(long hashLookupPos) {
|
|
this.hashLookupPos = hashLookupPos;
|
|
}
|
|
|
|
public void setLocalLockState(LocalLockState newState) {
|
|
localLockState = newState;
|
|
}
|
|
|
|
final Thread owner;
|
|
|
|
public Thread owner() {
|
|
return this.owner;
|
|
}
|
|
|
|
private void closeNestedLocks() {
|
|
unlinkFromSegmentContextsChain();
|
|
switch (localLockState) {
|
|
case UNLOCKED :
|
|
break;
|
|
case READ_LOCKED :
|
|
int newTotalReadLockCount = this.rootContextOnThisSegment.totalReadLockCount -= 1;
|
|
if (newTotalReadLockCount == 0) {
|
|
if (((this.rootContextOnThisSegment.totalUpdateLockCount) == 0) && ((this.rootContextOnThisSegment.totalWriteLockCount) == 0)) {
|
|
segmentHeader().readUnlock(segmentHeaderAddress());
|
|
}
|
|
} else if (newTotalReadLockCount < 0) {
|
|
throw new IllegalStateException("read underflow");
|
|
}
|
|
break;
|
|
case UPDATE_LOCKED :
|
|
int newTotalUpdateLockCount = this.rootContextOnThisSegment.totalUpdateLockCount -= 1;
|
|
if (newTotalUpdateLockCount == 0) {
|
|
if ((this.rootContextOnThisSegment.totalWriteLockCount) == 0) {
|
|
if ((this.rootContextOnThisSegment.totalReadLockCount) == 0) {
|
|
segmentHeader().updateUnlock(segmentHeaderAddress());
|
|
} else {
|
|
segmentHeader().downgradeUpdateToReadLock(segmentHeaderAddress());
|
|
}
|
|
}
|
|
} else if (newTotalUpdateLockCount < 0) {
|
|
throw new IllegalStateException("update underflow");
|
|
}
|
|
break;
|
|
case WRITE_LOCKED :
|
|
int newTotalWriteLockCount = this.rootContextOnThisSegment.totalWriteLockCount -= 1;
|
|
if (newTotalWriteLockCount == 0) {
|
|
if ((this.rootContextOnThisSegment.totalUpdateLockCount) > 0) {
|
|
segmentHeader().downgradeWriteToUpdateLock(segmentHeaderAddress());
|
|
} else {
|
|
if ((this.rootContextOnThisSegment.totalReadLockCount) > 0) {
|
|
segmentHeader().downgradeWriteToReadLock(segmentHeaderAddress());
|
|
} else {
|
|
segmentHeader().writeUnlock(segmentHeaderAddress());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void closeRootLocks() {
|
|
assert (nextNode) == null;
|
|
switch (localLockState) {
|
|
case UNLOCKED :
|
|
return ;
|
|
case READ_LOCKED :
|
|
segmentHeader().readUnlock(segmentHeaderAddress());
|
|
return ;
|
|
case UPDATE_LOCKED :
|
|
segmentHeader().updateUnlock(segmentHeaderAddress());
|
|
return ;
|
|
case WRITE_LOCKED :
|
|
segmentHeader().writeUnlock(segmentHeaderAddress());
|
|
}
|
|
}
|
|
|
|
private void innerInitSegmentHashLookup(long address, long capacity, int entrySize, int keyBits, int valueBits) {
|
|
this.address = address;
|
|
this.capacityMask = capacity - 1L;
|
|
this.hashLookupEntrySize = entrySize;
|
|
this.capacityMask2 = (capacityMask) * entrySize;
|
|
this.keyBits = keyBits;
|
|
this.keyMask = CompiledReplicatedMapIterationContext.mask(keyBits);
|
|
this.valueMask = CompiledReplicatedMapIterationContext.mask(valueBits);
|
|
this.entryMask = CompiledReplicatedMapIterationContext.mask((keyBits + valueBits));
|
|
}
|
|
|
|
private void unlinkFromSegmentContextsChain() {
|
|
CompiledReplicatedMapIterationContext prevContext = this.rootContextOnThisSegment;
|
|
while (true) {
|
|
assert (prevContext.nextNode) != null;
|
|
if ((prevContext.nextNode) == this)
|
|
break;
|
|
|
|
prevContext = prevContext.nextNode;
|
|
}
|
|
assert (nextNode) == null;
|
|
prevContext.nextNode = null;
|
|
}
|
|
|
|
public final int indexInContextChain;
|
|
|
|
public int indexInContextChain() {
|
|
return this.indexInContextChain;
|
|
}
|
|
|
|
public static int entrySize(int keyBits, int valueBits) {
|
|
return ((int)(MemoryUnit.BYTES.alignAndConvert(((long)(keyBits + valueBits)), MemoryUnit.BITS)));
|
|
}
|
|
|
|
public static int keyBits(long entriesPerSegment, int valueBits) {
|
|
int minKeyBits = 64 - (Long.numberOfLeadingZeros((entriesPerSegment - 1L)));
|
|
minKeyBits += 3;
|
|
int actualEntryBits = ((int)(MemoryUnit.BYTES.align(((long)(minKeyBits + valueBits)), MemoryUnit.BITS)));
|
|
return actualEntryBits - valueBits;
|
|
}
|
|
|
|
public static int valueBits(long actualChunksPerSegment) {
|
|
return 64 - (Long.numberOfLeadingZeros((actualChunksPerSegment - 1L)));
|
|
}
|
|
|
|
public final Bytes entryBytes;
|
|
|
|
public Bytes entryBytes() {
|
|
return this.entryBytes;
|
|
}
|
|
|
|
public static long capacityFor(long entriesPerSegment) {
|
|
if (entriesPerSegment < 0L)
|
|
throw new IllegalArgumentException("entriesPerSegment should be positive");
|
|
|
|
long capacity = Maths.nextPower2(entriesPerSegment, 64L);
|
|
if ((((double)(entriesPerSegment)) / ((double)(capacity))) > (2.0 / 3.0)) {
|
|
capacity <<= 1L;
|
|
}
|
|
return capacity;
|
|
}
|
|
|
|
public static long mask(int bits) {
|
|
return (1L << bits) - 1L;
|
|
}
|
|
|
|
public static final int MAX_SEGMENT_CHUNKS = 1 << 30;
|
|
|
|
public static final int MAX_SEGMENT_ENTRIES = 1 << 29;
|
|
|
|
public int MAX_SEGMENT_ENTRIES() {
|
|
return this.MAX_SEGMENT_ENTRIES;
|
|
}
|
|
|
|
public int MAX_SEGMENT_CHUNKS() {
|
|
return this.MAX_SEGMENT_CHUNKS;
|
|
}
|
|
|
|
public static final long UNSET_KEY = 0L;
|
|
|
|
public static final long UNSET_ENTRY = 0L;
|
|
|
|
public long UNSET_ENTRY() {
|
|
return this.UNSET_ENTRY;
|
|
}
|
|
|
|
public long UNSET_KEY() {
|
|
return this.UNSET_KEY;
|
|
}
|
|
|
|
public final ReadLock innerReadLock;
|
|
|
|
public ReadLock innerReadLock() {
|
|
return this.innerReadLock;
|
|
}
|
|
|
|
public final WriteLock innerWriteLock;
|
|
|
|
public WriteLock innerWriteLock() {
|
|
return this.innerWriteLock;
|
|
}
|
|
|
|
public final List<CompiledReplicatedMapIterationContext> contextChain;
|
|
|
|
public final UpdateLock innerUpdateLock;
|
|
|
|
public UpdateLock innerUpdateLock() {
|
|
return this.innerUpdateLock;
|
|
}
|
|
|
|
public List<CompiledReplicatedMapIterationContext> contextChain() {
|
|
return this.contextChain;
|
|
}
|
|
|
|
public final ThreadLocalCopies copies;
|
|
|
|
public ThreadLocalCopies copies() {
|
|
return this.copies;
|
|
}
|
|
|
|
private void countValueOffset() {
|
|
CompiledReplicatedMapIterationContext.this.m().alignment.alignPositionAddr(entryBytes);
|
|
valueOffset = entryBytes.position();
|
|
}
|
|
|
|
final DummyValueZeroData dummyValue;
|
|
|
|
public DummyValueZeroData dummyValue() {
|
|
return this.dummyValue;
|
|
}
|
|
|
|
final EntryKeyBytesData entryKey;
|
|
|
|
public EntryKeyBytesData entryKey() {
|
|
return this.entryKey;
|
|
}
|
|
|
|
public final EntryValueBytesData entryValue;
|
|
|
|
public EntryValueBytesData entryValue() {
|
|
return this.entryValue;
|
|
}
|
|
|
|
final WrappedValueInstanceData wrappedValueInstanceValue;
|
|
|
|
public WrappedValueInstanceData wrappedValueInstanceValue() {
|
|
return this.wrappedValueInstanceValue;
|
|
}
|
|
|
|
public final DeprecatedMapKeyContextOnIteration deprecatedMapKeyContextOnIteration;
|
|
|
|
public DeprecatedMapKeyContextOnIteration deprecatedMapKeyContextOnIteration() {
|
|
return this.deprecatedMapKeyContextOnIteration;
|
|
}
|
|
|
|
private final ReplicatedChronicleMap<K, KI, MKI, V, VI, MVI, R> m;
|
|
|
|
public final VI valueInterop;
|
|
|
|
public VI valueInterop() {
|
|
return this.valueInterop;
|
|
}
|
|
|
|
final Full<Bytes, ?> entryBytesAccessor;
|
|
|
|
public Full<Bytes, ?> entryBytesAccessor() {
|
|
return this.entryBytesAccessor;
|
|
}
|
|
|
|
@SuppressWarnings(value = "unchecked")
|
|
public final T entryBytesAccessHandle;
|
|
|
|
public T entryBytesAccessHandle() {
|
|
return this.entryBytesAccessHandle;
|
|
}
|
|
|
|
public final BytesReader<V> valueReader;
|
|
|
|
public BytesReader<V> valueReader() {
|
|
return this.valueReader;
|
|
}
|
|
|
|
public final KI keyInterop;
|
|
|
|
public KI keyInterop() {
|
|
return this.keyInterop;
|
|
}
|
|
|
|
@SuppressWarnings(value = "unchecked")
|
|
public final Access<T> entryBytesAccess;
|
|
|
|
public Access<T> entryBytesAccess() {
|
|
return this.entryBytesAccess;
|
|
}
|
|
|
|
public final BytesReader<K> keyReader;
|
|
|
|
public BytesReader<K> keyReader() {
|
|
return this.keyReader;
|
|
}
|
|
|
|
public MKI keyMetaInterop(K key) {
|
|
return CompiledReplicatedMapIterationContext.this.h().metaKeyInteropProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.h().originalMetaKeyInterop, keyInterop, key);
|
|
}
|
|
|
|
public void checkAccessingFromOwnerThread() {
|
|
if ((owner) != (Thread.currentThread())) {
|
|
throw new ConcurrentModificationException("Context shouldn\'t be accessed from multiple threads");
|
|
}
|
|
}
|
|
|
|
public void closeOwnerThreadHolderCheckAccessingFromOwnerThreadDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeInterationCheckOnEachPublicOperationCheckOnEachPublicOperationDependants();
|
|
}
|
|
|
|
public MVI valueMetaInterop(V value) {
|
|
return CompiledReplicatedMapIterationContext.this.m().metaValueInteropProvider.get(CompiledReplicatedMapIterationContext.this.copies, CompiledReplicatedMapIterationContext.this.m().originalMetaValueInterop, valueInterop, value);
|
|
}
|
|
|
|
public void closeValueBytesInteropValueMetaInteropDependants() {
|
|
CompiledReplicatedMapIterationContext.this.wrappedValueInstanceValue.closeBuffer();
|
|
}
|
|
|
|
public void checkEntryNotRemovedOnThisIteration() {
|
|
if (entryRemovedOnThisIterationInit())
|
|
throw new IllegalStateException("Entry was already removed on this iteration");
|
|
|
|
}
|
|
|
|
public void closeReplicatedMapSegmentIterationCheckEntryNotRemovedOnThisIterationDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeInterationCheckOnEachPublicOperationCheckOnEachPublicOperationDependants();
|
|
}
|
|
|
|
private void _CheckOnEachPublicOperation_checkOnEachPublicOperation() {
|
|
CompiledReplicatedMapIterationContext.this.checkAccessingFromOwnerThread();
|
|
}
|
|
|
|
public void checkOnEachPublicOperation() {
|
|
_CheckOnEachPublicOperation_checkOnEachPublicOperation();
|
|
CompiledReplicatedMapIterationContext.this.checkEntryNotRemovedOnThisIteration();
|
|
}
|
|
|
|
public void closeInterationCheckOnEachPublicOperationCheckOnEachPublicOperationDependants() {
|
|
CompiledReplicatedMapIterationContext.this.entryKey.closeEntryKeyBytesDataSizeDependants();
|
|
CompiledReplicatedMapIterationContext.this.entryValue.closeEntryValueBytesDataSizeDependants();
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public InterProcessLock writeLock() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.innerWriteLock;
|
|
}
|
|
|
|
@Override
|
|
public Data<V, ?> wrapValueAsValue(V value) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
WrappedValueInstanceData wrapped = CompiledReplicatedMapIterationContext.this.wrappedValueInstanceValue;
|
|
wrapped = wrapped.getUnusedWrappedValueGuarded();
|
|
wrapped.initValue(value);
|
|
return wrapped;
|
|
}
|
|
|
|
@Override
|
|
public R replaceValue(@NotNull
|
|
MapEntry<K, V> entry, Data<V, ?> newValue) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.m().entryOperations.replaceValue(entry, newValue);
|
|
}
|
|
|
|
@Override
|
|
public R remove(@NotNull
|
|
MapEntry<K, V> entry) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.m().entryOperations.remove(entry);
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public Data<V, ?> value() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.entryValue;
|
|
}
|
|
|
|
@Override
|
|
public Data<V, ?> defaultValue(@NotNull
|
|
MapAbsentEntry<K, V> absentEntry) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.m().entryOperations.defaultValue(absentEntry);
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public Data<K, ?> key() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.entryKey;
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public InterProcessLock updateLock() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.innerUpdateLock;
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public InterProcessLock readLock() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.innerReadLock;
|
|
}
|
|
|
|
@Override
|
|
public R insert(@NotNull
|
|
MapAbsentEntry<K, V> absentEntry, Data<V, ?> value) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return CompiledReplicatedMapIterationContext.this.m().entryOperations.insert(absentEntry, value);
|
|
}
|
|
|
|
public long entryBytesAccessOffset(long offset) {
|
|
return entryBytesAccessor.offset(entryBytes, offset);
|
|
}
|
|
|
|
public void incrementSegmentEntriesIfNeeded() {
|
|
}
|
|
|
|
@Override
|
|
public ReplicatedChronicleMap<K, KI, MKI, V, VI, MVI, R> m() {
|
|
return m;
|
|
}
|
|
|
|
@Override
|
|
public ChronicleMap<K, V> map() {
|
|
return m();
|
|
}
|
|
|
|
public <T>T contextAtIndexInChain(int index) {
|
|
return ((T)(contextChain.get(index)));
|
|
}
|
|
|
|
public void closeReplicatedChronicleMapHolderImplContextAtIndexInChainDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeSegmentStagesTryFindInitLocksOfThisSegmentDependants();
|
|
}
|
|
|
|
private long _MapEntryStages_sizeOfEverythingBeforeValue(long keySize, long valueSize) {
|
|
return (((CompiledReplicatedMapIterationContext.this.m().metaDataBytes) + (CompiledReplicatedMapIterationContext.this.m().keySizeMarshaller.sizeEncodingSize(keySize))) + keySize) + (CompiledReplicatedMapIterationContext.this.m().valueSizeMarshaller.sizeEncodingSize(valueSize));
|
|
}
|
|
|
|
long sizeOfEverythingBeforeValue(long keySize, long valueSize) {
|
|
return (_MapEntryStages_sizeOfEverythingBeforeValue(keySize, valueSize)) + (ReplicatedChronicleMap.ADDITIONAL_ENTRY_BYTES);
|
|
}
|
|
|
|
public long innerEntrySize(long sizeOfEverythingBeforeValue, long valueSize) {
|
|
if (CompiledReplicatedMapIterationContext.this.m().constantlySizedEntry) {
|
|
return CompiledReplicatedMapIterationContext.this.m().alignment.alignAddr((sizeOfEverythingBeforeValue + valueSize));
|
|
} else if (CompiledReplicatedMapIterationContext.this.m().couldNotDetermineAlignmentBeforeAllocation) {
|
|
return (sizeOfEverythingBeforeValue + (CompiledReplicatedMapIterationContext.this.m().worstAlignment)) + valueSize;
|
|
} else {
|
|
return (CompiledReplicatedMapIterationContext.this.m().alignment.alignAddr(sizeOfEverythingBeforeValue)) + valueSize;
|
|
}
|
|
}
|
|
|
|
public final long entrySize(long keySize, long valueSize) {
|
|
long sizeOfEverythingBeforeValue = sizeOfEverythingBeforeValue(keySize, valueSize);
|
|
return innerEntrySize(sizeOfEverythingBeforeValue, valueSize);
|
|
}
|
|
|
|
private CompiledReplicatedMapIterationContext _Chaining_createChaining() {
|
|
return new CompiledReplicatedMapIterationContext(this);
|
|
}
|
|
|
|
public CompiledReplicatedMapIterationContext createChaining() {
|
|
return new CompiledReplicatedMapIterationContext(this);
|
|
}
|
|
|
|
public <T>T getContext() {
|
|
for (CompiledReplicatedMapIterationContext context : contextChain) {
|
|
if (!(context.usedInit())) {
|
|
return ((T)(context));
|
|
}
|
|
}
|
|
int maxNestedContexts = 1 << 16;
|
|
if ((contextChain.size()) > maxNestedContexts) {
|
|
throw new IllegalStateException((((((("More than " + maxNestedContexts) + " 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"));
|
|
}
|
|
return ((T)(createChaining()));
|
|
}
|
|
|
|
@NotNull
|
|
@Override
|
|
public MapContext<K, V, ?> context() {
|
|
return CompiledReplicatedMapIterationContext.this;
|
|
}
|
|
|
|
public long hashLookupPos = -1;
|
|
|
|
public boolean hashLookupPosInit() {
|
|
return (this.hashLookupPos) >= 0;
|
|
}
|
|
|
|
public void initHashLookupPos(long hashLookupPos) {
|
|
this.hashLookupPos = hashLookupPos;
|
|
}
|
|
|
|
public long hashLookupPos() {
|
|
assert this.hashLookupPosInit() : "HashLookupPos should be init";
|
|
return this.hashLookupPos;
|
|
}
|
|
|
|
public void closeHashLookupPos() {
|
|
if (!(this.hashLookupPosInit()))
|
|
return ;
|
|
|
|
this.hashLookupPos = -1;
|
|
}
|
|
|
|
public long keySize = -1;
|
|
|
|
public boolean keySizeInit() {
|
|
return (this.keySize) >= 0;
|
|
}
|
|
|
|
public void initKeySize(long keySize) {
|
|
this.keySize = keySize;
|
|
this.closeKeySizeDependants();
|
|
}
|
|
|
|
public long keySize() {
|
|
assert this.keySizeInit() : "KeySize should be init";
|
|
return this.keySize;
|
|
}
|
|
|
|
public void closeKeySize() {
|
|
if (!(this.keySizeInit()))
|
|
return ;
|
|
|
|
this.closeKeySizeDependants();
|
|
this.keySize = -1;
|
|
}
|
|
|
|
public void closeKeySizeDependants() {
|
|
CompiledReplicatedMapIterationContext.this.entryKey.closeEntryKeyBytesDataSizeDependants();
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesKeyEndDependants();
|
|
}
|
|
|
|
public int segmentIndex = -1;
|
|
|
|
public boolean theSegmentIndexInit() {
|
|
return (this.segmentIndex) >= 0;
|
|
}
|
|
|
|
public void initTheSegmentIndex(int segmentIndex) {
|
|
this.segmentIndex = segmentIndex;
|
|
this.closeTheSegmentIndexDependants();
|
|
}
|
|
|
|
public int segmentIndex() {
|
|
assert this.theSegmentIndexInit() : "TheSegmentIndex should be init";
|
|
return this.segmentIndex;
|
|
}
|
|
|
|
public void closeTheSegmentIndex() {
|
|
if (!(this.theSegmentIndexInit()))
|
|
return ;
|
|
|
|
this.closeTheSegmentIndexDependants();
|
|
this.segmentIndex = -1;
|
|
}
|
|
|
|
public void closeTheSegmentIndexDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeSegHeader();
|
|
CompiledReplicatedMapIterationContext.this.closeSegmentHashLookup();
|
|
CompiledReplicatedMapIterationContext.this.closeSegment();
|
|
}
|
|
|
|
long segmentHeaderAddress;
|
|
|
|
SegmentHeader segmentHeader = null;
|
|
|
|
public boolean segHeaderInit() {
|
|
return (this.segmentHeader) != null;
|
|
}
|
|
|
|
private void initSegHeader() {
|
|
segmentHeaderAddress = (CompiledReplicatedMapIterationContext.this.h().ms.address()) + (CompiledReplicatedMapIterationContext.this.h().segmentHeaderOffset(segmentIndex()));
|
|
segmentHeader = BigSegmentHeader.INSTANCE;
|
|
this.closeSegHeaderDependants();
|
|
}
|
|
|
|
public long segmentHeaderAddress() {
|
|
if (!(this.segHeaderInit()))
|
|
this.initSegHeader();
|
|
|
|
return this.segmentHeaderAddress;
|
|
}
|
|
|
|
public SegmentHeader segmentHeader() {
|
|
if (!(this.segHeaderInit()))
|
|
this.initSegHeader();
|
|
|
|
return this.segmentHeader;
|
|
}
|
|
|
|
public void closeSegHeader() {
|
|
if (!(this.segHeaderInit()))
|
|
return ;
|
|
|
|
this.closeSegHeaderDependants();
|
|
this.segmentHeader = null;
|
|
}
|
|
|
|
public void closeSegHeaderDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeSegmentStagesTryFindInitLocksOfThisSegmentDependants();
|
|
CompiledReplicatedMapIterationContext.this.closeLocks();
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.closeWriteLockLockDependants();
|
|
}
|
|
|
|
public void deleted(long deleted) {
|
|
segmentHeader().deleted(segmentHeaderAddress(), deleted);
|
|
}
|
|
|
|
public long deleted() {
|
|
return segmentHeader().deleted(segmentHeaderAddress());
|
|
}
|
|
|
|
public long entries() {
|
|
return segmentHeader().size(segmentHeaderAddress());
|
|
}
|
|
|
|
public long size() {
|
|
return (entries()) - (deleted());
|
|
}
|
|
|
|
boolean tryFindInitLocksOfThisSegment(Object thisContext, int index) {
|
|
CompiledReplicatedMapIterationContext c = CompiledReplicatedMapIterationContext.this.contextAtIndexInChain(index);
|
|
if ((((c.segmentHeader()) != null) && ((c.segmentHeaderAddress()) == (segmentHeaderAddress()))) && ((c.rootContextOnThisSegment()) != null)) {
|
|
throw new IllegalStateException("Nested context not implemented yet");
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void closeSegmentStagesTryFindInitLocksOfThisSegmentDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeLocks();
|
|
}
|
|
|
|
int totalReadLockCount;
|
|
|
|
int totalUpdateLockCount;
|
|
|
|
int totalWriteLockCount;
|
|
|
|
public int latestSameThreadSegmentModCount;
|
|
|
|
public int contextModCount;
|
|
|
|
CompiledReplicatedMapIterationContext nextNode;
|
|
|
|
public boolean concurrentSameThreadContexts;
|
|
|
|
LocalLockState localLockState;
|
|
|
|
public CompiledReplicatedMapIterationContext rootContextOnThisSegment = null;
|
|
|
|
public boolean locksInit() {
|
|
return (this.rootContextOnThisSegment) != null;
|
|
}
|
|
|
|
void initLocks() {
|
|
localLockState = LocalLockState.UNLOCKED;
|
|
int indexOfThisContext = CompiledReplicatedMapIterationContext.this.indexInContextChain;
|
|
for (int i = indexOfThisContext - 1 ; i >= 0 ; i--) {
|
|
if (tryFindInitLocksOfThisSegment(this, i))
|
|
return ;
|
|
|
|
}
|
|
for (int i = indexOfThisContext + 1, size = CompiledReplicatedMapIterationContext.this.contextChain.size() ; i < size ; i++) {
|
|
if (tryFindInitLocksOfThisSegment(this, i))
|
|
return ;
|
|
|
|
}
|
|
rootContextOnThisSegment = this;
|
|
concurrentSameThreadContexts = false;
|
|
latestSameThreadSegmentModCount = 0;
|
|
contextModCount = 0;
|
|
nextNode = null;
|
|
totalReadLockCount = 0;
|
|
totalUpdateLockCount = 0;
|
|
totalWriteLockCount = 0;
|
|
this.closeLocksDependants();
|
|
}
|
|
|
|
public LocalLockState localLockState() {
|
|
if (!(this.locksInit()))
|
|
this.initLocks();
|
|
|
|
return this.localLockState;
|
|
}
|
|
|
|
public CompiledReplicatedMapIterationContext rootContextOnThisSegment() {
|
|
if (!(this.locksInit()))
|
|
this.initLocks();
|
|
|
|
return this.rootContextOnThisSegment;
|
|
}
|
|
|
|
void closeLocks() {
|
|
if (!(this.locksInit()))
|
|
return ;
|
|
|
|
this.closeLocksDependants();
|
|
if ((rootContextOnThisSegment) == this) {
|
|
closeRootLocks();
|
|
} else {
|
|
closeNestedLocks();
|
|
}
|
|
localLockState = null;
|
|
rootContextOnThisSegment = null;
|
|
}
|
|
|
|
public void closeLocksDependants() {
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.closeWriteLockLockDependants();
|
|
}
|
|
|
|
public void entries(long size) {
|
|
segmentHeader().size(segmentHeaderAddress(), size);
|
|
}
|
|
|
|
long nextPosToSearchFrom() {
|
|
return segmentHeader().nextPosToSearchFrom(segmentHeaderAddress());
|
|
}
|
|
|
|
public void nextPosToSearchFrom(long nextPosToSearchFrom) {
|
|
segmentHeader().nextPosToSearchFrom(segmentHeaderAddress(), nextPosToSearchFrom);
|
|
}
|
|
|
|
public void updateNextPosToSearchFrom(long allocated, int chunks) {
|
|
long nextPosToSearchFrom = allocated + chunks;
|
|
if (nextPosToSearchFrom >= (CompiledReplicatedMapIterationContext.this.h().actualChunksPerSegment))
|
|
nextPosToSearchFrom = 0L;
|
|
|
|
nextPosToSearchFrom(nextPosToSearchFrom);
|
|
}
|
|
|
|
int hashLookupEntrySize;
|
|
|
|
int keyBits;
|
|
|
|
long address = -1;
|
|
|
|
long capacityMask;
|
|
|
|
long capacityMask2;
|
|
|
|
long keyMask;
|
|
|
|
long valueMask;
|
|
|
|
long entryMask;
|
|
|
|
public boolean segmentHashLookupInit() {
|
|
return (this.address) >= 0;
|
|
}
|
|
|
|
public void initSegmentHashLookup() {
|
|
long hashLookupOffset = CompiledReplicatedMapIterationContext.this.h().segmentOffset(CompiledReplicatedMapIterationContext.this.segmentIndex());
|
|
innerInitSegmentHashLookup(((CompiledReplicatedMapIterationContext.this.h().ms.address()) + hashLookupOffset), CompiledReplicatedMapIterationContext.this.h().segmentHashLookupCapacity, CompiledReplicatedMapIterationContext.this.h().segmentHashLookupEntrySize, CompiledReplicatedMapIterationContext.this.h().segmentHashLookupKeyBits, CompiledReplicatedMapIterationContext.this.h().segmentHashLookupValueBits);
|
|
}
|
|
|
|
public void initSegmentHashLookup(long address, long capacity, int entrySize, int keyBits, int valueBits) {
|
|
innerInitSegmentHashLookup(address, capacity, entrySize, keyBits, valueBits);
|
|
}
|
|
|
|
public int hashLookupEntrySize() {
|
|
if (!(this.segmentHashLookupInit()))
|
|
this.initSegmentHashLookup();
|
|
|
|
return this.hashLookupEntrySize;
|
|
}
|
|
|
|
public int keyBits() {
|
|
if (!(this.segmentHashLookupInit()))
|
|
this.initSegmentHashLookup();
|
|
|
|
return this.keyBits;
|
|
}
|
|
|
|
public long address() {
|
|
if (!(this.segmentHashLookupInit()))
|
|
this.initSegmentHashLookup();
|
|
|
|
return this.address;
|
|
}
|
|
|
|
public long capacityMask() {
|
|
if (!(this.segmentHashLookupInit()))
|
|
this.initSegmentHashLookup();
|
|
|
|
return this.capacityMask;
|
|
}
|
|
|
|
public long capacityMask2() {
|
|
if (!(this.segmentHashLookupInit()))
|
|
this.initSegmentHashLookup();
|
|
|
|
return this.capacityMask2;
|
|
}
|
|
|
|
public long entryMask() {
|
|
if (!(this.segmentHashLookupInit()))
|
|
this.initSegmentHashLookup();
|
|
|
|
return this.entryMask;
|
|
}
|
|
|
|
public long keyMask() {
|
|
if (!(this.segmentHashLookupInit()))
|
|
this.initSegmentHashLookup();
|
|
|
|
return this.keyMask;
|
|
}
|
|
|
|
public long valueMask() {
|
|
if (!(this.segmentHashLookupInit()))
|
|
this.initSegmentHashLookup();
|
|
|
|
return this.valueMask;
|
|
}
|
|
|
|
public void closeSegmentHashLookup() {
|
|
if (!(this.segmentHashLookupInit()))
|
|
return ;
|
|
|
|
this.address = -1;
|
|
}
|
|
|
|
public long readEntry(long pos) {
|
|
return NativeBytes.UNSAFE.getLong(((address()) + pos));
|
|
}
|
|
|
|
void clearEntry(long pos, long prevEntry) {
|
|
long entry = prevEntry & (~(entryMask()));
|
|
NativeBytes.UNSAFE.putLong(((address()) + pos), entry);
|
|
}
|
|
|
|
public long key(long entry) {
|
|
return entry & (keyMask());
|
|
}
|
|
|
|
public long value(long entry) {
|
|
return (entry >>> (keyBits())) & (valueMask());
|
|
}
|
|
|
|
public long maskUnsetKey(long key) {
|
|
return (key &= keyMask()) != (UNSET_KEY) ? key : keyMask();
|
|
}
|
|
|
|
public void clearHashLookup() {
|
|
NativeBytes.UNSAFE.setMemory(address(), ((capacityMask2()) + (hashLookupEntrySize())), ((byte)(0)));
|
|
}
|
|
|
|
long entry(long key, long value) {
|
|
return key | (value << (keyBits()));
|
|
}
|
|
|
|
public void writeEntry(long pos, long prevEntry, long key, long value) {
|
|
long entry = (prevEntry & (~(entryMask()))) | (entry(key, value));
|
|
NativeBytes.UNSAFE.putLong(((address()) + pos), entry);
|
|
}
|
|
|
|
public void writeEntryVolatile(long pos, long prevEntry, long key, long value) {
|
|
long entry = (prevEntry & (~(entryMask()))) | (entry(key, value));
|
|
NativeBytes.UNSAFE.putLongVolatile(null, ((address()) + pos), entry);
|
|
}
|
|
|
|
public void checkValueForPut(long value) {
|
|
assert (value & (~(valueMask()))) == 0L : "Value out of range, was " + value;
|
|
}
|
|
|
|
public void putValueVolatile(long pos, long value) {
|
|
checkValueForPut(value);
|
|
long currentEntry = readEntry(pos);
|
|
writeEntryVolatile(pos, currentEntry, key(currentEntry), value);
|
|
}
|
|
|
|
void writeEntry(long pos, long prevEntry, long anotherEntry) {
|
|
long entry = (prevEntry & (~(entryMask()))) | (anotherEntry & (entryMask()));
|
|
NativeBytes.UNSAFE.putLong(((address()) + pos), entry);
|
|
}
|
|
|
|
public long stepBack(long pos) {
|
|
return (pos -= hashLookupEntrySize()) >= 0 ? pos : capacityMask2();
|
|
}
|
|
|
|
public long step(long pos) {
|
|
return (pos += hashLookupEntrySize()) <= (capacityMask2()) ? pos : 0L;
|
|
}
|
|
|
|
long indexToPos(long index) {
|
|
return index * (hashLookupEntrySize());
|
|
}
|
|
|
|
public long hlPos(long key) {
|
|
return indexToPos((key & (capacityMask())));
|
|
}
|
|
|
|
public boolean empty(long entry) {
|
|
return (entry & (entryMask())) == (UNSET_ENTRY);
|
|
}
|
|
|
|
public long remove(long posToRemove) {
|
|
long entryToRemove = readEntry(posToRemove);
|
|
long posToShift = posToRemove;
|
|
while (true) {
|
|
posToShift = step(posToShift);
|
|
long entryToShift = readEntry(posToShift);
|
|
if (empty(entryToShift))
|
|
break;
|
|
|
|
long insertPos = hlPos(key(entryToShift));
|
|
boolean cond1 = insertPos <= posToRemove;
|
|
boolean cond2 = posToRemove <= posToShift;
|
|
if ((cond1 && cond2) || ((posToShift < insertPos) && (cond1 || cond2))) {
|
|
writeEntry(posToRemove, entryToRemove, entryToShift);
|
|
posToRemove = posToShift;
|
|
entryToRemove = entryToShift;
|
|
}
|
|
}
|
|
clearEntry(posToRemove, entryToRemove);
|
|
return posToRemove;
|
|
}
|
|
|
|
void forEach(EntryConsumer action) {
|
|
for (long pos = 0L ; pos <= (capacityMask2()) ; pos += hashLookupEntrySize()) {
|
|
long entry = readEntry(pos);
|
|
if (!(empty(entry)))
|
|
action.accept(key(entry), value(entry));
|
|
|
|
}
|
|
}
|
|
|
|
String hashLookupToString() {
|
|
final StringBuilder sb = new StringBuilder("{");
|
|
forEach((long key,long value) -> sb.append(key).append('=').append(value).append(','));
|
|
sb.append('}');
|
|
return sb.toString();
|
|
}
|
|
|
|
long entrySpaceOffset = 0;
|
|
|
|
MultiStoreBytes freeListBytes = new MultiStoreBytes();
|
|
|
|
public SingleThreadedDirectBitSet freeList = new SingleThreadedDirectBitSet();
|
|
|
|
boolean segmentInit() {
|
|
return (entrySpaceOffset) > 0;
|
|
}
|
|
|
|
void initSegment() {
|
|
VanillaChronicleHash<?, ?, ?, ?, ?> h = CompiledReplicatedMapIterationContext.this.h();
|
|
long hashLookupOffset = h.segmentOffset(segmentIndex());
|
|
long freeListOffset = hashLookupOffset + (h.segmentHashLookupOuterSize);
|
|
freeListBytes.storePositionAndSize(h.ms, freeListOffset, h.segmentFreeListInnerSize);
|
|
freeList.reuse(freeListBytes);
|
|
entrySpaceOffset = (freeListOffset + (h.segmentFreeListOuterSize)) + (h.segmentEntrySpaceInnerOffset);
|
|
this.closeSegmentDependants();
|
|
}
|
|
|
|
public long entrySpaceOffset() {
|
|
if (!(this.segmentInit()))
|
|
this.initSegment();
|
|
|
|
return this.entrySpaceOffset;
|
|
}
|
|
|
|
public SingleThreadedDirectBitSet freeList() {
|
|
if (!(this.segmentInit()))
|
|
this.initSegment();
|
|
|
|
return this.freeList;
|
|
}
|
|
|
|
void closeSegment() {
|
|
if (!(this.segmentInit()))
|
|
return ;
|
|
|
|
this.closeSegmentDependants();
|
|
entrySpaceOffset = 0;
|
|
}
|
|
|
|
public void closeSegmentDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeEntryOffset();
|
|
}
|
|
|
|
public void clearSegment() {
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.lock();
|
|
CompiledReplicatedMapIterationContext.this.clearHashLookup();
|
|
freeList().clear();
|
|
nextPosToSearchFrom(0L);
|
|
entries(0L);
|
|
}
|
|
|
|
public void clear() {
|
|
clearSegment();
|
|
}
|
|
|
|
public void free(long fromPos, int chunks) {
|
|
freeList().clear(fromPos, (fromPos + chunks));
|
|
if (fromPos < (nextPosToSearchFrom()))
|
|
nextPosToSearchFrom(fromPos);
|
|
|
|
}
|
|
|
|
public long alloc(int chunks) {
|
|
VanillaChronicleHash<?, ?, ?, ?, ?> h = CompiledReplicatedMapIterationContext.this.h();
|
|
if (chunks > (h.maxChunksPerEntry))
|
|
throw new IllegalArgumentException((((("Entry is too large: requires " + chunks) + " entry size chucks, ") + (h.maxChunksPerEntry)) + " is maximum."));
|
|
|
|
long ret = freeList().setNextNContinuousClearBits(nextPosToSearchFrom(), chunks);
|
|
if ((ret == (DirectBitSet.NOT_FOUND)) || ((ret + chunks) > (h.actualChunksPerSegment))) {
|
|
if (((ret != (DirectBitSet.NOT_FOUND)) && ((ret + chunks) > (h.actualChunksPerSegment))) && (ret < (h.actualChunksPerSegment)))
|
|
freeList().clear(ret, h.actualChunksPerSegment);
|
|
|
|
ret = freeList().setNextNContinuousClearBits(0L, chunks);
|
|
if ((ret == (DirectBitSet.NOT_FOUND)) || ((ret + chunks) > (h.actualChunksPerSegment))) {
|
|
if (((ret != (DirectBitSet.NOT_FOUND)) && ((ret + chunks) > (h.actualChunksPerSegment))) && (ret < (h.actualChunksPerSegment)))
|
|
freeList().clear(ret, h.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 ((chunks == 1) || (freeList().isSet(nextPosToSearchFrom()))) {
|
|
updateNextPosToSearchFrom(ret, chunks);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public boolean entryRemovedOnThisIteration = false;
|
|
|
|
boolean entryRemovedOnThisIterationInit() {
|
|
return (this.entryRemovedOnThisIteration) != false;
|
|
}
|
|
|
|
protected void initEntryRemovedOnThisIteration(boolean entryRemovedOnThisIteration) {
|
|
this.entryRemovedOnThisIteration = entryRemovedOnThisIteration;
|
|
}
|
|
|
|
public void closeEntryRemovedOnThisIteration() {
|
|
if (!(this.entryRemovedOnThisIterationInit()))
|
|
return ;
|
|
|
|
this.entryRemovedOnThisIteration = false;
|
|
}
|
|
|
|
public int allocatedChunks = 0;
|
|
|
|
public boolean allocatedChunksInit() {
|
|
return (this.allocatedChunks) != 0;
|
|
}
|
|
|
|
public void initAllocatedChunks(int allocatedChunks) {
|
|
this.allocatedChunks = allocatedChunks;
|
|
}
|
|
|
|
public int allocatedChunks() {
|
|
assert this.allocatedChunksInit() : "AllocatedChunks should be init";
|
|
return this.allocatedChunks;
|
|
}
|
|
|
|
public void closeAllocatedChunks() {
|
|
if (!(this.allocatedChunksInit()))
|
|
return ;
|
|
|
|
this.allocatedChunks = 0;
|
|
}
|
|
|
|
public long keyOffset = -1;
|
|
|
|
public boolean keyOffsetInit() {
|
|
return (this.keyOffset) >= 0;
|
|
}
|
|
|
|
public void initKeyOffset(long keyOffset) {
|
|
this.keyOffset = keyOffset;
|
|
this.closeKeyOffsetDependants();
|
|
}
|
|
|
|
public long keyOffset() {
|
|
assert this.keyOffsetInit() : "KeyOffset should be init";
|
|
return this.keyOffset;
|
|
}
|
|
|
|
public void closeKeyOffset() {
|
|
if (!(this.keyOffsetInit()))
|
|
return ;
|
|
|
|
this.closeKeyOffsetDependants();
|
|
this.keyOffset = -1;
|
|
}
|
|
|
|
public void closeKeyOffsetDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesKeyEndDependants();
|
|
CompiledReplicatedMapIterationContext.this.entryKey.closeEntryKeyBytesDataInnerGetUsingDependants();
|
|
}
|
|
|
|
public long keyEnd() {
|
|
return (keyOffset()) + (keySize());
|
|
}
|
|
|
|
public void closeReplicatedMapEntryStagesKeyEndDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesCountValueSizeOffsetDependants();
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesEntryEndDependants();
|
|
CompiledReplicatedMapIterationContext.this.closeReplicationState();
|
|
}
|
|
|
|
private long _MapEntryStages_countValueSizeOffset() {
|
|
return keyEnd();
|
|
}
|
|
|
|
long countValueSizeOffset() {
|
|
return (_MapEntryStages_countValueSizeOffset()) + (ReplicatedChronicleMap.ADDITIONAL_ENTRY_BYTES);
|
|
}
|
|
|
|
public void closeReplicatedMapEntryStagesCountValueSizeOffsetDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeValueSizeOffset();
|
|
}
|
|
|
|
public long valueSizeOffset = -1;
|
|
|
|
public boolean valueSizeOffsetInit() {
|
|
return (this.valueSizeOffset) >= 0;
|
|
}
|
|
|
|
void initValueSizeOffset() {
|
|
valueSizeOffset = countValueSizeOffset();
|
|
this.closeValueSizeOffsetDependants();
|
|
}
|
|
|
|
public long valueSizeOffset() {
|
|
if (!(this.valueSizeOffsetInit()))
|
|
this.initValueSizeOffset();
|
|
|
|
return this.valueSizeOffset;
|
|
}
|
|
|
|
public void closeValueSizeOffset() {
|
|
if (!(this.valueSizeOffsetInit()))
|
|
return ;
|
|
|
|
this.closeValueSizeOffsetDependants();
|
|
this.valueSizeOffset = -1;
|
|
}
|
|
|
|
public void closeValueSizeOffsetDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeValSize();
|
|
}
|
|
|
|
public long valueSize = -1;
|
|
|
|
public long valueOffset;
|
|
|
|
public boolean valSizeInit() {
|
|
return (this.valueSize) >= 0;
|
|
}
|
|
|
|
void initValSize() {
|
|
entryBytes.position(valueSizeOffset());
|
|
valueSize = CompiledReplicatedMapIterationContext.this.m().readValueSize(entryBytes);
|
|
countValueOffset();
|
|
this.closeValSizeDependants();
|
|
}
|
|
|
|
void initValSize(long valueSize) {
|
|
this.valueSize = valueSize;
|
|
entryBytes.position(valueSizeOffset());
|
|
CompiledReplicatedMapIterationContext.this.m().valueSizeMarshaller.writeSize(entryBytes, valueSize);
|
|
countValueOffset();
|
|
this.closeValSizeDependants();
|
|
}
|
|
|
|
void initValSizeEqualToOld(long oldValueSizeOffset, long oldValueSize, long oldValueOffset) {
|
|
valueSize = oldValueSize;
|
|
valueOffset = (valueSizeOffset()) + (oldValueOffset - oldValueSizeOffset);
|
|
this.closeValSizeDependants();
|
|
}
|
|
|
|
public long valueOffset() {
|
|
if (!(this.valSizeInit()))
|
|
this.initValSize();
|
|
|
|
return this.valueOffset;
|
|
}
|
|
|
|
public long valueSize() {
|
|
if (!(this.valSizeInit()))
|
|
this.initValSize();
|
|
|
|
return this.valueSize;
|
|
}
|
|
|
|
public void closeValSize() {
|
|
if (!(this.valSizeInit()))
|
|
return ;
|
|
|
|
this.closeValSizeDependants();
|
|
this.valueSize = -1;
|
|
}
|
|
|
|
public void closeValSizeDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesEntryEndDependants();
|
|
CompiledReplicatedMapIterationContext.this.entryValue.closeEntryValueBytesDataSizeDependants();
|
|
CompiledReplicatedMapIterationContext.this.entryValue.closeEntryValueBytesDataInnerGetUsingDependants();
|
|
}
|
|
|
|
public void writeValue(Data<?, ?> value) {
|
|
value.writeTo(entryBytesAccess, entryBytesAccessHandle, entryBytesAccessOffset(valueOffset()));
|
|
}
|
|
|
|
public void initValue(Data<?, ?> value) {
|
|
entryBytes.position(valueSizeOffset());
|
|
initValSize(value.size());
|
|
writeValue(value);
|
|
}
|
|
|
|
public void initValueWithoutSize(Data<?, ?> value, long oldValueSizeOffset, long oldValueSize, long oldValueOffset) {
|
|
assert oldValueSize == (value.size());
|
|
initValSizeEqualToOld(oldValueSizeOffset, oldValueSize, oldValueOffset);
|
|
writeValue(value);
|
|
}
|
|
|
|
private long _HashEntryStages_entryEnd() {
|
|
return keyEnd();
|
|
}
|
|
|
|
protected long entryEnd() {
|
|
return (valueOffset()) + (valueSize());
|
|
}
|
|
|
|
public void closeReplicatedMapEntryStagesEntryEndDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesEntrySizeDependants();
|
|
}
|
|
|
|
long replicationBytesOffset = -1;
|
|
|
|
public boolean replicationStateInit() {
|
|
return (this.replicationBytesOffset) >= 0;
|
|
}
|
|
|
|
void initReplicationState() {
|
|
replicationBytesOffset = keyEnd();
|
|
this.closeReplicationStateDependants();
|
|
}
|
|
|
|
public long replicationBytesOffset() {
|
|
if (!(this.replicationStateInit()))
|
|
this.initReplicationState();
|
|
|
|
return this.replicationBytesOffset;
|
|
}
|
|
|
|
public void closeReplicationState() {
|
|
if (!(this.replicationStateInit()))
|
|
return ;
|
|
|
|
this.closeReplicationStateDependants();
|
|
this.replicationBytesOffset = -1;
|
|
}
|
|
|
|
public void closeReplicationStateDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesTimestampOffsetDependants();
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesUpdateReplicationStateDependants();
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesIdentifierOffsetDependants();
|
|
}
|
|
|
|
private long entryDeletedOffset() {
|
|
return (replicationBytesOffset()) + 9L;
|
|
}
|
|
|
|
public boolean entryDeleted() {
|
|
return entryBytesAccess.readBoolean(entryBytesAccessHandle, entryDeletedOffset());
|
|
}
|
|
|
|
private boolean _MapSegmentIteration_entryIsPresent() {
|
|
return true;
|
|
}
|
|
|
|
public boolean entryIsPresent() {
|
|
return !(CompiledReplicatedMapIterationContext.this.entryDeleted());
|
|
}
|
|
|
|
public void writeEntryDeleted() {
|
|
entryBytesAccess.writeBoolean(entryBytesAccessHandle, entryDeletedOffset(), true);
|
|
}
|
|
|
|
public void writeEntryPresent() {
|
|
entryBytesAccess.writeBoolean(entryBytesAccessHandle, entryDeletedOffset(), false);
|
|
}
|
|
|
|
private long timestampOffset() {
|
|
return replicationBytesOffset();
|
|
}
|
|
|
|
public void closeReplicatedMapEntryStagesTimestampOffsetDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesTimestampDependants();
|
|
}
|
|
|
|
public long timestamp() {
|
|
return entryBytesAccess.readLong(entryBytesAccessHandle, timestampOffset());
|
|
}
|
|
|
|
public void closeReplicatedMapEntryStagesTimestampDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeUpdatedReplicationState();
|
|
}
|
|
|
|
@Override
|
|
public long originTimestamp() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return timestamp();
|
|
}
|
|
|
|
void updateReplicationState(long timestamp, byte identifier) {
|
|
entryBytes.position(replicationBytesOffset());
|
|
entryBytes.writeLong(timestamp);
|
|
entryBytes.writeByte(identifier);
|
|
}
|
|
|
|
public void closeReplicatedMapEntryStagesUpdateReplicationStateDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeUpdatedReplicationState();
|
|
}
|
|
|
|
private long identifierOffset() {
|
|
return (replicationBytesOffset()) + 8L;
|
|
}
|
|
|
|
public void closeReplicatedMapEntryStagesIdentifierOffsetDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesIdentifierDependants();
|
|
}
|
|
|
|
byte identifier() {
|
|
return entryBytesAccess.readByte(entryBytesAccessHandle, identifierOffset());
|
|
}
|
|
|
|
public void closeReplicatedMapEntryStagesIdentifierDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeUpdatedReplicationState();
|
|
}
|
|
|
|
@Override
|
|
public byte originIdentifier() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return identifier();
|
|
}
|
|
|
|
public long pos = -1;
|
|
|
|
public boolean posInit() {
|
|
return (this.pos) >= 0;
|
|
}
|
|
|
|
public void initPos(long pos) {
|
|
this.pos = pos;
|
|
this.closePosDependants();
|
|
}
|
|
|
|
public long pos() {
|
|
assert this.posInit() : "Pos should be init";
|
|
return this.pos;
|
|
}
|
|
|
|
public void closePos() {
|
|
if (!(this.posInit()))
|
|
return ;
|
|
|
|
this.closePosDependants();
|
|
this.pos = -1;
|
|
}
|
|
|
|
public void closePosDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeEntryOffset();
|
|
}
|
|
|
|
public void dropChange() {
|
|
CompiledReplicatedMapIterationContext.this.m().dropChange(CompiledReplicatedMapIterationContext.this.segmentIndex(), CompiledReplicatedMapIterationContext.this.pos());
|
|
}
|
|
|
|
public void raiseChange() {
|
|
CompiledReplicatedMapIterationContext.this.m().raiseChange(CompiledReplicatedMapIterationContext.this.segmentIndex(), CompiledReplicatedMapIterationContext.this.pos());
|
|
}
|
|
|
|
public void updateChange() {
|
|
if (replicationUpdateInit()) {
|
|
dropChange();
|
|
} else {
|
|
raiseChange();
|
|
}
|
|
}
|
|
|
|
public long keySizeOffset = -1;
|
|
|
|
public boolean entryOffsetInit() {
|
|
return (this.keySizeOffset) >= 0;
|
|
}
|
|
|
|
public void initEntryOffset() {
|
|
keySizeOffset = (CompiledReplicatedMapIterationContext.this.entrySpaceOffset()) + ((pos()) * (CompiledReplicatedMapIterationContext.this.h().chunkSize));
|
|
entryBytes.limit(entryBytes.capacity());
|
|
this.closeEntryOffsetDependants();
|
|
}
|
|
|
|
public long keySizeOffset() {
|
|
if (!(this.entryOffsetInit()))
|
|
this.initEntryOffset();
|
|
|
|
return this.keySizeOffset;
|
|
}
|
|
|
|
public void closeEntryOffset() {
|
|
if (!(this.entryOffsetInit()))
|
|
return ;
|
|
|
|
this.closeEntryOffsetDependants();
|
|
this.keySizeOffset = -1;
|
|
}
|
|
|
|
public void closeEntryOffsetDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeReplicatedMapEntryStagesEntrySizeDependants();
|
|
}
|
|
|
|
public long newSizeOfEverythingBeforeValue(Data<V, ?> newValue) {
|
|
return ((valueSizeOffset()) + (CompiledReplicatedMapIterationContext.this.m().valueSizeMarshaller.sizeEncodingSize(newValue.size()))) - (keySizeOffset());
|
|
}
|
|
|
|
public void copyExistingEntry(long newPos, long bytesToCopy) {
|
|
long oldKeySizeOffset = keySizeOffset();
|
|
long oldKeyOffset = keyOffset();
|
|
initPos(newPos);
|
|
initKeyOffset(((keySizeOffset()) + (oldKeyOffset - oldKeySizeOffset)));
|
|
Access.copy(entryBytesAccess, entryBytesAccessHandle, entryBytesAccessOffset(oldKeySizeOffset), entryBytesAccess, entryBytesAccessHandle, entryBytesAccessOffset(keySizeOffset()), bytesToCopy);
|
|
}
|
|
|
|
public void initEntryAndKeyCopying(long entrySize, long bytesToCopy) {
|
|
initAllocatedChunks(CompiledReplicatedMapIterationContext.this.h().inChunks(entrySize));
|
|
CompiledReplicatedMapIterationContext.this.copyExistingEntry(CompiledReplicatedMapIterationContext.this.alloc(allocatedChunks()), bytesToCopy);
|
|
incrementSegmentEntriesIfNeeded();
|
|
}
|
|
|
|
long entrySize() {
|
|
return (entryEnd()) - (keySizeOffset());
|
|
}
|
|
|
|
public void closeReplicatedMapEntryStagesEntrySizeDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeTheEntrySizeInChunks();
|
|
}
|
|
|
|
public int entrySizeInChunks = 0;
|
|
|
|
public boolean theEntrySizeInChunksInit() {
|
|
return (this.entrySizeInChunks) != 0;
|
|
}
|
|
|
|
void initTheEntrySizeInChunks() {
|
|
entrySizeInChunks = CompiledReplicatedMapIterationContext.this.h().inChunks(entrySize());
|
|
}
|
|
|
|
public void initTheEntrySizeInChunks(int actuallyUsedChunks) {
|
|
entrySizeInChunks = actuallyUsedChunks;
|
|
}
|
|
|
|
public int entrySizeInChunks() {
|
|
if (!(this.theEntrySizeInChunksInit()))
|
|
this.initTheEntrySizeInChunks();
|
|
|
|
return this.entrySizeInChunks;
|
|
}
|
|
|
|
public void closeTheEntrySizeInChunks() {
|
|
if (!(this.theEntrySizeInChunksInit()))
|
|
return ;
|
|
|
|
this.entrySizeInChunks = 0;
|
|
}
|
|
|
|
public final void freeExtraAllocatedChunks() {
|
|
if (((!(CompiledReplicatedMapIterationContext.this.m().constantlySizedEntry)) && (CompiledReplicatedMapIterationContext.this.m().couldNotDetermineAlignmentBeforeAllocation)) && ((entrySizeInChunks()) < (CompiledReplicatedMapIterationContext.this.allocatedChunks()))) {
|
|
CompiledReplicatedMapIterationContext.this.free(((pos()) + (entrySizeInChunks())), ((CompiledReplicatedMapIterationContext.this.allocatedChunks()) - (entrySizeInChunks())));
|
|
} else {
|
|
initTheEntrySizeInChunks(CompiledReplicatedMapIterationContext.this.allocatedChunks());
|
|
}
|
|
}
|
|
|
|
public void writeValueAndPutPos(Data<V, ?> value) {
|
|
initValue(value);
|
|
freeExtraAllocatedChunks();
|
|
CompiledReplicatedMapIterationContext.this.putValueVolatile(CompiledReplicatedMapIterationContext.this.hashLookupPos(), pos());
|
|
}
|
|
|
|
public void innerRemoveEntryExceptHashLookupUpdate() {
|
|
CompiledReplicatedMapIterationContext.this.free(pos(), entrySizeInChunks());
|
|
CompiledReplicatedMapIterationContext.this.entries(((CompiledReplicatedMapIterationContext.this.entries()) - 1L));
|
|
CompiledReplicatedMapIterationContext.this.incrementModCountGuarded();
|
|
}
|
|
|
|
public void writeNewEntry(long pos, Data<?, ?> key) {
|
|
initPos(pos);
|
|
initKeySize(key.size());
|
|
entryBytes.position(keySizeOffset());
|
|
CompiledReplicatedMapIterationContext.this.h().keySizeMarshaller.writeSize(entryBytes, keySize());
|
|
initKeyOffset(entryBytes.position());
|
|
key.writeTo(entryBytesAccessor, entryBytes, keyOffset());
|
|
}
|
|
|
|
public void readExistingEntry(long pos) {
|
|
initPos(pos);
|
|
entryBytes.position(keySizeOffset());
|
|
initKeySize(CompiledReplicatedMapIterationContext.this.h().keySizeMarshaller.readSize(entryBytes));
|
|
initKeyOffset(entryBytes.position());
|
|
}
|
|
|
|
public boolean forEachRemoving(Predicate<? super MapEntry<K, V>> action) {
|
|
CompiledReplicatedMapIterationContext.this.innerUpdateLock.lock();
|
|
try {
|
|
long size = CompiledReplicatedMapIterationContext.this.size();
|
|
if (size == 0)
|
|
return true;
|
|
|
|
boolean interrupted = false;
|
|
long startPos = 0L;
|
|
while (!(CompiledReplicatedMapIterationContext.this.empty(CompiledReplicatedMapIterationContext.this.readEntry(startPos)))) {
|
|
startPos = CompiledReplicatedMapIterationContext.this.step(startPos);
|
|
}
|
|
CompiledReplicatedMapIterationContext.this.initHashLookupPos(startPos);
|
|
do {
|
|
CompiledReplicatedMapIterationContext.this.setHashLookupPosGuarded(CompiledReplicatedMapIterationContext.this.step(CompiledReplicatedMapIterationContext.this.hashLookupPos()));
|
|
long entry = CompiledReplicatedMapIterationContext.this.readEntry(CompiledReplicatedMapIterationContext.this.hashLookupPos());
|
|
if (!(CompiledReplicatedMapIterationContext.this.empty(entry))) {
|
|
CompiledReplicatedMapIterationContext.this.readExistingEntry(CompiledReplicatedMapIterationContext.this.value(entry));
|
|
if (entryIsPresent()) {
|
|
initEntryRemovedOnThisIteration(false);
|
|
if (!(action.test(((MapEntry<K, V>)(this))))) {
|
|
interrupted = true;
|
|
break;
|
|
} else {
|
|
if ((--size) == 0)
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
} while ((CompiledReplicatedMapIterationContext.this.hashLookupPos()) != startPos );
|
|
return !interrupted;
|
|
} finally {
|
|
CompiledReplicatedMapIterationContext.this.innerReadLock.unlock();
|
|
initEntryRemovedOnThisIteration(false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void forEachReplicableEntry(Consumer<? super ReplicableEntry> action) {
|
|
CompiledReplicatedMapIterationContext.this.innerUpdateLock.lock();
|
|
try {
|
|
long entries = CompiledReplicatedMapIterationContext.this.entries();
|
|
if (entries == 0)
|
|
return ;
|
|
|
|
long startPos = 0L;
|
|
while (!(CompiledReplicatedMapIterationContext.this.empty(CompiledReplicatedMapIterationContext.this.readEntry(startPos)))) {
|
|
startPos = CompiledReplicatedMapIterationContext.this.step(startPos);
|
|
}
|
|
CompiledReplicatedMapIterationContext.this.initHashLookupPos(startPos);
|
|
do {
|
|
CompiledReplicatedMapIterationContext.this.setHashLookupPosGuarded(CompiledReplicatedMapIterationContext.this.step(CompiledReplicatedMapIterationContext.this.hashLookupPos()));
|
|
long entry = CompiledReplicatedMapIterationContext.this.readEntry(CompiledReplicatedMapIterationContext.this.hashLookupPos());
|
|
if (!(CompiledReplicatedMapIterationContext.this.empty(entry))) {
|
|
CompiledReplicatedMapIterationContext.this.readExistingEntry(CompiledReplicatedMapIterationContext.this.value(entry));
|
|
action.accept(this);
|
|
if ((--entries) == 0)
|
|
break;
|
|
|
|
}
|
|
} while ((CompiledReplicatedMapIterationContext.this.hashLookupPos()) != startPos );
|
|
} finally {
|
|
CompiledReplicatedMapIterationContext.this.innerReadLock.unlock();
|
|
}
|
|
}
|
|
|
|
private void _MapEntryStages_relocation(Data<V, ?> newValue, long newSizeOfEverythingBeforeValue) {
|
|
CompiledReplicatedMapIterationContext.this.free(pos(), entrySizeInChunks());
|
|
long entrySize = innerEntrySize(newSizeOfEverythingBeforeValue, newValue.size());
|
|
CompiledReplicatedMapIterationContext.this.initEntryAndKeyCopying(entrySize, ((valueSizeOffset()) - (keySizeOffset())));
|
|
writeValueAndPutPos(newValue);
|
|
}
|
|
|
|
protected void relocation(Data<V, ?> newValue, long newSizeOfEverythingBeforeValue) {
|
|
CompiledReplicatedMapIterationContext.this.dropChange();
|
|
_MapEntryStages_relocation(newValue, newSizeOfEverythingBeforeValue);
|
|
}
|
|
|
|
public void innerDefaultReplaceValue(Data<V, ?> newValue) {
|
|
assert CompiledReplicatedMapIterationContext.this.innerUpdateLock.isHeldByCurrentThread();
|
|
boolean newValueSizeIsDifferent = (newValue.size()) != (this.valueSize());
|
|
if (newValueSizeIsDifferent) {
|
|
long newSizeOfEverythingBeforeValue = newSizeOfEverythingBeforeValue(newValue);
|
|
long entryStartOffset = keySizeOffset();
|
|
VanillaChronicleMap<?, ?, ?, ?, ?, ?, ?> m = CompiledReplicatedMapIterationContext.this.m();
|
|
long newValueOffset = m.alignment.alignAddr((entryStartOffset + newSizeOfEverythingBeforeValue));
|
|
long newEntrySize = (newValueOffset + (newValue.size())) - entryStartOffset;
|
|
int newSizeInChunks = m.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 (CompiledReplicatedMapIterationContext.this.freeList().allClear(((pos()) + (entrySizeInChunks())), ((pos()) + newSizeInChunks))) {
|
|
CompiledReplicatedMapIterationContext.this.freeList().set(((pos()) + (entrySizeInChunks())), ((pos()) + newSizeInChunks));
|
|
break newValueDoesNotFit;
|
|
}
|
|
relocation(newValue, newSizeOfEverythingBeforeValue);
|
|
return ;
|
|
} else if (newSizeInChunks < (entrySizeInChunks())) {
|
|
CompiledReplicatedMapIterationContext.this.freeList().clear(((pos()) + newSizeInChunks), ((pos()) + (entrySizeInChunks())));
|
|
}
|
|
} else {
|
|
}
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.lock();
|
|
if (newValueSizeIsDifferent) {
|
|
initValue(newValue);
|
|
} else {
|
|
writeValue(newValue);
|
|
}
|
|
CompiledReplicatedMapIterationContext.this.putValueVolatile(CompiledReplicatedMapIterationContext.this.hashLookupPos(), pos());
|
|
}
|
|
|
|
private void _MapSegmentIteration_doReplaceValue(Data<V, ?> newValue) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
try {
|
|
CompiledReplicatedMapIterationContext.this.innerDefaultReplaceValue(newValue);
|
|
} finally {
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.unlock();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void doReplaceValue(Data<V, ?> newValue) {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
try {
|
|
CompiledReplicatedMapIterationContext.this.innerDefaultReplaceValue(newValue);
|
|
CompiledReplicatedMapIterationContext.this.updateChange();
|
|
CompiledReplicatedMapIterationContext.this.initUpdatedReplicationStateOnPresentEntry();
|
|
} finally {
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.unlock();
|
|
}
|
|
}
|
|
|
|
private void _MapSegmentIteration_doRemove() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
initEntryRemovedOnThisIteration(true);
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.lock();
|
|
try {
|
|
if ((CompiledReplicatedMapIterationContext.this.remove(CompiledReplicatedMapIterationContext.this.hashLookupPos())) != (CompiledReplicatedMapIterationContext.this.hashLookupPos())) {
|
|
CompiledReplicatedMapIterationContext.this.setHashLookupPosGuarded(CompiledReplicatedMapIterationContext.this.stepBack(CompiledReplicatedMapIterationContext.this.hashLookupPos()));
|
|
}
|
|
CompiledReplicatedMapIterationContext.this.innerRemoveEntryExceptHashLookupUpdate();
|
|
} finally {
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.unlock();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void doRemove() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
initEntryRemovedOnThisIteration(true);
|
|
try {
|
|
if ((CompiledReplicatedMapIterationContext.this.valueSize()) > (CompiledReplicatedMapIterationContext.this.dummyValue.size()))
|
|
CompiledReplicatedMapIterationContext.this.innerDefaultReplaceValue(CompiledReplicatedMapIterationContext.this.dummyValue);
|
|
|
|
CompiledReplicatedMapIterationContext.this.initUpdatedReplicationStateOnPresentEntry();
|
|
CompiledReplicatedMapIterationContext.this.writeEntryDeleted();
|
|
CompiledReplicatedMapIterationContext.this.updateChange();
|
|
CompiledReplicatedMapIterationContext.this.deleted(((CompiledReplicatedMapIterationContext.this.deleted()) + 1));
|
|
} finally {
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.unlock();
|
|
}
|
|
}
|
|
|
|
private void _MapEntryStages_putValueDeletedEntry(Data<V, ?> newValue) {
|
|
assert CompiledReplicatedMapIterationContext.this.innerUpdateLock.isHeldByCurrentThread();
|
|
int newSizeInChunks;
|
|
long entryStartOffset = keySizeOffset();
|
|
long newSizeOfEverythingBeforeValue = -1;
|
|
boolean newValueSizeIsDifferent = (newValue.size()) != (valueSize());
|
|
if (newValueSizeIsDifferent) {
|
|
newSizeOfEverythingBeforeValue = newSizeOfEverythingBeforeValue(newValue);
|
|
long newValueOffset = CompiledReplicatedMapIterationContext.this.m().alignment.alignAddr((entryStartOffset + newSizeOfEverythingBeforeValue));
|
|
long newEntrySize = (newValueOffset + (newValue.size())) - entryStartOffset;
|
|
newSizeInChunks = CompiledReplicatedMapIterationContext.this.m().inChunks(newEntrySize);
|
|
} else {
|
|
newSizeInChunks = entrySizeInChunks();
|
|
}
|
|
if ((((pos()) + newSizeInChunks) < (CompiledReplicatedMapIterationContext.this.freeList().size())) && (CompiledReplicatedMapIterationContext.this.freeList().allClear(pos(), ((pos()) + newSizeInChunks)))) {
|
|
CompiledReplicatedMapIterationContext.this.freeList().set(pos(), ((pos()) + newSizeInChunks));
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.lock();
|
|
CompiledReplicatedMapIterationContext.this.incrementSegmentEntriesIfNeeded();
|
|
if (newValueSizeIsDifferent) {
|
|
initValue(newValue);
|
|
} else {
|
|
writeValue(newValue);
|
|
}
|
|
} else {
|
|
if (newValueSizeIsDifferent) {
|
|
assert newSizeOfEverythingBeforeValue >= 0;
|
|
} else {
|
|
newSizeOfEverythingBeforeValue = newSizeOfEverythingBeforeValue(newValue);
|
|
}
|
|
long entrySize = innerEntrySize(newSizeOfEverythingBeforeValue, newValue.size());
|
|
if (newValueSizeIsDifferent) {
|
|
CompiledReplicatedMapIterationContext.this.initEntryAndKeyCopying(entrySize, ((valueSizeOffset()) - entryStartOffset));
|
|
initValue(newValue);
|
|
} else {
|
|
long oldValueSizeOffset = valueSizeOffset();
|
|
long oldValueSize = valueSize();
|
|
long oldValueOffset = valueOffset();
|
|
CompiledReplicatedMapIterationContext.this.initEntryAndKeyCopying(entrySize, ((valueOffset()) - entryStartOffset));
|
|
initValueWithoutSize(newValue, oldValueSizeOffset, oldValueSize, oldValueOffset);
|
|
}
|
|
freeExtraAllocatedChunks();
|
|
}
|
|
CompiledReplicatedMapIterationContext.this.putValueVolatile(CompiledReplicatedMapIterationContext.this.hashLookupPos(), pos());
|
|
}
|
|
|
|
public void putValueDeletedEntry(Data<V, ?> newValue) {
|
|
throw new AssertionError("Replicated Map doesn\'t remove entries truly, yet");
|
|
}
|
|
|
|
boolean used;
|
|
|
|
public boolean usedInit() {
|
|
return used;
|
|
}
|
|
|
|
public void initUsed(boolean used) {
|
|
this.used = used;
|
|
}
|
|
|
|
void closeUsed() {
|
|
if (!(this.usedInit()))
|
|
return ;
|
|
|
|
used = false;
|
|
}
|
|
|
|
public long innerRemoteTimestamp;
|
|
|
|
public byte innerRemoteIdentifier = ((byte)(0));
|
|
|
|
public boolean replicationUpdateInit() {
|
|
return (this.innerRemoteIdentifier) != ((byte)(0));
|
|
}
|
|
|
|
public void initReplicationUpdate(long timestamp, byte identifier) {
|
|
innerRemoteTimestamp = timestamp;
|
|
if (identifier == 0)
|
|
throw new IllegalStateException("identifier can\'t be 0");
|
|
|
|
innerRemoteIdentifier = identifier;
|
|
this.closeReplicationUpdateDependants();
|
|
}
|
|
|
|
public byte innerRemoteIdentifier() {
|
|
assert this.replicationUpdateInit() : "ReplicationUpdate should be init";
|
|
return this.innerRemoteIdentifier;
|
|
}
|
|
|
|
public long innerRemoteTimestamp() {
|
|
assert this.replicationUpdateInit() : "ReplicationUpdate should be init";
|
|
return this.innerRemoteTimestamp;
|
|
}
|
|
|
|
public void closeReplicationUpdate() {
|
|
if (!(this.replicationUpdateInit()))
|
|
return ;
|
|
|
|
this.closeReplicationUpdateDependants();
|
|
this.innerRemoteIdentifier = ((byte)(0));
|
|
}
|
|
|
|
public void closeReplicationUpdateDependants() {
|
|
CompiledReplicatedMapIterationContext.this.closeUpdatedReplicationState();
|
|
}
|
|
|
|
private boolean updatedReplicationState = false;
|
|
|
|
public boolean updatedReplicationStateInit() {
|
|
return (this.updatedReplicationState) != false;
|
|
}
|
|
|
|
public void initUpdatedReplicationStateOnAbsentEntry() {
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.lock();
|
|
if (CompiledReplicatedMapIterationContext.this.replicationUpdateInit()) {
|
|
updateReplicationState(CompiledReplicatedMapIterationContext.this.innerRemoteTimestamp(), CompiledReplicatedMapIterationContext.this.innerRemoteIdentifier());
|
|
} else {
|
|
updateReplicationState(CompiledReplicatedMapIterationContext.this.m().timeProvider.currentTime(), CompiledReplicatedMapIterationContext.this.m().identifier());
|
|
}
|
|
updatedReplicationState = true;
|
|
}
|
|
|
|
public void initUpdatedReplicationStateOnPresentEntry() {
|
|
CompiledReplicatedMapIterationContext.this.innerWriteLock.lock();
|
|
if (CompiledReplicatedMapIterationContext.this.replicationUpdateInit()) {
|
|
updateReplicationState(CompiledReplicatedMapIterationContext.this.innerRemoteTimestamp(), CompiledReplicatedMapIterationContext.this.innerRemoteIdentifier());
|
|
} else {
|
|
long timestamp;
|
|
if ((identifier()) != (CompiledReplicatedMapIterationContext.this.m().identifier())) {
|
|
timestamp = Math.max(((timestamp()) + 1), CompiledReplicatedMapIterationContext.this.m().timeProvider.currentTime());
|
|
} else {
|
|
timestamp = CompiledReplicatedMapIterationContext.this.m().timeProvider.currentTime();
|
|
}
|
|
updateReplicationState(timestamp, CompiledReplicatedMapIterationContext.this.m().identifier());
|
|
}
|
|
updatedReplicationState = true;
|
|
}
|
|
|
|
public void closeUpdatedReplicationState() {
|
|
if (!(this.updatedReplicationStateInit()))
|
|
return ;
|
|
|
|
this.updatedReplicationState = false;
|
|
}
|
|
|
|
@Override
|
|
public long remoteTimestamp() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return innerRemoteTimestamp();
|
|
}
|
|
|
|
@Override
|
|
public byte remoteIdentifier() {
|
|
CompiledReplicatedMapIterationContext.this.checkOnEachPublicOperation();
|
|
return innerRemoteIdentifier();
|
|
}
|
|
|
|
private boolean testTimeStampInSensibleRange() {
|
|
if ((CompiledReplicatedMapIterationContext.this.m().timeProvider) == (TimeProvider.SYSTEM)) {
|
|
long currentTime = TimeProvider.SYSTEM.currentTime();
|
|
assert (Math.abs((currentTime - (timestamp())))) <= 100000000 : "unrealistic timestamp: " + (timestamp());
|
|
assert (Math.abs((currentTime - (CompiledReplicatedMapIterationContext.this.innerRemoteTimestamp())))) <= 100000000 : "unrealistic innerRemoteTimestamp: " + (CompiledReplicatedMapIterationContext.this.innerRemoteTimestamp());
|
|
}
|
|
return true;
|
|
}
|
|
}
|