@Override public int calculateRegionEntryValueSize(RegionEntry regionEntry) { return calcMemSize(regionEntry.getValue()); // OFFHEAP _getValue ok }
@Override public void run() { for (HashEntry<?, ?> he : clearedEntries) { for (HashEntry<?, ?> p = he; p != null; p = p.getNextEntry()) { if (p instanceof RegionEntry) { synchronized (p) { GatewaySenderEventImpl.release(((RegionEntry) p).getValue()); // OFFHEAP } } } } } };
private void basicGetRegionLiveChunks(InternalRegion r, List<OffHeapStoredObject> result) { for (Object key : r.keySet()) { RegionEntry re = r.getRegionEntry(key); if (re != null) { /** * value could be GATEWAY_SENDER_EVENT_IMPL_VALUE or region entry value. */ @Unretained(OffHeapIdentifier.GATEWAY_SENDER_EVENT_IMPL_VALUE) Object value = re.getValue(); if (value instanceof OffHeapStoredObject) { result.add((OffHeapStoredObject) value); } } } }
private RegionEntry createRegionEntry(Object key, Object value) { RegionEntry mockEntry = mock(RegionEntry.class); when(mockEntry.getValue(any())).thenReturn(value); when(mockEntry.getKey()).thenReturn(key); return mockEntry; } }
@Override public Object getTargetObject(RegionEntry entry) { if (indexOnValues) { Object o = entry.getValue((LocalRegion) region); if (o instanceof CachedDeserializable) { return ((CachedDeserializable) o).getDeserializedValue(region, entry); } return o; } else if (indexOnRegionKeys) { return entry.getKey(); } return ((LocalRegion) region).new NonTXEntry(entry); }
/** * Test Method: Fetch a value from the local cache * * @param key The kye * @return the value associated with that key * @see LocalRegion#get(Object, Object, boolean, EntryEventImpl) */ public Object localCacheGet(Object key) { RegionEntry re = getRegionMap().getEntry(key); if (re == null || re.isDestroyedOrRemoved()) { return null; } else { return re.getValue(this); // OFFHEAP: spin until we can copy into a heap cd? } }
private void givenExistingEntryWithValue(Object value) throws RegionClearedException { if (value == Token.TOMBSTONE) { givenExistingTombstone(); } else { when(existingRegionEntry.getValue()).thenReturn(value); } when(regionMap.getEntry(event)).thenReturn(value == null ? null : existingRegionEntry); when(regionMap.putEntryIfAbsent(eq(KEY), any())).thenReturn(existingRegionEntry); if (withConcurrencyChecks) { when(existingRegionEntry.getVersionStamp()).thenReturn(mock(VersionStamp.class)); } }
protected PageEntry getEntry(final Region region, final Object key) { final EntrySnapshot entry = (EntrySnapshot) region.getEntry(key); if (entry == null) { return null; } final Object value = entry.getRegionEntry().getValue(null); if (value == null || Token.isInvalidOrRemoved(value)) { return null; } return new PageEntry(key, value); }
private void givenExistingTombstone(boolean miss) { givenExistingEntry(); when(existingRegionEntry.isTombstone()).thenReturn(true); when(existingRegionEntry.isRemoved()).thenReturn(true); when(existingRegionEntry.isDestroyedOrRemoved()).thenReturn(true); when(existingRegionEntry.isInvalidOrRemoved()).thenReturn(true); when(existingRegionEntry.getValue()).thenReturn(Token.TOMBSTONE); }
@Override public RegionEntry putEntryIfAbsent(Object key, RegionEntry regionEntry) { RegionEntry oldRe = (RegionEntry) getEntryMap().putIfAbsent(key, regionEntry); if (oldRe == null && (regionEntry instanceof OffHeapRegionEntry) && _isOwnerALocalRegion() && _getOwner().isThisRegionBeingClosedOrDestroyed()) { // prevent orphan during concurrent destroy (#48068) Object v = regionEntry.getValue(); if (v != Token.REMOVED_PHASE1 && v != Token.REMOVED_PHASE2 && v instanceof StoredObject && ((StoredObject) v).hasRefCount()) { if (getEntryMap().remove(key, regionEntry)) { ((OffHeapRegionEntry) regionEntry).release(); } } } return oldRe; }
/** * To get the value from region in serialized form * * @return {@link VMCachedDeserializable} */ public Object getRawValue() { Object value = basicGetEntry().getValue((RegionEntryContext) getRegion()); if (value == null) { throw new EntryDestroyedException(this.getRegionEntry().getKey().toString()); } else if (Token.isInvalid(value)) { return null; } return value; }
@Test public void eventPutExistingEntryGivenNullOldValue_ifNotRetrieveOldValueForDelta() throws RegionClearedException { givenThatRunWhileEvictionDisabledCallsItsRunnable(); givenExistingRegionEntry(); Object oldValue = new Object(); when(existingRegionEntry.getValue(any())).thenReturn(oldValue); when(event.getDeltaBytes()).thenReturn(null); doPut(); verify(event, times(1)).putExistingEntry(same(internalRegion), same(existingRegionEntry), eq(false), eq(null)); }
@Test public void doesNotSetEventOldValueToExistingRegionEntryValue_ifNotRequired() { givenExistingRegionEntry(); givenAnOperationThatDoesNotGuaranteeOldValue(); givenPutDoesNotNeedToDoCacheWrite(); this.requireOldValue = false; Object oldValue = new Object(); when(existingRegionEntry.getValue()).thenReturn(oldValue); doPut(); verify(event, never()).setOldValue(any()); verify(event, never()).setOldValue(any(), anyBoolean()); }
@Test public void setsEventOldValueToExistingRegionEntryValue_ifOldValueIsGatewaySenderEvent() { givenExistingRegionEntry(); GatewaySenderEventImpl oldValue = new GatewaySenderEventImpl(); when(existingRegionEntry.getValue()).thenReturn(oldValue); doPut(); verify(event, times(1)).setOldValue(same(oldValue), eq(true)); verify(event, never()).setOldValue(not(same(oldValue)), eq(true)); }
@Test public void eventPutExistingEntryGivenOldValue_ifRetrieveOldValueForDelta() throws RegionClearedException { givenThatRunWhileEvictionDisabledCallsItsRunnable(); givenExistingRegionEntry(); Object oldValue = new Object(); when(existingRegionEntry.getValue(any())).thenReturn(oldValue); when(event.getDeltaBytes()).thenReturn(new byte[1]); doPut(); verify(event, times(1)).putExistingEntry(same(internalRegion), same(existingRegionEntry), eq(false), same(oldValue)); }
@Test public void shouldReturnMapWithKeyAndValue() { PartitionedRegion region = mock(PartitionedRegion.class); InternalRegionFunctionContext context = mock(InternalRegionFunctionContext.class); when(context.getDataSet()).thenReturn(region); ResultSender resultSender = mock(ResultSender.class); when(context.getResultSender()).thenReturn(resultSender); LuceneGetPageFunction function = new LuceneGetPageFunction(); when(context.getLocalDataSet(any())).thenReturn(region); final EntrySnapshot entry = mock(EntrySnapshot.class); when(region.getEntry(any())).thenReturn(entry); final RegionEntry regionEntry = mock(RegionEntry.class); when(entry.getRegionEntry()).thenReturn(regionEntry); when(regionEntry.getValue(any())).thenReturn("value"); when(context.getFilter()).thenReturn((Set) Collections.singleton("key")); function.execute(context); PageResults expectedResults = new PageResults(); expectedResults.add(new PageEntry("key", "value")); verify(resultSender).lastResult(eq(expectedResults)); }
@Override protected void setOldValueForDelta() { if (isRetrieveOldValueForDelta()) { getRegionMap().runWhileEvictionDisabled(() -> { setOldValueForDelta(getRegionEntry().getValue(getOwner())); }); } }
@Test public void testUpdateAgainstAConcurrentHashSet() throws Exception { IntStream.range(0, 150).forEach(i -> { try { store.addMapping(1, createRegionEntry(1, new Object())); } catch (Exception e) { throw new AssertionError(e); } }); RegionEntry entry = createRegionEntry(1, new Object()); store.addMapping(1, entry); store.updateMapping(2, 1, entry, entry.getValue(null)); assertEquals(151, numObjectsInStore(store)); }
/** * Create one of these in the local case so that we have a snapshot of the state and can allow the * bucket to move out from under us. */ public NonLocalRegionEntry(RegionEntry re, InternalRegion br, boolean allowTombstones) { this.key = re.getKey(); if (allowTombstones && re.isTombstone()) { // client get() operations need to see tombstone values this.value = Token.TOMBSTONE; } else { this.value = re.getValue(br); // OFFHEAP: copy into heap cd } Assert.assertTrue(this.value != Token.NOT_AVAILABLE, "getEntry did not fault value in from disk"); this.lastModified = re.getLastModified(); this.isRemoved = re.isRemoved(); VersionStamp stamp = re.getVersionStamp(); if (stamp != null) { this.versionTag = stamp.asVersionTag(); } }
@Override protected void setOldValueInEvent() { final EntryEventImpl event = getEvent(); final RegionEntry re = getRegionEntry(); event.setRegionEntry(re); if (event.getOperation().guaranteesOldValue()) { setOldValueEvenIfFaultedOut(); } else if (isCacheWrite() || isRequireOldValue()) { setOldValueIfNotFaultedOut(); } else { @Unretained Object existingValue = re.getValue(); if (existingValue instanceof GatewaySenderEventImpl) { event.setOldValue(existingValue, true); } } }