@SuppressWarnings({ "unchecked", "rawtypes" }) @Override public Collection<RegionEntry> regionEntriesInVM() { return (Collection)_getMap().values(); }
public final void writeSyncIfPresent(Object key, Runnable runner) { RegionEntry re = getEntry(key); if (re != null) { final boolean disabled = disableLruUpdateCallback(); try { synchronized (re) { if (!re.isRemoved()) { runner.run(); } } } finally { if (disabled) { enableLruUpdateCallback(); } try { lruUpdateCallback(); }catch(DiskAccessException dae) { this._getOwner().handleDiskAccessException(dae, true/* stop bridge servers*/); throw dae; } } } }
public void changeOwner(LocalRegion r) { if (r == _getOwnerObject()) { return; } setOwner(r); }
public final boolean isListOfDeltas(Object key) { RegionEntry re = getEntry(key); if(re != null) { LocalRegion owner = _getOwner(); return reHasDelta(owner, re); } return false; }
public final void removeIfDelta(Object key) { RegionEntry re = getEntry(key); if (re != null) { LocalRegion owner = _getOwner(); if (reHasDelta(owner, re)) { synchronized (re) { re.removePhase2(owner); removeEntry(key, re, true); } } } }
final LocalRegion owner = _getOwner(); owner.checkBeforeEntrySync(txEvent); lockForTXCacheModification(owner, versionTag); try { if (forceNewEntry) { boolean opCompleted = false; RegionEntry newRe = getEntryFactory().createEntry(owner, key, Token.REMOVED_PHASE1); synchronized (newRe) { try { RegionEntry oldRe = putEntryIfAbsent(key, newRe); while (!opCompleted && oldRe != null) { synchronized (oldRe) { if (oldRe.isRemovedPhase2()) { oldRe = putEntryIfAbsent(key, newRe); if (oldRe != null) { owner.getCachePerfStats().incRetries(); boolean invokeCallbacks = shouldCreateCBEvent(owner, true, owner.isInitialized()); boolean cbEventInPending = false; cbEvent = createCBEvent(owner, localOp ? Operation.LOCAL_INVALIDATE : Operation.INVALIDATE, key, newValue, txId, txEvent, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, txEntryState, versionTag, tailKey); txRemoveOldIndexEntry(Operation.INVALIDATE, oldRe); if (didDestroy) { oldRe.txDidDestroy(owner.cacheTimeMillis());
final LocalRegion owner = _getOwner(); if (owner == null) { lockForCacheModification(owner, event); try { if (forceNewEntry || forceCallbacks) { boolean opCompleted = false; RegionEntry newRe = getEntryFactory().createEntry(owner, event.getKey(), Token.REMOVED_PHASE1); synchronized (newRe) { try { RegionEntry oldRe = putEntryIfAbsent(event.getKey(), newRe); oldRe = putEntryIfAbsent(event.getKey(), newRe); if (oldRe != null) { owner.getCachePerfStats().incRetries(); processVersionTag(oldRe, event); try { try { if (oldRe.isRemoved()) { processVersionTag(oldRe, event); event.putNewEntry(owner, oldRe); EntryLogger.logInvalidate(event); processVersionTag(oldRe, event); event.putExistingEntry(owner, oldRe); EntryLogger.logInvalidate(event);
boolean done = false; boolean cleared = false; final LocalRegion owner = _getOwner(); RegionEntry newRe = getEntryFactory().createEntry(owner, key, Token.REMOVED_PHASE1); EntryEventImpl event = null; synchronized (newRe) { try { oldRe = putEntryIfAbsent(key, newRe); while (!done && oldRe != null) { synchronized (oldRe) { if (oldRe.isRemovedPhase2()) { oldRe = putEntryIfAbsent(key, newRe); if (oldRe != null) { owner.getCachePerfStats().incRetries(); processVersionTagForGII(oldRe, owner, entryVersion, isTombstone, sender, !wasRecovered || isSynchronizing); acceptedVersionTag = true; } catch (ConcurrentCacheModificationException e) { try { indexUpdater.onEvent(owner, event, oldRe); lruEntryUpdate(oldRe); owner.updateSizeOnPut(key, oldSize, owner.calculateRegionEntryValueSize(oldRe)); EntryLogger.logInitialImagePut(_getOwnerObject(), key, newValue); result = true; done = true;
final LocalRegion owner = _getOwner(); owner.checkBeforeEntrySync(txEvent); final boolean hasRemoteOrigin = !((TXId)txId).getMemberId().equals(owner.getMyId()); boolean cbEventInPending = false; lockForTXCacheModification(owner, versionTag); IndexManager oqlIndexManager = owner.getIndexManager() ; try { RegionEntry re = getEntry(key); if (re != null) { boolean invokeCallbacks = shouldCreateCBEvent(owner, false/*isInvalidate*/, isRegionReady || inRI); EntryEventImpl cbEvent = createCBEvent(owner, op, key, null, txId, txEvent, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, txEntryState, versionTag, tailKey); try { } else { if (owner.isUsedForPartitionedRegionBucket()) { txHandleWANEvent(owner, cbEvent, txEntryState); txRemoveOldIndexEntry(Operation.DESTROY, re); if (txEvent != null) { txEvent.addDestroy(owner, re, re.getKey(),aCallbackArgument); processAndGenerateTXVersionTag(owner, cbEvent, re, txEntryState); if (inTokenMode) { if (oldValue == Token.TOMBSTONE) { re.removePhase1(owner, false); // fix for bug 43063
CustomEntryConcurrentHashMap<Object, Object> other = ((AbstractRegionMap)rm)._getMap(); Iterator<Map.Entry<Object, Object>> it = other .entrySetWithReusableEntries().iterator(); @Retained @Released Object value = oldRe._getValueRetain((RegionEntryContext) ((AbstractRegionMap) rm)._getOwnerObject(), true); if (value == Token.TOMBSTONE && !_getOwner().getConcurrencyChecksEnabled()) { continue; RegionEntry newRe = getEntryFactory().createEntry((RegionEntryContext) _getOwnerObject(), key, value); copyRecoveredEntry(oldRe, newRe); _getOwner().updateSizeOnCreate(key, _getOwner().calculateRegionEntryValueSize(newRe)); incEntryCount(1); lruEntryUpdate(newRe); } finally { if (OffHeapHelper.release(value)) { lruUpdateCallback(); incEntryCount(size()); for (Iterator<RegionEntry> iter = regionEntries().iterator(); iter.hasNext(); ) { RegionEntry re = iter.next(); if (re.isTombstone()) { if (re.getVersionStamp() == null) { // bug #50992 - recovery from versioned to non-versioned incEntryCount(-1); iter.remove(); continue;
if(!_isOwnerALocalRegion()) { _mapClear(); return null; logger.debug("Clearing entries for {} rvv={}", _getOwner(), " rvv=" + rvv); LocalRegion lr = _getOwner(); RegionVersionVector localRvv = lr.getVersionVector(); incClearCount(lr); int delta = 0; try { delta = sizeInVM(); // TODO soplog need to determine if stats should _mapClear(); _getOwner().updateSizeOnClearRegion(delta - tombstones); _getOwner().incTombstoneCount(-tombstones); if (delta != 0) { incEntryCount(-delta); VersionSource myId = _getOwner().getVersionMember(); if (localRvv != rvv) { localRvv.recordGCVersions(rvv); for (RegionEntry re : regionEntries()) { synchronized(re) { Token value = re.getValueAsToken();
@Retained RegionEntry newRe = getEntryFactory().createEntry((RegionEntryContext) _getOwnerObject(), key, value); synchronized (newRe) { if (value.getVersionTag()!=null && newRe.getVersionStamp()!=null) { newRe.getVersionStamp().setVersions(value.getVersionTag()); RegionEntry oldRe = putEntryIfAbsent(key, newRe); while (oldRe != null) { synchronized (oldRe) { if (oldRe.isRemoved() && !oldRe.isTombstone()) { oldRe = putEntryIfAbsent(key, newRe); if (oldRe != null) { if (_isOwnerALocalRegion()) { _getOwner().getCachePerfStats().incRetries(); if (_isOwnerALocalRegion()) { _getOwner().updateSizeOnCreate(key, _getOwner().calculateRegionEntryValueSize(newRe)); if (newRe.isTombstone()) { _getOwner().scheduleTombstone(newRe, newRe.getVersionStamp().asVersionTag()); incEntryCount(1); // we are creating an entry that was recovered from disk including tombstone lruEntryUpdate(newRe); needsCallback = true; lruUpdateCallback(); EntryLogger.logRecovery(_getOwnerObject(), key, value);
final LocalRegion owner = _getOwner(); if (owner == null) { if (shouldCreateCBEvent(owner, false /* isInvalidate */, isRegionReady)) { cbEvent = createCBEvent(owner, putOp, key, newValue, txState, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, versionTag, tailKey, cbEvent); flag = checkIfEqualValue(owner, re, tmplEntry, newValue); txEvent = createCBEvent(owner, putOp, key, newValue, txState, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, versionTag, tailKey, cbEvent); processAndGenerateTXVersionTag(owner, !isRegionReady ? txEvent : cbEvent, re, txr); txRemoveOldIndexEntry(putOp, re); if (didDestroy) { re.txDidDestroy(lastMod); EntryLogger.logTXPut(_getOwnerObject(), key, nv); lruEntryCreate(re); incEntryCount(1); lruEntryUpdate(re); if (isLockedForTXCacheMod) { if (!opCompleted && (entryCreated || re.isMarkedForEviction())) {
public final RegionEntry updateRecoveredEntry(Object key, DiskEntry.RecoveredEntry value) { boolean needsCallback = false; RegionEntry re = getEntry(key); if (re == null) { return null; if (_isOwnerALocalRegion()) { if (re.isTombstone()) { _getOwner().unscheduleTombstone(re); final int oldSize = _getOwner().calculateRegionEntryValueSize(re); re.setValue(_getOwner(), value); // OFFHEAP no need to call AbstractRegionMap.prepareValueForCache because setValue is overridden for disk and that code takes apart value (RecoveredEntry) and prepares its nested value for the cache if (re.isTombstone()) { _getOwner().scheduleTombstone(re, re.getVersionStamp().asVersionTag()); _getOwner().updateSizeOnPut(key, oldSize, _getOwner().calculateRegionEntryValueSize(re)); } else { DiskEntry.Helper.updateRecoveredEntry((PlaceHolderDiskRegion)_getOwnerObject(), (DiskEntry)re, value, (RegionEntryContext) _getOwnerObject()); lruEntryUpdate(re); needsCallback = true; lruUpdateCallback(); EntryLogger.logRecovery(_getOwnerObject(), key, value);
final LocalRegion owner = _getOwner(); if (shouldCreateCBEvent(owner, false/* isInvalidate */, isRegionReady || inRI)) { cbEvent = createCBEvent(owner, localOp ? Operation.LOCAL_DESTROY : Operation.DESTROY, key, null, txState, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, txRemoveOldIndexEntry(Operation.DESTROY, re); boolean clearOccured = false; try { processAndGenerateTXVersionTag(owner, cbEvent, re, txr); if (inTokenMode) { re.setValue(owner, Token.DESTROYED); re.removePhase1(owner, false); // fix for bug 43063 re.removePhase2(owner); removeEntry(key, re, true); EntryLogger.logTXDestroy(_getOwnerObject(), key); lruEntryDestroy(re); if (shouldCreateCBEvent(owner, false /* isInvalidate */, isRegionReady || inRI)) { cbEvent = createCBEvent(owner, localOp ? Operation.LOCAL_DESTROY : Operation.DESTROY, key, null, txState, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext,
@Override public void updateEntryVersion(EntryEventImpl event) throws EntryNotFoundException { final LocalRegion owner = _getOwner(); if (owner == null) { lockForCacheModification(owner, event); RegionEntry re = getEntry(event.getKey()); entryExisted = true; processVersionTag(re, event); owner.generateAndSetVersionTag(event, re); EntryLogger.logUpdateEntryVersion(event); _getOwner().recordEvent(event); } catch (ConcurrentCacheModificationException ccme) { this._getOwner().handleDiskAccessException(dae); throw dae; } finally { releaseCacheModificationLock(owner, event); if (dr != null) { dr.removeClearCountReference();
InternalRegionArguments internalRegionArgs, boolean isLRU) { _setAttributes(attr); setOwner(owner); Method method = factoryProvider.getDeclaredMethod( "getHashEntryCreator"); _setMap(createConcurrentMap(attr.initialCapacity, attr.loadFactor, attr.concurrencyLevel, false, (HashEntryCreator<Object, Object>)method.invoke(null)), ownerPath); Boolean.valueOf(withVersioning), owner, internalRegionArgs }); setEntryFactory(ref); _setMap(createConcurrentMap(attr.initialCapacity, attr.loadFactor, attr.concurrencyLevel, false, new AbstractRegionEntry.HashRegionEntryCreator()), ownerPath); setEntryFactory(factory);
long tailKey, TXRegionState txr, EntryEventImpl cbEvent) { final LocalRegion owner = _getOwner(); boolean cbEventInPending = false; if (shouldCreateCBEvent(owner, true /* isInvalidate */, owner.isInitialized())) { cbEvent.setEntryLastModified(lastMod); cbEvent = createCBEvent(owner, localOp ? Operation.LOCAL_INVALIDATE : Operation.INVALIDATE, key, newValue, txState, eventId, aCallbackArgument, filterRoutingInfo, bridgeContext, cbEvent = null; txRemoveOldIndexEntry(Operation.INVALIDATE, re); if (didDestroy) { re.txDidDestroy(lastMod); processAndGenerateTXVersionTag(owner, cbEvent, re, txr); re.setValue(owner, re.prepareValueForCache(owner, newValue, true, true)); if (EntryLogger.isEnabled()) { EntryLogger.logTXInvalidate(_getOwnerObject(), key); lruEntryUpdate(re);
RegionEntry retVal = null; if (event.isFetchFromHDFS()) { retVal = getEntry(event); } else { retVal = getEntryInVM(key); value = valueCreator.newValue(key, ownerRegion, value, null); retVal = getEntryFactory().createEntry((RegionEntryContext) ownerRegion, key, value); RegionEntry oldRe = putEntryIfAbsent(key, retVal); if (oldRe != null) { if (retVal instanceof OffHeapRegionEntry) {
public final RegionEntry putEntryIfAbsent(Object key, RegionEntry re) { RegionEntry value = (RegionEntry)_getMap().putIfAbsent(key, re); if (value == null && (re instanceof OffHeapRegionEntry) && _isOwnerALocalRegion() && _getOwner().isThisRegionBeingClosedOrDestroyed()) { // prevent orphan during concurrent destroy (#48068) if (_getMap().remove(key, re)) { ((OffHeapRegionEntry)re).release(); } _getOwner().checkReadiness(); // throw RegionDestroyedException } return value; }