LocalRegion region = _getOwner(); if (action.isLocalDestroy()) { int size = entry.getEntrySize(); if (region.evictDestroy(entry)) { return size; int change = 0; synchronized (entry) { if (entry.isInUseByTransaction()) { entry.unsetEvicted(); if (logger.isTraceEnabled(LogMarker.LRU)) { logger.trace(LogMarker.LRU, "No eviction of transactional entry for key={}", entry.getKey()); if (entry.isInvalidOrRemoved()) { logger.trace(LogMarker.LRU, "no need to evict invalid/localInvalid/destroyed token for key={}", entry.getKey()); entry.setEvicted(); change = DiskEntry.Helper.overflowToDisk((DiskEntry)entry, region, _getCCHelper()); if (logger.isTraceEnabled(LogMarker.LRU)) { logger.trace(LogMarker.LRU, "no need to evict token for key={} because moving its value to disk resulted in a net change of {} bytes.", entry.getKey(), change);
@Override final boolean confirmEvictionDestroy(RegionEntry re) { // We assume here that a LRURegionMap contains LRUEntries LRUEntry lruRe = (LRUEntry) re; if (lruRe.isInUseByTransaction() || lruRe.isDestroyed()) { lruRe.unsetEvicted(); return false; } else { return true; } } }
@Override protected final void lruEntryDestroy(RegionEntry re) { final LRUEntry e = (LRUEntry)re; if (logger.isTraceEnabled(LogMarker.LRU)) { logger.trace(LogMarker.LRU, "lruEntryDestroy for key={}; list size is: {}; actual size is: {}; map size is: {}; entry size: {}; in lru clock: {}", re.getKey(), getTotalEntrySize(), this._getLruList().getExpensiveListCount(), size(), e.getEntrySize(), !e.testEvicted()); } // if (this.lruCreatedKey == re.getKey()) { // String method = Thread.currentThread().getStackTrace()[5].getMethodName(); // } // boolean wasEvicted = e.testEvicted(); /*boolean removed = */_getLruList().unlinkEntry(e); // if (removed || wasEvicted) { // evicted entries have already been removed from the list changeTotalEntrySize(-1 * e.getEntrySize());// subtract the size. Token vTok = re.getValueAsToken(); if (vTok == Token.DESTROYED || vTok == Token.TOMBSTONE) { // OFFHEAP noop TODO: use re.isDestroyedOrTombstone // if in token mode we need to recalculate the size of the entry since it's // staying in the map and may be resurrected e.updateEntrySize(_getCCHelper()); } // } else if (debug) { // debugLogging("entry not removed from LRU list"); // } } /** Called by DiskEntry.Helper.faultInValue
@Override final boolean confirmEvictionDestroy(RegionEntry re) { // We assume here that a LRURegionMap contains LRUEntries LRUEntry lruRe = (LRUEntry) re; // TODO: TX: currently skip LRU processing for a transactionally locked // entry since value is already in TXState so no use of evicting it until we // have on-disk TXStates if (ExclusiveSharedSynchronizer.isWrite(lruRe.getState()) || lruRe.isDestroyed()) { lruRe.unsetEvicted(); return false; } else { return true; } }
/** Called by DiskEntry.Helper.faultInValue */ @Override public final void lruEntryFaultIn(LRUEntry e) { if (logger.isDebugEnabled()) { logger.debug("lruEntryFaultIn for key={} size={}", e.getKey(), e.getEntrySize()); } NewLRUClockHand lruList = _getLruList(); if (_isOwnerALocalRegion()) { DiskRegion disk = _getOwner().getDiskRegion(); boolean possibleClear = disk != null && disk.didClearCountChange(); if (!possibleClear || this._getOwner().basicGetEntry(e.getKey()) == e) { lruEntryUpdate(e); e.unsetEvicted(); lruList.appendEntry(e); } } else { lruEntryUpdate(e); lruList.appendEntry(e); } }
@Override protected final void lruEntryCreate(RegionEntry re) { LRUEntry e = (LRUEntry)re; // Assert.assertFalse(e._getValue() instanceof DiskEntry.RecoveredEntry) if (logger.isTraceEnabled(LogMarker.LRU)) { logger.trace(LogMarker.LRU, "lruEntryCreate for key={}; list size is: {}; actual size is: {}; map size is: {}; entry size: {}; in lru clock: {}", re.getKey(), getTotalEntrySize(), this._getLruList().getExpensiveListCount(), size(), e.getEntrySize(), !e.testEvicted()); } // this.lruCreatedKey = re.getKey(); // [ bruce ] for DEBUGGING only e.unsetEvicted(); NewLRUClockHand lruList = _getLruList(); DiskRegion disk = _getOwner().getDiskRegion(); boolean possibleClear = disk != null && disk.didClearCountChange(); if(!possibleClear || this._getOwner().basicGetEntry(re.getKey()) == re ) { lruList.appendEntry(e); lruEntryUpdate(e); } }
@Override protected final void lruEntryUpdate(RegionEntry re ) { final LRUEntry e = (LRUEntry)re; setDelta(e.updateEntrySize(_getCCHelper())); if (logger.isDebugEnabled()) { logger.debug("lruEntryUpdate for key={} size={}", re.getKey(), e.getEntrySize()); if (!possibleClear || this._getOwner().basicGetEntry(re.getKey()) == re) { if (e instanceof DiskEntry) { if (!e.testEvicted()) { lruList.appendEntry(e); e.resetRefCount(lruList); if (!e.testEvicted()) { lruList.appendEntry(e);
/** Called by DiskEntry.Helper.faultInValue */ @Override public final void lruEntryFaultIn(LRUEntry e) { if (debug) debugLogging("lruEntryFaultIn for key=" + e.getKeyCopy() + " size=" + e.getEntrySize()); NewLRUClockHand lruList = _getLruList(); if (_isOwnerALocalRegion()) { LocalRegion owner = _getOwner(); DiskRegion disk = owner.getDiskRegion(); boolean possibleClear = disk != null && disk.didClearCountChange(); if (!possibleClear || owner.basicGetEntry(e.getKey()) == e) { lruEntryUpdate(e); e.unsetEvicted(); lruList.appendEntry(e); } } else { lruEntryUpdate(e); lruList.appendEntry(e); } lruList.stats().incFaultins(); }
le = (LRUEntry)re; if (re instanceof DiskEntry) { if (le.testEvicted()) {
Object curVal = le._getValue(); // OFFHEAP: _getValue ok if (curVal != cd) { if (cd instanceof StoredObject) { int delta = le.updateEntrySize(_getCCHelper(), new CDValueWrapper(v));
boolean wasEvicted = le.testEvicted(); le.unsetEvicted(); if (!Token.isRemovedFromDisk(newValue)) { if (oldValue == null
if (entry.isInvalidOrRemoved()) { + "token for key=" + entry.getKeyCopy()); entry.setEvicted(); change = DiskEntry.Helper.overflowToDisk((DiskEntry)entry, region, _getCCHelper()); + entry.getKeyCopy() + " because moving its value to disk resulted in a net change of " + change + " bytes.");
@Override boolean evictDestroy(LRUEntry entry) { boolean evictDestroyWasDone = super.evictDestroy(entry); if (evictDestroyWasDone) { if (this.scope.isGlobal()) { try { getLockService().freeResources(entry.getKey()); } catch (LockServiceDestroyedException ignore) { } } } return evictDestroyWasDone; }
bytesToEvict -= sizeOfValue; if (debug) { debugLogging("evicted entry key=" + removalEntry.getKeyCopy() + " total entry size is now: " + getTotalEntrySize() + " bytesToEvict :" + bytesToEvict); if (evictEntry(removalEntry, stats) != 0) { if (debug) { debugLogging("evicted entry key(2)=" + removalEntry.getKey() + " total entry size is now: " + getTotalEntrySize() + " bytesToEvict :" + bytesToEvict);
private RegionEntry createRegionEntry(Object key, Object value, VersionTag tag, boolean forceOnHeap) { RegionEntryFactory ref = backingRM.getEntryFactory(); if (forceOnHeap) { ref = ref.makeOnHeap(); } value = getValueDuringGII(key, value); RegionEntry re = ref.createEntry(this.owner, key, value); setVersionTag(re, tag); if (re instanceof LRUEntry) { assert backingRM instanceof AbstractLRURegionMap; EnableLRU ccHelper = ((AbstractLRURegionMap)backingRM)._getCCHelper(); ((LRUEntry)re).updateEntrySize(ccHelper); } return re; }
/** * Broken-out so that it can be overridden */ protected int handleLocalDestroy(LRUEntry entry) { assert _getCCHelper().getEvictionAction().isLocalDestroy(); int size = entry.getEntrySize(); if (_getOwner().evictDestroy(entry)) { return size; } else { return 0; } }
@Override public final void decTxRefCount(RegionEntry re) { LocalRegion lr = null; if (_isOwnerALocalRegion()) { lr = _getOwner(); } ((LRUEntry) re).decRefCount(_getLruList(), lr); }
@Override protected final void lruEntryCreate(RegionEntry re) { LRUEntry e = (LRUEntry)re; // Assert.assertFalse(e._getValue() instanceof DiskEntry.RecoveredEntry) if ( debug ) { debugLogging( "lruEntryCreate for key=" + re.getKeyCopy() + "; list size is: " + getTotalEntrySize() + "; actual size is: " + this._getLruList().getExpensiveListCount() + "; map size is: " + sizeInVM() + "; entry size: " + e.getEntrySize() + "; in lru clock: " + !e.testEvicted()); } // this.lruCreatedKey = re.getKey(); // [ bruce ] for DEBUGGING only e.unsetEvicted(); NewLRUClockHand lruList = _getLruList(); DiskRegion disk = _getOwner().getDiskRegion(); boolean possibleClear = disk != null && disk.didClearCountChange(); if(!possibleClear || this._getOwner().basicGetEntry(re.getKey()) == re ) { lruList.appendEntry(e); lruEntryUpdate(e); } }
if (re instanceof DiskEntry && re instanceof LRUEntry) { LRUEntry le = (LRUEntry)re; if (le.testEvicted()) {