You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by ds...@apache.org on 2016/03/05 01:51:24 UTC
[24/38] incubator-geode git commit: renamed ObjectChunk to
ObjectStoredInMemory
renamed ObjectChunk to ObjectStoredInMemory
Project: http://git-wip-us.apache.org/repos/asf/incubator-geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-geode/commit/b75d0400
Tree: http://git-wip-us.apache.org/repos/asf/incubator-geode/tree/b75d0400
Diff: http://git-wip-us.apache.org/repos/asf/incubator-geode/diff/b75d0400
Branch: refs/heads/feature/GEODE-982
Commit: b75d040062071518bbe89a0ccef800c3e1ff57f7
Parents: 63d9e08
Author: Darrel Schneider <ds...@pivotal.io>
Authored: Tue Mar 1 17:02:16 2016 -0800
Committer: Darrel Schneider <ds...@pivotal.io>
Committed: Tue Mar 1 17:02:16 2016 -0800
----------------------------------------------------------------------
.../internal/GetOperationContextImpl.java | 6 +-
.../query/internal/index/AbstractIndex.java | 8 +-
.../query/internal/index/DummyQRegion.java | 14 +-
.../cache/query/internal/index/HashIndex.java | 6 +-
.../internal/cache/AbstractRegionEntry.java | 24 +-
.../internal/cache/AbstractRegionMap.java | 4 +-
.../cache/BytesAndBitsForCompactor.java | 8 +-
.../gemfire/internal/cache/DiskEntry.java | 20 +-
.../internal/cache/DistributedRegion.java | 6 +-
.../gemfire/internal/cache/EntryEventImpl.java | 52 +-
.../gemfire/internal/cache/LocalRegion.java | 6 +-
.../internal/cache/PartitionedRegion.java | 2 +-
.../internal/cache/tier/sockets/Part.java | 20 +-
.../cache/wan/GatewaySenderEventImpl.java | 8 +-
.../gemfire/internal/offheap/Fragment.java | 2 +-
.../internal/offheap/FreeListManager.java | 108 +--
.../internal/offheap/MemoryBlockNode.java | 14 +-
.../gemfire/internal/offheap/ObjectChunk.java | 826 ------------------
.../internal/offheap/ObjectChunkSlice.java | 4 +-
.../offheap/ObjectChunkWithHeapForm.java | 8 +-
.../internal/offheap/ObjectStoredInMemory.java | 828 +++++++++++++++++++
.../offheap/OffHeapRegionEntryHelper.java | 10 +-
.../offheap/SimpleMemoryAllocatorImpl.java | 38 +-
.../internal/offheap/SyncChunkStack.java | 12 +-
.../internal/tcp/ByteBufferInputStream.java | 10 +-
.../tcp/ImmutableByteBufferInputStream.java | 4 +-
.../gemfire/internal/util/BlobHelper.java | 4 +-
.../gemfire/pdx/internal/PdxInputStream.java | 4 +-
.../cache/ChunkValueWrapperJUnitTest.java | 4 +-
.../cache/OldValueImporterTestBase.java | 6 +-
.../internal/offheap/FragmentJUnitTest.java | 2 +-
.../internal/offheap/FreeListManagerTest.java | 162 ++--
.../offheap/FreeListOffHeapRegionJUnitTest.java | 2 +-
.../offheap/MemoryBlockNodeJUnitTest.java | 4 +-
.../internal/offheap/ObjectChunkJUnitTest.java | 176 ++--
.../offheap/ObjectChunkSliceJUnitTest.java | 6 +-
.../ObjectChunkWithHeapFormJUnitTest.java | 8 +-
.../offheap/OffHeapHelperJUnitTest.java | 4 +-
.../internal/offheap/OffHeapRegionBase.java | 8 +-
.../OffHeapRegionEntryHelperJUnitTest.java | 48 +-
.../offheap/OffHeapValidationJUnitTest.java | 4 +-
.../OffHeapWriteObjectAsByteArrayJUnitTest.java | 4 +-
.../OldFreeListOffHeapRegionJUnitTest.java | 2 +-
...moryAllocatorFillPatternIntegrationTest.java | 8 +-
...mpleMemoryAllocatorFillPatternJUnitTest.java | 16 +-
.../offheap/SimpleMemoryAllocatorJUnitTest.java | 10 +-
.../offheap/SyncChunkStackJUnitTest.java | 20 +-
.../offheap/TinyMemoryBlockJUnitTest.java | 16 +-
.../management/OffHeapManagementDUnitTest.java | 8 +-
.../OffHeapByteBufferByteSourceJUnitTest.java | 6 +-
.../gemfire/pdx/OffHeapByteSourceJUnitTest.java | 6 +-
51 files changed, 1294 insertions(+), 1292 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/cache/operations/internal/GetOperationContextImpl.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/cache/operations/internal/GetOperationContextImpl.java b/geode-core/src/main/java/com/gemstone/gemfire/cache/operations/internal/GetOperationContextImpl.java
index 11d9248..92a6158 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/cache/operations/internal/GetOperationContextImpl.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/cache/operations/internal/GetOperationContextImpl.java
@@ -18,7 +18,7 @@ package com.gemstone.gemfire.cache.operations.internal;
import com.gemstone.gemfire.SerializationException;
import com.gemstone.gemfire.cache.operations.GetOperationContext;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.Releasable;
import com.gemstone.gemfire.internal.offheap.StoredObject;
import com.gemstone.gemfire.internal.offheap.annotations.Unretained;
@@ -70,7 +70,7 @@ public class GetOperationContextImpl extends GetOperationContext implements Rele
private void checkForReleasedOffHeapValue(Object v) {
// Note that we only care about Chunk (instead of all StoredObject) because it is the only one using a refcount
- if (this.released && v instanceof ObjectChunk) {
+ if (this.released && v instanceof ObjectStoredInMemory) {
throw new IllegalStateException("Attempt to access off-heap value after the OperationContext callback returned.");
}
}
@@ -116,7 +116,7 @@ public class GetOperationContextImpl extends GetOperationContext implements Rele
// our value (since this context did not retain it)
// but we do make sure that any future attempt to access
// the off-heap value fails.
- if (super.getValue() instanceof ObjectChunk) {
+ if (super.getValue() instanceof ObjectStoredInMemory) {
this.released = true;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/AbstractIndex.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/AbstractIndex.java b/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/AbstractIndex.java
index aab99cb..88b82e6 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/AbstractIndex.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/AbstractIndex.java
@@ -75,7 +75,7 @@ import com.gemstone.gemfire.internal.cache.RegionEntry;
import com.gemstone.gemfire.internal.cache.persistence.query.CloseableIterator;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.internal.logging.LogService;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.annotations.Released;
import com.gemstone.gemfire.internal.offheap.annotations.Retained;
import com.gemstone.gemfire.pdx.PdxInstance;
@@ -1477,9 +1477,9 @@ public abstract class AbstractIndex implements IndexProtocol
valueInIndex = verifyAndGetPdxDomainObject(value);
} else{
@Released Object val = re.getValueInVM(context.getPartitionedRegion());
- ObjectChunk valToFree = null;
- if (val instanceof ObjectChunk) {
- valToFree = (ObjectChunk)val;
+ ObjectStoredInMemory valToFree = null;
+ if (val instanceof ObjectStoredInMemory) {
+ valToFree = (ObjectStoredInMemory)val;
}
try {
if (val instanceof CachedDeserializable) {
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/DummyQRegion.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/DummyQRegion.java b/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/DummyQRegion.java
index bde948d..2a1007e 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/DummyQRegion.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/DummyQRegion.java
@@ -41,7 +41,7 @@ import com.gemstone.gemfire.internal.cache.LocalRegion;
import com.gemstone.gemfire.internal.cache.RegionEntry;
import com.gemstone.gemfire.internal.cache.RegionEntryContext;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.annotations.Released;
import com.gemstone.gemfire.internal.offheap.annotations.Retained;
@@ -134,8 +134,8 @@ public class DummyQRegion extends QRegion {
}
valueInList.clear();
Object val = this.entry.getValueOffHeapOrDiskWithoutFaultIn((LocalRegion) getRegion());
- if (val instanceof ObjectChunk) {
- @Retained @Released ObjectChunk ohval = (ObjectChunk) val;
+ if (val instanceof ObjectStoredInMemory) {
+ @Retained @Released ObjectStoredInMemory ohval = (ObjectStoredInMemory) val;
try {
// TODO OFFHEAP: val may be off-heap PdxInstance
val = ohval.getDeserializedValue(getRegion(), this.entry);
@@ -155,8 +155,8 @@ public class DummyQRegion extends QRegion {
valueInArray = new Object[1];
}
Object val = this.entry.getValueOffHeapOrDiskWithoutFaultIn((LocalRegion) getRegion());
- if (val instanceof ObjectChunk) {
- @Retained @Released ObjectChunk ohval = (ObjectChunk) val;
+ if (val instanceof ObjectStoredInMemory) {
+ @Retained @Released ObjectStoredInMemory ohval = (ObjectStoredInMemory) val;
try {
// TODO OFFHEAP: val may be off-heap PdxInstance
val = ohval.getDeserializedValue(getRegion(), this.entry);
@@ -178,8 +178,8 @@ public class DummyQRegion extends QRegion {
}
values.clear();
Object val = this.entry.getValueOffHeapOrDiskWithoutFaultIn((LocalRegion) getRegion());
- if (val instanceof ObjectChunk) {
- @Retained @Released ObjectChunk ohval = (ObjectChunk) val;
+ if (val instanceof ObjectStoredInMemory) {
+ @Retained @Released ObjectStoredInMemory ohval = (ObjectStoredInMemory) val;
try {
// TODO OFFHEAP: val may be off-heap PdxInstance
val = ohval.getDeserializedValue(getRegion(), this.entry);
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/HashIndex.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/HashIndex.java b/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/HashIndex.java
index a30a264..94a97cc 100755
--- a/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/HashIndex.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/cache/query/internal/index/HashIndex.java
@@ -79,7 +79,7 @@ import com.gemstone.gemfire.internal.cache.Token;
import com.gemstone.gemfire.internal.cache.persistence.query.CloseableIterator;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.internal.logging.LogService;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.annotations.Released;
import com.gemstone.gemfire.internal.offheap.annotations.Retained;
import com.gemstone.gemfire.pdx.internal.PdxString;
@@ -876,8 +876,8 @@ public class HashIndex extends AbstractIndex {
if (this.indexOnValues) {
Object o = entry.getValueOffHeapOrDiskWithoutFaultIn((LocalRegion) getRegion());
try {
- if (o instanceof ObjectChunk) {
- ObjectChunk ohval = (ObjectChunk) o;
+ if (o instanceof ObjectStoredInMemory) {
+ ObjectStoredInMemory ohval = (ObjectStoredInMemory) o;
try {
o = ohval.getDeserializedForReading();
} finally {
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionEntry.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionEntry.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionEntry.java
index c2d6a4c..f24aae4 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionEntry.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionEntry.java
@@ -61,7 +61,7 @@ import com.gemstone.gemfire.internal.lang.StringUtils;
import com.gemstone.gemfire.internal.logging.LogService;
import com.gemstone.gemfire.internal.logging.log4j.LocalizedMessage;
import com.gemstone.gemfire.internal.logging.log4j.LogMarker;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.ObjectChunkWithHeapForm;
import com.gemstone.gemfire.internal.offheap.MemoryAllocator;
import com.gemstone.gemfire.internal.offheap.OffHeapHelper;
@@ -987,10 +987,10 @@ public abstract class AbstractRegionEntry implements RegionEntry,
return checkPdxEquals((PdxInstance)v1, v2);
} else if (v2 instanceof PdxInstance) {
return checkPdxEquals((PdxInstance)v2, v1);
- } else if (v1 instanceof ObjectChunk) {
- return checkOffHeapEquals((ObjectChunk)v1, v2);
- } else if (v2 instanceof ObjectChunk) {
- return checkOffHeapEquals((ObjectChunk)v2, v1);
+ } else if (v1 instanceof ObjectStoredInMemory) {
+ return checkOffHeapEquals((ObjectStoredInMemory)v1, v2);
+ } else if (v2 instanceof ObjectStoredInMemory) {
+ return checkOffHeapEquals((ObjectStoredInMemory)v2, v1);
} else if (v1 instanceof CachedDeserializable) {
return checkCDEquals((CachedDeserializable)v1, v2, isCompressedOffHeap);
} else if (v2 instanceof CachedDeserializable) {
@@ -999,13 +999,13 @@ public abstract class AbstractRegionEntry implements RegionEntry,
return basicEquals(v1, v2);
}
}
- private static boolean checkOffHeapEquals(@Unretained ObjectChunk cd, @Unretained Object obj) {
+ private static boolean checkOffHeapEquals(@Unretained ObjectStoredInMemory cd, @Unretained Object obj) {
if (cd.isSerializedPdxInstance()) {
PdxInstance pi = InternalDataSerializer.readPdxInstance(cd.getSerializedValue(), GemFireCacheImpl.getForPdx("Could not check value equality"));
return checkPdxEquals(pi, obj);
}
- if (obj instanceof ObjectChunk) {
- return cd.checkDataEquals((ObjectChunk)obj);
+ if (obj instanceof ObjectStoredInMemory) {
+ return cd.checkDataEquals((ObjectStoredInMemory)obj);
} else {
byte[] serializedObj;
if (obj instanceof CachedDeserializable) {
@@ -1309,9 +1309,9 @@ public abstract class AbstractRegionEntry implements RegionEntry,
}
return prepareValueForCache(r, heapValue, event, isEntryUpdate);
}
- if (val instanceof ObjectChunk) {
+ if (val instanceof ObjectStoredInMemory) {
// if the reused guy has a refcount then need to inc it
- if (!((ObjectChunk)val).retain()) {
+ if (!((ObjectStoredInMemory)val).retain()) {
throw new IllegalStateException("Could not use an off heap value because it was freed");
}
}
@@ -1346,8 +1346,8 @@ public abstract class AbstractRegionEntry implements RegionEntry,
MemoryAllocator ma = SimpleMemoryAllocatorImpl.getAllocator(); // fix for bug 47875
val = ma.allocateAndInitialize(compressedData, isSerialized, isCompressed); // TODO:KIRK:48068 race happens right after this line
ReferenceCountHelper.setReferenceCountOwner(null);
- if (val instanceof ObjectChunk) {
- val = new ObjectChunkWithHeapForm((ObjectChunk)val, data);
+ if (val instanceof ObjectStoredInMemory) {
+ val = new ObjectChunkWithHeapForm((ObjectStoredInMemory)val, data);
}
// if (val instanceof Chunk && r instanceof LocalRegion) {
// Chunk c = (Chunk) val;
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionMap.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionMap.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionMap.java
index 699de2f..5f3a8cc 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionMap.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/AbstractRegionMap.java
@@ -75,7 +75,7 @@ import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.internal.logging.LogService;
import com.gemstone.gemfire.internal.logging.log4j.LocalizedMessage;
import com.gemstone.gemfire.internal.logging.log4j.LogMarker;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.OffHeapHelper;
import com.gemstone.gemfire.internal.offheap.OffHeapRegionEntryHelper;
import com.gemstone.gemfire.internal.offheap.ReferenceCountHelper;
@@ -955,7 +955,7 @@ public abstract class AbstractRegionMap implements RegionMap {
((ListOfDeltas)oldValue).apply(event);
Object preparedNewValue =oldRe.prepareValueForCache(owner,
event.getNewValueAsOffHeapDeserializedOrRaw(), true);
- if(preparedNewValue instanceof ObjectChunk) {
+ if(preparedNewValue instanceof ObjectStoredInMemory) {
event.setNewValue(preparedNewValue);
}
oldRe.setValue(owner, preparedNewValue, event);
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/BytesAndBitsForCompactor.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/BytesAndBitsForCompactor.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/BytesAndBitsForCompactor.java
index cc358f5..7bd7b25 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/BytesAndBitsForCompactor.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/BytesAndBitsForCompactor.java
@@ -16,7 +16,7 @@
*/
package com.gemstone.gemfire.internal.cache;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.annotations.Unretained;
/**
@@ -36,7 +36,7 @@ public class BytesAndBitsForCompactor {
* The dataChunk field is unretained so it can only be used while the RegionEntry is still synced.
* When done with the dataChunk, null it out if you want to reuse the byte[] later.
*/
- private @Unretained ObjectChunk dataChunk;
+ private @Unretained ObjectStoredInMemory dataChunk;
private byte[] data;
private byte userBits=0;
// length of the data present in the byte array
@@ -56,7 +56,7 @@ public class BytesAndBitsForCompactor {
}
- public final ObjectChunk getDataChunk() {
+ public final ObjectStoredInMemory getDataChunk() {
return this.dataChunk;
}
public final byte[] getBytes() {
@@ -87,7 +87,7 @@ public class BytesAndBitsForCompactor {
this.validLength = validLength;
this.isReusable = isReusable;
}
- public void setChunkData(ObjectChunk c, byte userBits) {
+ public void setChunkData(ObjectStoredInMemory c, byte userBits) {
this.dataChunk = c;
this.userBits = userBits;
}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DiskEntry.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DiskEntry.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DiskEntry.java
index dcedc1f..73110f6 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DiskEntry.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DiskEntry.java
@@ -41,7 +41,7 @@ import com.gemstone.gemfire.internal.cache.versions.VersionTag;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.internal.logging.LogService;
import com.gemstone.gemfire.internal.offheap.AddressableMemoryManager;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.OffHeapHelper;
import com.gemstone.gemfire.internal.offheap.ReferenceCountHelper;
import com.gemstone.gemfire.internal.offheap.Releasable;
@@ -208,8 +208,8 @@ public interface DiskEntry extends RegionEntry {
static Object getValueOnDiskOrBuffer(DiskEntry entry, DiskRegion dr, RegionEntryContext context) {
@Released Object v = getOffHeapValueOnDiskOrBuffer(entry, dr, context);
if (v instanceof CachedDeserializable) {
- if (v instanceof ObjectChunk) {
- @Released ObjectChunk ohv = (ObjectChunk) v;
+ if (v instanceof ObjectStoredInMemory) {
+ @Released ObjectStoredInMemory ohv = (ObjectStoredInMemory) v;
try {
v = ohv.getDeserializedValue(null, null);
if (v == ohv) {
@@ -688,8 +688,8 @@ public interface DiskEntry extends RegionEntry {
* Note that this class is only used with uncompressed chunks.
*/
public static class ChunkValueWrapper implements ValueWrapper {
- private final @Unretained ObjectChunk chunk;
- public ChunkValueWrapper(ObjectChunk c) {
+ private final @Unretained ObjectStoredInMemory chunk;
+ public ChunkValueWrapper(ObjectStoredInMemory c) {
assert !c.isCompressed();
this.chunk = c;
}
@@ -722,7 +722,7 @@ public interface DiskEntry extends RegionEntry {
return;
}
}
- final long bbAddress = ObjectChunk.getDirectByteBufferAddress(bb);
+ final long bbAddress = ObjectStoredInMemory.getDirectByteBufferAddress(bb);
if (bbAddress != 0L) {
int bytesRemaining = maxOffset;
int availableSpace = bb.remaining();
@@ -782,8 +782,8 @@ public interface DiskEntry extends RegionEntry {
byte[] bytes;
if (value instanceof CachedDeserializable) {
CachedDeserializable proxy = (CachedDeserializable)value;
- if (proxy instanceof ObjectChunk) {
- return new ChunkValueWrapper((ObjectChunk) proxy);
+ if (proxy instanceof ObjectStoredInMemory) {
+ return new ChunkValueWrapper((ObjectStoredInMemory) proxy);
}
if (proxy instanceof StoredObject) {
StoredObject ohproxy = (StoredObject) proxy;
@@ -833,8 +833,8 @@ public interface DiskEntry extends RegionEntry {
// We don't do this for the delta case because getRawNewValue returns delta
// and we want to write the entire new value to disk.
rawValue = event.getRawNewValue();
- if (rawValue instanceof ObjectChunk) {
- return new ChunkValueWrapper((ObjectChunk) rawValue);
+ if (rawValue instanceof ObjectStoredInMemory) {
+ return new ChunkValueWrapper((ObjectStoredInMemory) rawValue);
}
}
if (event.getCachedSerializedNewValue() != null) {
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DistributedRegion.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DistributedRegion.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DistributedRegion.java
index 19496da..485ac03 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DistributedRegion.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/DistributedRegion.java
@@ -121,7 +121,7 @@ import com.gemstone.gemfire.internal.cache.wan.parallel.ConcurrentParallelGatewa
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.internal.logging.LogService;
import com.gemstone.gemfire.internal.logging.log4j.LocalizedMessage;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.OffHeapHelper;
import com.gemstone.gemfire.internal.offheap.annotations.Released;
import com.gemstone.gemfire.internal.offheap.annotations.Retained;
@@ -2549,8 +2549,8 @@ public class DistributedRegion extends LocalRegion implements
}
//For SQLFire , we need to increment the use count so that returned
//object has use count 2
- if( incrementUseCountForSqlf && result instanceof ObjectChunk) {
- ((ObjectChunk)result).retain();
+ if( incrementUseCountForSqlf && result instanceof ObjectStoredInMemory) {
+ ((ObjectStoredInMemory)result).retain();
}
return result;
} finally {
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/EntryEventImpl.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/EntryEventImpl.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/EntryEventImpl.java
index 3d0d090..d713268 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/EntryEventImpl.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/EntryEventImpl.java
@@ -73,7 +73,7 @@ import com.gemstone.gemfire.internal.lang.StringUtils;
import com.gemstone.gemfire.internal.logging.LogService;
import com.gemstone.gemfire.internal.logging.log4j.LocalizedMessage;
import com.gemstone.gemfire.internal.logging.log4j.LogMarker;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.AddressableStoredObject;
import com.gemstone.gemfire.internal.offheap.OffHeapHelper;
import com.gemstone.gemfire.internal.offheap.OffHeapRegionEntryHelper;
@@ -931,9 +931,9 @@ public class EntryEventImpl
if (this.offHeapOk) {
OffHeapHelper.releaseAndTrackOwner(this.newValue, this);
}
- if (v instanceof ObjectChunk) {
+ if (v instanceof ObjectStoredInMemory) {
ReferenceCountHelper.setReferenceCountOwner(this);
- if (!((ObjectChunk) v).retain()) {
+ if (!((ObjectStoredInMemory) v).retain()) {
ReferenceCountHelper.setReferenceCountOwner(null);
this.newValue = null;
return;
@@ -947,13 +947,13 @@ public class EntryEventImpl
* Returns true if this event has a reference to an off-heap new or old value.
*/
public boolean hasOffHeapValue() {
- return (this.newValue instanceof ObjectChunk) || (this.oldValue instanceof ObjectChunk);
+ return (this.newValue instanceof ObjectStoredInMemory) || (this.oldValue instanceof ObjectStoredInMemory);
}
@Unretained
protected final Object basicGetNewValue() {
Object result = this.newValue;
- if (!this.offHeapOk && result instanceof ObjectChunk) {
+ if (!this.offHeapOk && result instanceof ObjectStoredInMemory) {
//this.region.getCache().getLogger().info("DEBUG new value already freed " + System.identityHashCode(result));
throw new IllegalStateException("Attempt to access off heap value after the EntryEvent was released.");
}
@@ -993,7 +993,7 @@ public class EntryEventImpl
@Released final Object curOldValue = this.oldValue;
if (v == curOldValue) return;
if (this.offHeapOk) {
- if (curOldValue instanceof ObjectChunk) {
+ if (curOldValue instanceof ObjectStoredInMemory) {
if (ReferenceCountHelper.trackReferenceCounts()) {
OffHeapHelper.releaseAndTrackOwner(curOldValue, new OldValueOwner());
} else {
@@ -1009,17 +1009,17 @@ public class EntryEventImpl
private void retainAndSetOldValue(@Retained(ENTRY_EVENT_OLD_VALUE) Object v) {
if (v == this.oldValue) return;
- if (v instanceof ObjectChunk) {
+ if (v instanceof ObjectStoredInMemory) {
if (ReferenceCountHelper.trackReferenceCounts()) {
ReferenceCountHelper.setReferenceCountOwner(new OldValueOwner());
- boolean couldNotRetain = (!((ObjectChunk) v).retain());
+ boolean couldNotRetain = (!((ObjectStoredInMemory) v).retain());
ReferenceCountHelper.setReferenceCountOwner(null);
if (couldNotRetain) {
this.oldValue = null;
return;
}
} else {
- if (!((ObjectChunk) v).retain()) {
+ if (!((ObjectStoredInMemory) v).retain()) {
this.oldValue = null;
return;
}
@@ -1032,7 +1032,7 @@ public class EntryEventImpl
private Object basicGetOldValue() {
@Unretained(ENTRY_EVENT_OLD_VALUE)
Object result = this.oldValue;
- if (!this.offHeapOk && result instanceof ObjectChunk) {
+ if (!this.offHeapOk && result instanceof ObjectStoredInMemory) {
//this.region.getCache().getLogger().info("DEBUG old value already freed " + System.identityHashCode(result));
throw new IllegalStateException("Attempt to access off heap value after the EntryEvent was released.");
}
@@ -1361,7 +1361,7 @@ public class EntryEventImpl
@Unretained(ENTRY_EVENT_NEW_VALUE)
final StoredObject so = (StoredObject) nv;
final boolean isSerialized = so.isSerialized();
- if (nv instanceof ObjectChunk) {
+ if (nv instanceof ObjectStoredInMemory) {
if (importer.isUnretainedNewReferenceOk()) {
importer.importNewObject(nv, isSerialized);
} else {
@@ -1448,7 +1448,7 @@ public class EntryEventImpl
if (ov instanceof StoredObject) {
final StoredObject so = (StoredObject) ov;
final boolean isSerialized = so.isSerialized();
- if (ov instanceof ObjectChunk) {
+ if (ov instanceof ObjectStoredInMemory) {
if (importer.isUnretainedOldReferenceOk()) {
importer.importOldObject(ov, isSerialized);
} else {
@@ -1865,8 +1865,8 @@ public class EntryEventImpl
Object preparedV = reentry.prepareValueForCache(this.region, v, this, this.hasDelta());
if (preparedV != v) {
v = preparedV;
- if (v instanceof ObjectChunk) {
- if (!((ObjectChunk) v).isCompressed()) { // fix bug 52109
+ if (v instanceof ObjectStoredInMemory) {
+ if (!((ObjectStoredInMemory) v).isCompressed()) { // fix bug 52109
// If we put it off heap and it is not compressed then remember that value.
// Otherwise we want to remember the decompressed value in the event.
basicSetNewValue(v);
@@ -1927,8 +1927,8 @@ public class EntryEventImpl
success = true;
}
} finally {
- if (!success && reentry instanceof OffHeapRegionEntry && v instanceof ObjectChunk) {
- OffHeapRegionEntryHelper.releaseEntry((OffHeapRegionEntry)reentry, (ObjectChunk)v);
+ if (!success && reentry instanceof OffHeapRegionEntry && v instanceof ObjectStoredInMemory) {
+ OffHeapRegionEntryHelper.releaseEntry((OffHeapRegionEntry)reentry, (ObjectStoredInMemory)v);
}
}
if (logger.isTraceEnabled()) {
@@ -2228,7 +2228,7 @@ public class EntryEventImpl
* If a PdxInstance is returned then it will have an unretained reference
* to Chunk's off-heap address.
*/
- public static @Unretained Object deserializeChunk(ObjectChunk bytes) {
+ public static @Unretained Object deserializeChunk(ObjectStoredInMemory bytes) {
if (bytes == null)
return null;
try {
@@ -2877,7 +2877,7 @@ public class EntryEventImpl
private final byte[] serializedValue;
SerializedCacheValueImpl(EntryEventImpl event, Region r, RegionEntry re, @Unretained CachedDeserializable cd, byte[] serializedBytes) {
- if (cd instanceof ObjectChunk) {
+ if (cd instanceof ObjectStoredInMemory) {
this.event = event;
} else {
this.event = null;
@@ -3056,14 +3056,14 @@ public class EntryEventImpl
Object nv = basicGetNewValue();
this.offHeapOk = false;
- if (ov instanceof ObjectChunk) {
+ if (ov instanceof ObjectStoredInMemory) {
//this.region.getCache().getLogger().info("DEBUG freeing ref to old value on " + System.identityHashCode(ov));
if (ReferenceCountHelper.trackReferenceCounts()) {
ReferenceCountHelper.setReferenceCountOwner(new OldValueOwner());
- ((ObjectChunk) ov).release();
+ ((ObjectStoredInMemory) ov).release();
ReferenceCountHelper.setReferenceCountOwner(null);
} else {
- ((ObjectChunk) ov).release();
+ ((ObjectStoredInMemory) ov).release();
}
}
OffHeapHelper.releaseAndTrackOwner(nv, this);
@@ -3074,7 +3074,7 @@ public class EntryEventImpl
* Once this is called on an event it does not need to have release called.
*/
public void disallowOffHeapValues() {
- if (this.newValue instanceof ObjectChunk || this.oldValue instanceof ObjectChunk) {
+ if (this.newValue instanceof ObjectStoredInMemory || this.oldValue instanceof ObjectStoredInMemory) {
throw new IllegalStateException("This event does not support off-heap values");
}
this.offHeapOk = false;
@@ -3088,7 +3088,7 @@ public class EntryEventImpl
@Released({ENTRY_EVENT_NEW_VALUE, ENTRY_EVENT_OLD_VALUE})
public void copyOffHeapToHeap() {
Object ov = basicGetOldValue();
- if (ov instanceof ObjectChunk) {
+ if (ov instanceof ObjectStoredInMemory) {
if (ReferenceCountHelper.trackReferenceCounts()) {
ReferenceCountHelper.setReferenceCountOwner(new OldValueOwner());
this.oldValue = OffHeapHelper.copyAndReleaseIfNeeded(ov);
@@ -3098,19 +3098,19 @@ public class EntryEventImpl
}
}
Object nv = basicGetNewValue();
- if (nv instanceof ObjectChunk) {
+ if (nv instanceof ObjectStoredInMemory) {
ReferenceCountHelper.setReferenceCountOwner(this);
this.newValue = OffHeapHelper.copyAndReleaseIfNeeded(nv);
ReferenceCountHelper.setReferenceCountOwner(null);
}
- if (this.newValue instanceof ObjectChunk || this.oldValue instanceof ObjectChunk) {
+ if (this.newValue instanceof ObjectStoredInMemory || this.oldValue instanceof ObjectStoredInMemory) {
throw new IllegalStateException("event's old/new value still off-heap after calling copyOffHeapToHeap");
}
this.offHeapOk = false;
}
public boolean isOldValueOffHeap() {
- return this.oldValue instanceof ObjectChunk;
+ return this.oldValue instanceof ObjectStoredInMemory;
}
public final boolean isFetchFromHDFS() {
return fetchFromHDFS;
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/LocalRegion.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/LocalRegion.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/LocalRegion.java
index b6d8c49..f3d59b2 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/LocalRegion.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/LocalRegion.java
@@ -203,7 +203,7 @@ import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
import com.gemstone.gemfire.internal.logging.LogService;
import com.gemstone.gemfire.internal.logging.log4j.LocalizedMessage;
import com.gemstone.gemfire.internal.logging.log4j.LogMarker;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.OffHeapHelper;
import com.gemstone.gemfire.internal.offheap.ReferenceCountHelper;
import com.gemstone.gemfire.internal.offheap.StoredObject;
@@ -1587,8 +1587,8 @@ public class LocalRegion extends AbstractRegion
}
//For sqlf since the deserialized value is nothing but chunk
// before returning the found value increase its use count
- if(GemFireCacheImpl.sqlfSystem() && result instanceof ObjectChunk) {
- if(!((ObjectChunk)result).retain()) {
+ if(GemFireCacheImpl.sqlfSystem() && result instanceof ObjectStoredInMemory) {
+ if(!((ObjectStoredInMemory)result).retain()) {
return null;
}
}
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/PartitionedRegion.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/PartitionedRegion.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/PartitionedRegion.java
index 541c453..9f285f8 100755
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/PartitionedRegion.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/PartitionedRegion.java
@@ -252,7 +252,7 @@ import com.gemstone.gemfire.internal.logging.LogService;
import com.gemstone.gemfire.internal.logging.LoggingThreadGroup;
import com.gemstone.gemfire.internal.logging.log4j.LocalizedMessage;
import com.gemstone.gemfire.internal.logging.log4j.LogMarker;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.annotations.Unretained;
import com.gemstone.gemfire.internal.sequencelog.RegionLogger;
import com.gemstone.gemfire.internal.util.TransformUtils;
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/tier/sockets/Part.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/tier/sockets/Part.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/tier/sockets/Part.java
index 52e3488..67e641a 100755
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/tier/sockets/Part.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/tier/sockets/Part.java
@@ -18,7 +18,7 @@ package com.gemstone.gemfire.internal.cache.tier.sockets;
import com.gemstone.gemfire.internal.*;
import com.gemstone.gemfire.internal.cache.CachedDeserializable;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.AddressableMemoryManager;
import com.gemstone.gemfire.internal.offheap.ObjectStoredAsAddress;
import com.gemstone.gemfire.internal.offheap.StoredObject;
@@ -131,7 +131,7 @@ public class Part {
if (so instanceof ObjectStoredAsAddress) {
this.part = ((ObjectStoredAsAddress)so).getRawBytes();
} else {
- this.part = (ObjectChunk)so;
+ this.part = (ObjectStoredInMemory)so;
}
}
public byte getTypeCode() {
@@ -146,8 +146,8 @@ public class Part {
return 0;
} else if (this.part instanceof byte[]) {
return ((byte[])this.part).length;
- } else if (this.part instanceof ObjectChunk) {
- return ((ObjectChunk) this.part).getValueSizeInBytes();
+ } else if (this.part instanceof ObjectStoredInMemory) {
+ return ((ObjectStoredInMemory) this.part).getValueSizeInBytes();
} else {
return ((HeapDataOutputStream)this.part).size();
}
@@ -289,8 +289,8 @@ public class Part {
if (this.part instanceof byte[]) {
byte[] bytes = (byte[])this.part;
out.write(bytes, 0, bytes.length);
- } else if (this.part instanceof ObjectChunk) {
- ObjectChunk c = (ObjectChunk) this.part;
+ } else if (this.part instanceof ObjectStoredInMemory) {
+ ObjectStoredInMemory c = (ObjectStoredInMemory) this.part;
ByteBuffer cbb = c.createDirectByteBuffer();
if (cbb != null) {
HeapDataOutputStream.writeByteBufferToStream(out, buf, cbb);
@@ -322,8 +322,8 @@ public class Part {
if (getLength() > 0) {
if (this.part instanceof byte[]) {
buf.put((byte[])this.part);
- } else if (this.part instanceof ObjectChunk) {
- ObjectChunk c = (ObjectChunk) this.part;
+ } else if (this.part instanceof ObjectStoredInMemory) {
+ ObjectStoredInMemory c = (ObjectStoredInMemory) this.part;
ByteBuffer bb = c.createDirectByteBuffer();
if (bb != null) {
buf.put(bb);
@@ -372,10 +372,10 @@ public class Part {
}
buf.clear();
}
- } else if (this.part instanceof ObjectChunk) {
+ } else if (this.part instanceof ObjectStoredInMemory) {
// instead of copying the Chunk to buf try to create a direct ByteBuffer and
// just write it directly to the socket channel.
- ObjectChunk c = (ObjectChunk) this.part;
+ ObjectStoredInMemory c = (ObjectStoredInMemory) this.part;
ByteBuffer bb = c.createDirectByteBuffer();
if (bb != null) {
while (bb.remaining() > 0) {
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/wan/GatewaySenderEventImpl.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/wan/GatewaySenderEventImpl.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/wan/GatewaySenderEventImpl.java
index 0e506f7..51ee135 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/wan/GatewaySenderEventImpl.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/cache/wan/GatewaySenderEventImpl.java
@@ -50,7 +50,7 @@ import com.gemstone.gemfire.internal.cache.WrappedCallbackArgument;
import com.gemstone.gemfire.internal.cache.lru.Sizeable;
import com.gemstone.gemfire.internal.cache.tier.sockets.CacheServerHelper;
import com.gemstone.gemfire.internal.i18n.LocalizedStrings;
-import com.gemstone.gemfire.internal.offheap.ObjectChunk;
+import com.gemstone.gemfire.internal.offheap.ObjectStoredInMemory;
import com.gemstone.gemfire.internal.offheap.ObjectChunkWithHeapForm;
import com.gemstone.gemfire.internal.offheap.OffHeapHelper;
import com.gemstone.gemfire.internal.offheap.ReferenceCountHelper;
@@ -554,11 +554,11 @@ public class GatewaySenderEventImpl implements
result = this.substituteValue;
if (result == null) {
result = this.valueObj;
- if (result instanceof ObjectChunk) {
+ if (result instanceof ObjectStoredInMemory) {
if (this.valueObjReleased) {
result = null;
} else {
- ObjectChunk ohref = (ObjectChunk) result;
+ ObjectStoredInMemory ohref = (ObjectStoredInMemory) result;
if (!ohref.retain()) {
result = null;
} else if (this.valueObjReleased) {
@@ -1280,7 +1280,7 @@ public class GatewaySenderEventImpl implements
return this;
}
}
- if (v instanceof ObjectChunk) {
+ if (v instanceof ObjectStoredInMemory) {
try {
return makeCopy();
} catch (IllegalStateException ex) {
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/Fragment.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/Fragment.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/Fragment.java
index 351bb8c..00501cf 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/Fragment.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/Fragment.java
@@ -30,7 +30,7 @@ import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
*
*/
public class Fragment implements MemoryBlock {
- private static final byte FILL_BYTE = ObjectChunk.FILL_BYTE;
+ private static final byte FILL_BYTE = ObjectStoredInMemory.FILL_BYTE;
private final long baseAddr;
private final int size;
@SuppressWarnings("unused")
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/FreeListManager.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/FreeListManager.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/FreeListManager.java
index d4c23c5..048372b 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/FreeListManager.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/FreeListManager.java
@@ -45,30 +45,30 @@ public class FreeListManager {
final private AtomicReferenceArray<SyncChunkStack> tinyFreeLists = new AtomicReferenceArray<SyncChunkStack>(TINY_FREE_LIST_COUNT);
// hugeChunkSet is sorted by chunk size in ascending order. It will only contain chunks larger than MAX_TINY.
- private final ConcurrentSkipListSet<ObjectChunk> hugeChunkSet = new ConcurrentSkipListSet<ObjectChunk>();
+ private final ConcurrentSkipListSet<ObjectStoredInMemory> hugeChunkSet = new ConcurrentSkipListSet<ObjectStoredInMemory>();
private final AtomicLong allocatedSize = new AtomicLong(0L);
private int getNearestTinyMultiple(int size) {
return (size-1)/TINY_MULTIPLE;
}
- List<ObjectChunk> getLiveChunks() {
- ArrayList<ObjectChunk> result = new ArrayList<ObjectChunk>();
+ List<ObjectStoredInMemory> getLiveChunks() {
+ ArrayList<ObjectStoredInMemory> result = new ArrayList<ObjectStoredInMemory>();
for (int i=0; i < slabs.length; i++) {
getLiveChunks(slabs[i], result);
}
return result;
}
- private void getLiveChunks(Slab slab, List<ObjectChunk> result) {
+ private void getLiveChunks(Slab slab, List<ObjectStoredInMemory> result) {
long addr = slab.getMemoryAddress();
- while (addr <= (slab.getMemoryAddress() + slab.getSize() - ObjectChunk.MIN_CHUNK_SIZE)) {
+ while (addr <= (slab.getMemoryAddress() + slab.getSize() - ObjectStoredInMemory.MIN_CHUNK_SIZE)) {
Fragment f = isAddrInFragmentFreeSpace(addr);
if (f != null) {
addr = f.getMemoryAddress() + f.getSize();
} else {
- int curChunkSize = ObjectChunk.getSize(addr);
- int refCount = ObjectChunk.getRefCount(addr);
+ int curChunkSize = ObjectStoredInMemory.getSize(addr);
+ int refCount = ObjectStoredInMemory.getRefCount(addr);
if (refCount > 0) {
- result.add(new ObjectChunk(addr));
+ result.add(new ObjectStoredInMemory(addr));
}
addr += curChunkSize;
}
@@ -95,7 +95,7 @@ public class FreeListManager {
long result = 0;
for (Fragment f: this.fragmentList) {
int freeSpace = f.freeSpace();
- if (freeSpace >= ObjectChunk.MIN_CHUNK_SIZE) {
+ if (freeSpace >= ObjectStoredInMemory.MIN_CHUNK_SIZE) {
result += freeSpace;
}
}
@@ -113,7 +113,7 @@ public class FreeListManager {
}
long getFreeHugeMemory() {
long hugeFree = 0;
- for (ObjectChunk c: this.hugeChunkSet) {
+ for (ObjectStoredInMemory c: this.hugeChunkSet) {
hugeFree += c.getSize();
}
return hugeFree;
@@ -178,10 +178,10 @@ public class FreeListManager {
* @throws IllegalStateException if a chunk can not be allocated.
*/
@SuppressWarnings("synthetic-access")
- public ObjectChunk allocate(int size) {
+ public ObjectStoredInMemory allocate(int size) {
assert size > 0;
- ObjectChunk result = basicAllocate(size, true);
+ ObjectStoredInMemory result = basicAllocate(size, true);
result.setDataSize(size);
this.allocatedSize.addAndGet(result.getSize());
@@ -190,13 +190,13 @@ public class FreeListManager {
return result;
}
- private ObjectChunk basicAllocate(int size, boolean useSlabs) {
+ private ObjectStoredInMemory basicAllocate(int size, boolean useSlabs) {
if (useSlabs) {
// Every object stored off heap has a header so we need
// to adjust the size so that the header gets allocated.
// If useSlabs is false then the incoming size has already
// been adjusted.
- size += ObjectChunk.OFF_HEAP_HEADER_SIZE;
+ size += ObjectStoredInMemory.OFF_HEAP_HEADER_SIZE;
}
if (size <= MAX_TINY) {
return allocateTiny(size, useSlabs);
@@ -205,17 +205,17 @@ public class FreeListManager {
}
}
- private ObjectChunk allocateFromFragments(int chunkSize) {
+ private ObjectStoredInMemory allocateFromFragments(int chunkSize) {
do {
final int lastAllocationId = this.lastFragmentAllocation.get();
for (int i=lastAllocationId; i < this.fragmentList.size(); i++) {
- ObjectChunk result = allocateFromFragment(i, chunkSize);
+ ObjectStoredInMemory result = allocateFromFragment(i, chunkSize);
if (result != null) {
return result;
}
}
for (int i=0; i < lastAllocationId; i++) {
- ObjectChunk result = allocateFromFragment(i, chunkSize);
+ ObjectStoredInMemory result = allocateFromFragment(i, chunkSize);
if (result != null) {
return result;
}
@@ -247,7 +247,7 @@ public class FreeListManager {
}
private void logHugeState(LogWriter lw) {
- for (ObjectChunk c: this.hugeChunkSet) {
+ for (ObjectStoredInMemory c: this.hugeChunkSet) {
lw.info("Free huge of size " + c.getSize());
}
}
@@ -345,10 +345,10 @@ public class FreeListManager {
} else {
// see if we can conflate into sorted[idx]
long lowAddr = sorted[idx-1];
- int lowSize = ObjectChunk.getSize(lowAddr);
+ int lowSize = ObjectStoredInMemory.getSize(lowAddr);
if (lowAddr + lowSize == addr) {
// append the addr chunk to lowAddr
- ObjectChunk.setSize(lowAddr, lowSize + ObjectChunk.getSize(addr));
+ ObjectStoredInMemory.setSize(lowAddr, lowSize + ObjectStoredInMemory.getSize(addr));
} else {
if (sortedSize >= sorted.length) {
long[] newSorted = new long[sorted.length+SORT_ARRAY_BLOCK_SIZE];
@@ -360,11 +360,11 @@ public class FreeListManager {
}
}
} else {
- int addrSize = ObjectChunk.getSize(addr);
+ int addrSize = ObjectStoredInMemory.getSize(addr);
long highAddr = sorted[idx];
if (addr + addrSize == highAddr) {
// append highAddr chunk to addr
- ObjectChunk.setSize(addr, addrSize + ObjectChunk.getSize(highAddr));
+ ObjectStoredInMemory.setSize(addr, addrSize + ObjectStoredInMemory.getSize(highAddr));
sorted[idx] = addr;
} else {
boolean insert = idx==0;
@@ -374,10 +374,10 @@ public class FreeListManager {
// long[] tmp = Arrays.copyOf(sorted, sortedSize);
// throw new IllegalStateException("addr was zero at idx=" + (idx-1) + " sorted="+ Arrays.toString(tmp));
// }
- int lowSize = ObjectChunk.getSize(lowAddr);
+ int lowSize = ObjectStoredInMemory.getSize(lowAddr);
if (lowAddr + lowSize == addr) {
// append the addr chunk to lowAddr
- ObjectChunk.setSize(lowAddr, lowSize + addrSize);
+ ObjectStoredInMemory.setSize(lowAddr, lowSize + addrSize);
} else {
insert = true;
}
@@ -403,10 +403,10 @@ public class FreeListManager {
for (int i=sortedSize-1; i > 0; i--) {
long addr = sorted[i];
long lowAddr = sorted[i-1];
- int lowSize = ObjectChunk.getSize(lowAddr);
+ int lowSize = ObjectStoredInMemory.getSize(lowAddr);
if (lowAddr + lowSize == addr) {
// append addr chunk to lowAddr
- ObjectChunk.setSize(lowAddr, lowSize + ObjectChunk.getSize(addr));
+ ObjectStoredInMemory.setSize(lowAddr, lowSize + ObjectStoredInMemory.getSize(addr));
sorted[i] = 0L;
}
}
@@ -415,7 +415,7 @@ public class FreeListManager {
for (int i=sortedSize-1; i >= 0; i--) {
long addr = sorted[i];
if (addr == 0L) continue;
- int addrSize = ObjectChunk.getSize(addr);
+ int addrSize = ObjectStoredInMemory.getSize(addr);
Fragment f = createFragment(addr, addrSize);
if (addrSize >= chunkSize) {
result = true;
@@ -492,8 +492,8 @@ public class FreeListManager {
} else {
//more than 1 fragment is available so freeMemory is > ObjectChunk.MIN_CHUNK_SIZE
long freeMemory = getFreeMemory();
- assert freeMemory > ObjectChunk.MIN_CHUNK_SIZE;
- long maxPossibleFragments = freeMemory / ObjectChunk.MIN_CHUNK_SIZE;
+ assert freeMemory > ObjectStoredInMemory.MIN_CHUNK_SIZE;
+ long maxPossibleFragments = freeMemory / ObjectStoredInMemory.MIN_CHUNK_SIZE;
double fragmentation = ((double) availableFragments /(double) maxPossibleFragments) * 100d;
return (int) Math.rint(fragmentation);
}
@@ -517,8 +517,8 @@ public class FreeListManager {
do {
offset = f.getFreeIndex();
diff = f.getSize() - offset;
- } while (diff >= ObjectChunk.MIN_CHUNK_SIZE && !f.allocate(offset, offset+diff));
- if (diff < ObjectChunk.MIN_CHUNK_SIZE) {
+ } while (diff >= ObjectStoredInMemory.MIN_CHUNK_SIZE && !f.allocate(offset, offset+diff));
+ if (diff < ObjectStoredInMemory.MIN_CHUNK_SIZE) {
// If diff > 0 then that memory will be lost during compaction.
// This should never happen since we keep the sizes rounded
// based on MIN_CHUNK_SIZE.
@@ -527,7 +527,7 @@ public class FreeListManager {
continue;
}
long chunkAddr = f.getMemoryAddress()+offset;
- ObjectChunk.setSize(chunkAddr, diff);
+ ObjectStoredInMemory.setSize(chunkAddr, diff);
result.offer(chunkAddr);
}
// All the fragments have been turned in to chunks so now clear them
@@ -549,7 +549,7 @@ public class FreeListManager {
}
}
private void collectFreeHugeChunks(List<SyncChunkStack> l) {
- ObjectChunk c = this.hugeChunkSet.pollFirst();
+ ObjectStoredInMemory c = this.hugeChunkSet.pollFirst();
SyncChunkStack result = null;
while (c != null) {
if (result == null) {
@@ -561,7 +561,7 @@ public class FreeListManager {
}
}
- ObjectChunk allocateFromFragment(final int fragIdx, final int chunkSize) {
+ ObjectStoredInMemory allocateFromFragment(final int fragIdx, final int chunkSize) {
if (fragIdx >= this.fragmentList.size()) return null;
final Fragment fragment;
try {
@@ -580,7 +580,7 @@ public class FreeListManager {
// this fragment has room
int newOffset = oldOffset + chunkSize;
int extraSize = fragmentSize - newOffset;
- if (extraSize < ObjectChunk.MIN_CHUNK_SIZE) {
+ if (extraSize < ObjectStoredInMemory.MIN_CHUNK_SIZE) {
// include these last few bytes of the fragment in the allocation.
// If we don't then they will be lost forever.
// The extraSize bytes only apply to the first chunk we allocate (not the batch ones).
@@ -591,11 +591,11 @@ public class FreeListManager {
if (fragment.allocate(oldOffset, newOffset)) {
// We did the allocate!
this.lastFragmentAllocation.set(fragIdx);
- ObjectChunk result = new ObjectChunk(fragment.getMemoryAddress()+oldOffset, chunkSize+extraSize);
+ ObjectStoredInMemory result = new ObjectStoredInMemory(fragment.getMemoryAddress()+oldOffset, chunkSize+extraSize);
checkDataIntegrity(result);
return result;
} else {
- ObjectChunk result = basicAllocate(chunkSize, false);
+ ObjectStoredInMemory result = basicAllocate(chunkSize, false);
if (result != null) {
return result;
}
@@ -609,15 +609,15 @@ public class FreeListManager {
private int round(int multiple, int value) {
return (int) ((((long)value + (multiple-1)) / multiple) * multiple);
}
- private ObjectChunk allocateTiny(int size, boolean useFragments) {
+ private ObjectStoredInMemory allocateTiny(int size, boolean useFragments) {
return basicAllocate(getNearestTinyMultiple(size), TINY_MULTIPLE, 0, this.tinyFreeLists, useFragments);
}
- private ObjectChunk basicAllocate(int idx, int multiple, int offset, AtomicReferenceArray<SyncChunkStack> freeLists, boolean useFragments) {
+ private ObjectStoredInMemory basicAllocate(int idx, int multiple, int offset, AtomicReferenceArray<SyncChunkStack> freeLists, boolean useFragments) {
SyncChunkStack clq = freeLists.get(idx);
if (clq != null) {
long memAddr = clq.poll();
if (memAddr != 0) {
- ObjectChunk result = new ObjectChunk(memAddr);
+ ObjectStoredInMemory result = new ObjectStoredInMemory(memAddr);
checkDataIntegrity(result);
result.readyForAllocation();
return result;
@@ -629,13 +629,13 @@ public class FreeListManager {
return null;
}
}
- private ObjectChunk allocateHuge(int size, boolean useFragments) {
+ private ObjectStoredInMemory allocateHuge(int size, boolean useFragments) {
// sizeHolder is a fake Chunk used to search our sorted hugeChunkSet.
- ObjectChunk sizeHolder = new FakeChunk(size);
- NavigableSet<ObjectChunk> ts = this.hugeChunkSet.tailSet(sizeHolder);
- ObjectChunk result = ts.pollFirst();
+ ObjectStoredInMemory sizeHolder = new FakeChunk(size);
+ NavigableSet<ObjectStoredInMemory> ts = this.hugeChunkSet.tailSet(sizeHolder);
+ ObjectStoredInMemory result = ts.pollFirst();
if (result != null) {
- if (result.getSize() - (HUGE_MULTIPLE - ObjectChunk.OFF_HEAP_HEADER_SIZE) < size) {
+ if (result.getSize() - (HUGE_MULTIPLE - ObjectStoredInMemory.OFF_HEAP_HEADER_SIZE) < size) {
// close enough to the requested size; just return it.
checkDataIntegrity(result);
result.readyForAllocation();
@@ -653,7 +653,7 @@ public class FreeListManager {
}
}
- private void checkDataIntegrity(ObjectChunk data) {
+ private void checkDataIntegrity(ObjectStoredInMemory data) {
if (this.validateMemoryWithFill) {
data.validateFill();
}
@@ -663,7 +663,7 @@ public class FreeListManager {
* ConcurrentSkipListSet. This is not a real chunk
* but only used for searching.
*/
- private static class FakeChunk extends ObjectChunk {
+ private static class FakeChunk extends ObjectStoredInMemory {
private final int size;
public FakeChunk(int size) {
super();
@@ -678,14 +678,14 @@ public class FreeListManager {
@SuppressWarnings("synthetic-access")
public void free(long addr) {
if (this.validateMemoryWithFill) {
- ObjectChunk.fill(addr);
+ ObjectStoredInMemory.fill(addr);
}
free(addr, true);
}
private void free(long addr, boolean updateStats) {
- int cSize = ObjectChunk.getSize(addr);
+ int cSize = ObjectStoredInMemory.getSize(addr);
if (updateStats) {
OffHeapMemoryStats stats = this.ma.getStats();
stats.incObjects(-1);
@@ -724,7 +724,7 @@ public class FreeListManager {
}
private void freeHuge(long addr, int cSize) {
- this.hugeChunkSet.add(new ObjectChunk(addr)); // TODO make this a collection of longs
+ this.hugeChunkSet.add(new ObjectStoredInMemory(addr)); // TODO make this a collection of longs
}
List<MemoryBlock> getOrderedBlocks() {
@@ -748,8 +748,8 @@ public class FreeListManager {
}
}
- private void addBlocksFromChunks(Collection<ObjectChunk> src, List<MemoryBlock> dest) {
- for (ObjectChunk chunk : src) {
+ private void addBlocksFromChunks(Collection<ObjectStoredInMemory> src, List<MemoryBlock> dest) {
+ for (ObjectStoredInMemory chunk : src) {
dest.add(new MemoryBlockNode(this.ma, chunk));
}
}
@@ -768,7 +768,7 @@ public class FreeListManager {
long addr = this.tinyFreeLists.get(i).getTopAddress();
while (addr != 0L) {
value.add(new MemoryBlockNode(sma, new TinyMemoryBlock(addr, i)));
- addr = ObjectChunk.getNext(addr);
+ addr = ObjectStoredInMemory.getNext(addr);
}
}
return value;
@@ -809,7 +809,7 @@ public class FreeListManager {
@Override
public int getBlockSize() {
- return ObjectChunk.getSize(address);
+ return ObjectStoredInMemory.getSize(address);
}
@Override
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/b75d0400/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNode.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNode.java b/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNode.java
index b41d429..3e5186f 100644
--- a/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNode.java
+++ b/geode-core/src/main/java/com/gemstone/gemfire/internal/offheap/MemoryBlockNode.java
@@ -65,15 +65,15 @@ public class MemoryBlockNode implements MemoryBlock {
if (!isSerialized()) {
// byte array
if (isCompressed()) {
- return "compressed byte[" + ((ObjectChunk)this.block).getDataSize() + "]";
+ return "compressed byte[" + ((ObjectStoredInMemory)this.block).getDataSize() + "]";
} else {
- return "byte[" + ((ObjectChunk)this.block).getDataSize() + "]";
+ return "byte[" + ((ObjectStoredInMemory)this.block).getDataSize() + "]";
}
} else if (isCompressed()) {
- return "compressed object of size " + ((ObjectChunk)this.block).getDataSize();
+ return "compressed object of size " + ((ObjectStoredInMemory)this.block).getDataSize();
}
//Object obj = EntryEventImpl.deserialize(((Chunk)this.block).getRawBytes());
- byte[] bytes = ((ObjectChunk)this.block).getRawBytes();
+ byte[] bytes = ((ObjectStoredInMemory)this.block).getRawBytes();
return DataType.getDataType(bytes);
}
public boolean isSerialized() {
@@ -88,14 +88,14 @@ public class MemoryBlockNode implements MemoryBlock {
if (dataType == null || dataType.equals("N/A")) {
return null;
} else if (isCompressed()) {
- return ((ObjectChunk)this.block).getCompressedBytes();
+ return ((ObjectStoredInMemory)this.block).getCompressedBytes();
} else if (!isSerialized()) {
// byte array
//return "byte[" + ((Chunk)this.block).getDataSize() + "]";
- return ((ObjectChunk)this.block).getRawBytes();
+ return ((ObjectStoredInMemory)this.block).getRawBytes();
} else {
try {
- byte[] bytes = ((ObjectChunk)this.block).getRawBytes();
+ byte[] bytes = ((ObjectStoredInMemory)this.block).getRawBytes();
return DataSerializer.readObject(DataType.getDataInput(bytes));
} catch (IOException e) {
e.printStackTrace();