public void freeOffHeapResources() { // I do not use eventIterator here because it forces the lazy creation of EntryEventImpl by // calling getEventForPosition. for (int i = 0; i < this.removeAllDataSize; i++) { RemoveAllEntryData entry = this.removeAllData[i]; if (entry != null && entry.event != null) { entry.event.release(); } } }
@Override public void release() { this.event.release(); } }
public void freeOffHeapResources() { // I do not use eventIterator here because it forces the lazy creation of EntryEventImpl by // calling getEventForPosition. for (int i = 0; i < this.putAllDataSize; i++) { PutAllEntryData entry = this.putAllData[i]; if (entry != null && entry.event != null) { entry.event.release(); } } }
public void freeOffHeapResources() { if (this.events != null) { for (EntryEventImpl e : (List<EntryEventImpl>) this.events) { e.release(); } } } }
void releaseEvent(final EntryEventImpl event) { event.release(); }
public void freePendingCallbacks() { for (EntryEventImpl ee : getPendingCallbacks()) { ee.release(); } }
@Override public synchronized void release() { if (this.events != null) { Iterator it = getEvents().iterator(); while (it.hasNext()) { Object o = it.next(); if (o instanceof EntryEventImpl) { ((EntryEventImpl) o).release(); } } } } }
@Override public Object destroy(Object key, Object aCallbackArgument) throws TimeoutException, EntryNotFoundException, CacheWriterException { @Released EntryEventImpl event = newDestroyEntryEvent(key, aCallbackArgument); try { return validatedDestroy(key, event); } finally { event.release(); } }
@Override public void create(Object key, Object value, Object aCallbackArgument) throws TimeoutException, EntryExistsException, CacheWriterException { long startPut = CachePerfStats.getStatTime(); @Released EntryEventImpl event = newCreateEntryEvent(key, value, aCallbackArgument); try { validatedCreate(event, startPut); } finally { event.release(); } }
@Override public Object put(Object key, Object value, Object aCallbackArgument) throws TimeoutException, CacheWriterException { long startPut = CachePerfStats.getStatTime(); @Released EntryEventImpl event = newUpdateEntryEvent(key, value, aCallbackArgument); try { return validatedPut(event, startPut); } finally { event.release(); } }
@Test public void putThatDoesAddEventToPendingCallbacksDoesNotCallEventRelease() { when(internalRegion.isInitialized()).thenReturn(true); when(internalRegion.getConcurrencyChecksEnabled()).thenReturn(true); RegionEntry existingEntry = mock(RegionEntry.class); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isNotNull(); verify(event, never()).release(); }
@Override public void destroyRecoveredEntry(Object key) { @Released EntryEventImpl event = EntryEventImpl.create(this, Operation.LOCAL_DESTROY, key, null, null, false, getMyId(), false); try { event.inhibitCacheListenerNotification(true); mapDestroy(event, true, false, null, false, true); } finally { event.release(); } }
@Test public void putThatDoesNotAddEventToPendingCallbacksCallsEventRelease() { createInstance(Operation.UPDATE, false, txRmtEvent, null); instance.put(); assertThat(instance.isCallbackEventInPending()).isFalse(); assertThat(pendingCallbacks).doesNotContain(event); verify(event, never()).changeRegionToBucketsOwner(); verify(event, never()).setOriginRemote(anyBoolean()); verify(event, times(1)).release(); }
@Override public void removeAll(Collection keys, Object aCallbackArgument) { long startOp = CachePerfStats.getStatTime(); DistributedRemoveAllOperation operation = newRemoveAllOperation(keys, aCallbackArgument); if (operation != null) { try { basicRemoveAll(keys, operation, null); } finally { operation.getBaseEvent().release(); operation.freeOffHeapResources(); } } getCachePerfStats().endRemoveAll(startOp); }
@Override public void putAll(Map map, Object aCallbackArgument) { long startPut = CachePerfStats.getStatTime(); final DistributedPutAllOperation putAllOp = newPutAllOperation(map, aCallbackArgument); if (putAllOp != null) { try { basicPutAll(map, putAllOp, null); } finally { putAllOp.getBaseEvent().release(); putAllOp.freeOffHeapResources(); } } getCachePerfStats().endPutAll(startPut); }
/** * Destroys entry without performing validations. Call this after validating key, callback arg, * and runtime state. */ void validatedInvalidate(Object key, Object aCallbackArgument) throws TimeoutException, EntryNotFoundException { @Released EntryEventImpl event = EntryEventImpl.create(this, Operation.INVALIDATE, key, null, aCallbackArgument, false, getMyId()); try { if (generateEventID()) { event.setNewEventId(this.cache.getDistributedSystem()); } basicInvalidate(event); } finally { event.release(); } }
@Override @Retained protected InternalCacheEvent createEvent(DistributedRegion rgn) throws EntryNotFoundException { EntryEventImpl ev = createEntryEvent(rgn); boolean evReturned = false; try { ev.setEventId(this.eventId); ev.setOldValueFromRegion(); if (this.filterRouting != null) { ev.setLocalFilterInfo(this.filterRouting.getFilterInfo(rgn.getCache().getMyId())); } ev.setTailKey(tailKey); evReturned = true; return ev; } finally { if (!evReturned) ev.release(); } }
@Override public void localInvalidate(Object key, Object aCallbackArgument) throws EntryNotFoundException { validateKey(key); checkReadiness(); checkForNoAccess(); @Released EntryEventImpl event = EntryEventImpl.create(this, Operation.LOCAL_INVALIDATE, key, null/* newValue */, aCallbackArgument, false, getMyId()); try { if (generateEventID()) { event.setNewEventId(this.cache.getDistributedSystem()); } event.setLocalInvalid(true); basicInvalidate(event); } finally { event.release(); } }
public void basicBridgeUpdateVersionStamp(Object key, Object callbackArg, ClientProxyMembershipID memberId, boolean fromClient, EntryEventImpl clientEvent) { // Create an event and update version stamp of the entry @Released EntryEventImpl event = EntryEventImpl.create(this, Operation.UPDATE_VERSION_STAMP, key, null, null, false, memberId.getDistributedMember(), false, clientEvent.getEventId()); event.setContext(memberId); // if this is a replayed operation we may already have a version tag event.setVersionTag(clientEvent.getVersionTag()); try { basicUpdateEntryVersion(event); } finally { clientEvent.setVersionTag(event.getVersionTag()); clientEvent.isConcurrencyConflict(event.isConcurrencyConflict()); event.release(); } }
@Override protected boolean localDestroy() throws CacheException { RegionEntry re = getCheckedRegionEntry(); Object key = re.getKey(); LocalRegion lr = getLocalRegion(); @Released EntryEventImpl event = EntryEventImpl.create(lr, Operation.EXPIRE_LOCAL_DESTROY, key, null, createExpireEntryCallback(lr, key), false, lr.getMyId()); try { if (lr.generateEventID()) { event.setNewEventId(lr.getCache().getDistributedSystem()); } lr.expireDestroy(event, false); // expectedOldValue } finally { event.release(); } return true; }