http://git-wip-us.apache.org/repos/asf/geode/blob/d4f23332/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapLongKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapLongKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapLongKey.java index dba3d74..037e2ba 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapLongKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapLongKey.java @@ -15,82 +15,123 @@ package org.apache.geode.internal.cache; // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + + + + + import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; + import java.util.concurrent.atomic.AtomicLongFieldUpdater; + import org.apache.geode.cache.EntryEvent; + + import org.apache.geode.internal.cache.lru.EnableLRU; + + import org.apache.geode.internal.cache.persistence.DiskRecoveryStore; + + import org.apache.geode.internal.InternalStatisticsDisabledException; + + + + + + import org.apache.geode.distributed.internal.membership.InternalDistributedMember; import org.apache.geode.internal.cache.versions.VersionSource; import org.apache.geode.internal.cache.versions.VersionStamp; import org.apache.geode.internal.cache.versions.VersionTag; + + import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper; import org.apache.geode.internal.offheap.annotations.Released; import org.apache.geode.internal.offheap.annotations.Retained; import org.apache.geode.internal.offheap.annotations.Unretained; + import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry; // macros whose definition changes this class: -// disk: DISK +// disk: 1 // lru: LRU -// stats: STATS -// versioned: VERSIONED -// offheap: OFFHEAP +// stats: 1 +// versioned: 1 +// offheap: 1 // One of the following key macros must be defined: // key object: KEY_OBJECT // key int: KEY_INT -// key long: KEY_LONG +// key long: 1 // key uuid: KEY_UUID // key string1: KEY_STRING1 // key string2: KEY_STRING2 + /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ -public class VersionedStatsDiskRegionEntryOffHeapLongKey - extends VersionedStatsDiskRegionEntryOffHeap { - public VersionedStatsDiskRegionEntryOffHeapLongKey(RegionEntryContext context, long key, - @Retained Object value) { - super(context, (value instanceof RecoveredEntry ? null : value)); +public class VersionedStatsDiskRegionEntryOffHeapLongKey extends VersionedStatsDiskRegionEntryOffHeap { + public VersionedStatsDiskRegionEntryOffHeapLongKey (RegionEntryContext context, long key, + + @Retained + + Object value + + + + ) { + super(context, + + (value instanceof RecoveredEntry ? null : value) + + + + ); // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + initialize(context, value); + + + + + + this.key = key; + } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // common code protected int hash; private HashEntry<Object, Object> next; @SuppressWarnings("unused") private volatile long lastModified; - private static final AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapLongKey> lastModifiedUpdater = - AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapLongKey.class, - "lastModified"); + private static final AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapLongKey> lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapLongKey.class, "lastModified"); + /** * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is. */ @SuppressWarnings("unused") - @Retained - @Released - private volatile long ohAddress; + @Retained @Released private volatile long ohAddress; /** - * I needed to add this because I wanted clear to call setValue which normally can only be called - * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the - * disk regions because they also get a rw lock in clear. Some hardware platforms do not support - * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the - * re and we will once again be deadlocked. I don't know if we support any of the hardware - * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions. + * I needed to add this because I wanted clear to call setValue which normally can only be called while the re is synced. + * But if I sync in that code it causes a lock ordering deadlock with the disk regions because they also get a rw lock in clear. + * Some hardware platforms do not support CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync + * on the re and we will once again be deadlocked. + * I don't know if we support any of the hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks + * on disk regions. */ - private final static AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapLongKey> ohAddrUpdater = - AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapLongKey.class, - "ohAddress"); - + private final static AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapLongKey> ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapLongKey.class, "ohAddress"); + @Override public Token getValueAsToken() { return OffHeapRegionEntryHelper.getValueAsToken(this); } - + @Override protected Object getValueField() { return OffHeapRegionEntryHelper._getValue(this); @@ -98,13 +139,18 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey // DO NOT modify this class. It was generated from LeafRegionEntry.cpp @Override + @Unretained protected void setValueField(@Unretained Object v) { + + + OffHeapRegionEntryHelper.setValue(this, v); } - @Override + @Retained + public Object _getValueRetain(RegionEntryContext context, boolean decompress) { return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context); } @@ -118,47 +164,44 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey public boolean setAddress(long expectedAddr, long newAddr) { return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr); } - + @Override + @Released + public void release() { OffHeapRegionEntryHelper.releaseEntry(this); } - + @Override public void returnToPool() { // Deadcoded for now; never was working - // if (this instanceof VMThinRegionEntryLongKey) { - // factory.returnToPool((VMThinRegionEntryLongKey)this); - // } +// if (this instanceof VMThinRegionEntryLongKey) { +// factory.returnToPool((VMThinRegionEntryLongKey)this); +// } } - protected long getlastModifiedField() { + protected long getLastModifiedField() { return lastModifiedUpdater.get(this); } - protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) { return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue); } - /** * @see HashEntry#getEntryHash() */ public final int getEntryHash() { return this.hash; } - protected void setEntryHash(int v) { this.hash = v; } - /** * @see HashEntry#getNextEntry() */ public final HashEntry<Object, Object> getNextEntry() { return this.next; } - /** * @see HashEntry#setNextEntry */ @@ -166,23 +209,27 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey this.next = n; } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // disk code + protected void initialize(RegionEntryContext context, Object value) { diskInitialize(context, value); } - @Override public int updateAsyncEntrySize(EnableLRU capacityController) { throw new IllegalStateException("should never be called"); } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + private void diskInitialize(RegionEntryContext context, Object value) { - DiskRecoveryStore drs = (DiskRecoveryStore) context; + DiskRecoveryStore drs = (DiskRecoveryStore)context; DiskStoreImpl ds = drs.getDiskStore(); long maxOplogSize = ds.getMaxOplogSize(); - // get appropriate instance of DiskId implementation based on maxOplogSize + //get appropriate instance of DiskId implementation based on maxOplogSize this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList()); Helper.initialize(this, drs, value); } @@ -192,60 +239,64 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey * * @since GemFire 5.1 */ - protected DiskId id;// = new DiskId(); - + protected DiskId id;//= new DiskId(); public DiskId getDiskId() { return this.id; } - @Override void setDiskId(RegionEntry old) { - this.id = ((AbstractDiskRegionEntry) old).getDiskId(); - } - - // // inlining DiskId - // // always have these fields - // /** - // * id consists of - // * most significant - // * 1 byte = users bits - // * 2-8 bytes = oplog id - // * least significant. - // * - // * The highest bit in the oplog id part is set to 1 if the oplog id - // * is negative. - // * @todo this field could be an int for an overflow only region - // */ - // private long id; - // /** - // * Length of the bytes on disk. - // * This is always set. If the value is invalid then it will be set to 0. - // * The most significant bit is used by overflow to mark it as needing to be written. - // */ - // protected int valueLength = 0; - // // have intOffset or longOffset - // // intOffset - // /** - // * The position in the oplog (the oplog offset) where this entry's value is - // * stored - // */ - // private volatile int offsetInOplog; - // // longOffset - // /** - // * The position in the oplog (the oplog offset) where this entry's value is - // * stored - // */ - // private volatile long offsetInOplog; - // // have overflowOnly or persistence - // // overflowOnly - // // no fields - // // persistent - // /** unique entry identifier * */ - // private long keyId; + this.id = ((AbstractDiskRegionEntry)old).getDiskId(); + } +// // inlining DiskId +// // always have these fields +// /** +// * id consists of +// * most significant +// * 1 byte = users bits +// * 2-8 bytes = oplog id +// * least significant. +// * +// * The highest bit in the oplog id part is set to 1 if the oplog id +// * is negative. +// * @todo this field could be an int for an overflow only region +// */ +// private long id; +// /** +// * Length of the bytes on disk. +// * This is always set. If the value is invalid then it will be set to 0. +// * The most significant bit is used by overflow to mark it as needing to be written. +// */ +// protected int valueLength = 0; +// // have intOffset or longOffset +// // intOffset +// /** +// * The position in the oplog (the oplog offset) where this entry's value is +// * stored +// */ +// private volatile int offsetInOplog; +// // longOffset +// /** +// * The position in the oplog (the oplog offset) where this entry's value is +// * stored +// */ +// private volatile long offsetInOplog; +// // have overflowOnly or persistence +// // overflowOnly +// // no fields +// // persistent +// /** unique entry identifier * */ +// private long keyId; + + + + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // stats code @Override - public final void updateStatsForGet(boolean hit, long time) { + public final void updateStatsForGet(boolean hit, long time) + { setLastAccessed(time); if (hit) { incrementHitCount(); @@ -253,59 +304,51 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey incrementMissCount(); } } - @Override protected final void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) { _setLastModified(lastModified); - if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { setLastAccessed(lastAccessed); } } - private volatile long lastAccessed; private volatile int hitCount; private volatile int missCount; - private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapLongKey> hitCountUpdater = - AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapLongKey.class, - "hitCount"); - private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapLongKey> missCountUpdater = - AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapLongKey.class, - "missCount"); - + + private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapLongKey> hitCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapLongKey.class, "hitCount"); + private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapLongKey> missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapLongKey.class, "missCount"); + @Override public final long getLastAccessed() throws InternalStatisticsDisabledException { return this.lastAccessed; } - private void setLastAccessed(long lastAccessed) { this.lastAccessed = lastAccessed; } - @Override public final long getHitCount() throws InternalStatisticsDisabledException { return this.hitCount & 0xFFFFFFFFL; } - @Override public final long getMissCount() throws InternalStatisticsDisabledException { return this.missCount & 0xFFFFFFFFL; } - private void incrementHitCount() { hitCountUpdater.incrementAndGet(this); } - private void incrementMissCount() { missCountUpdater.incrementAndGet(this); } - @Override public final void resetCounts() throws InternalStatisticsDisabledException { - hitCountUpdater.set(this, 0); - missCountUpdater.set(this, 0); + hitCountUpdater.set(this,0); + missCountUpdater.set(this,0); } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override public final void txDidDestroy(long currTime) { setLastModified(currTime); @@ -313,13 +356,15 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey this.hitCount = 0; this.missCount = 0; } - @Override public boolean hasStats() { return true; } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // versioned code private VersionSource memberID; private short entryVersionLowBytes; @@ -331,15 +376,16 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey public int getEntryVersion() { return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF); } - + public long getRegionVersion() { - return (((long) regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); + return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); } - + + public long getVersionTimeStamp() { return getLastModified(); } - + public void setVersionTimeStamp(long time) { setLastModified(time); } @@ -347,17 +393,17 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey public VersionSource getMemberID() { return this.memberID; } - public int getDistributedSystemId() { return this.distributedSystemId; } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public void setVersions(VersionTag tag) { this.memberID = tag.getMemberID(); int eVersion = tag.getEntryVersion(); - this.entryVersionLowBytes = (short) (eVersion & 0xffff); - this.entryVersionHighByte = (byte) ((eVersion & 0xff0000) >> 16); + this.entryVersionLowBytes = (short)(eVersion & 0xffff); + this.entryVersionHighByte = (byte)((eVersion & 0xff0000) >> 16); this.regionVersionHighBytes = tag.getRegionVersionHighBytes(); this.regionVersionLowBytes = tag.getRegionVersionLowBytes(); if (!(tag.isGatewayTag()) && this.distributedSystemId == tag.getDistributedSystemId()) { @@ -369,11 +415,11 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey } else { setVersionTimeStamp(tag.getVersionTimeStamp()); } - this.distributedSystemId = (byte) (tag.getDistributedSystemId() & 0xff); + this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff); } public void setMemberID(VersionSource memberID) { - this.memberID = memberID; + this.memberID = memberID; } @Override @@ -382,6 +428,7 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public VersionTag asVersionTag() { VersionTag tag = VersionTag.create(memberID); tag.setEntryVersion(getEntryVersion()); @@ -391,9 +438,9 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey return tag; } - public void processVersionTag(LocalRegion r, VersionTag tag, boolean isTombstoneFromGII, - boolean hasDelta, VersionSource thisVM, InternalDistributedMember sender, - boolean checkForConflicts) { + public void processVersionTag(LocalRegion r, VersionTag tag, + boolean isTombstoneFromGII, boolean hasDelta, + VersionSource thisVM, InternalDistributedMember sender, boolean checkForConflicts) { basicProcessVersionTag(r, tag, isTombstoneFromGII, hasDelta, thisVM, sender, checkForConflicts); } @@ -408,21 +455,22 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey public short getRegionVersionHighBytes() { return this.regionVersionHighBytes; } - + /** get rvv internal low bytes. Used by region entries for transferring to storage */ public int getRegionVersionLowBytes() { return this.regionVersionLowBytes; } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code - private final long key; + private final long key; @Override public final Object getKey() { return this.key; } - @Override public boolean isKeyEqual(Object k) { if (k instanceof Long) { @@ -430,5 +478,8 @@ public class VersionedStatsDiskRegionEntryOffHeapLongKey } return false; } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp } +
http://git-wip-us.apache.org/repos/asf/geode/blob/d4f23332/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapObjectKey.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapObjectKey.java index 6afcd0d..46da7f9 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapObjectKey.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapObjectKey.java @@ -15,82 +15,119 @@ package org.apache.geode.internal.cache; // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + + + + + import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; + import java.util.concurrent.atomic.AtomicLongFieldUpdater; + import org.apache.geode.cache.EntryEvent; + + import org.apache.geode.internal.cache.lru.EnableLRU; + + import org.apache.geode.internal.cache.persistence.DiskRecoveryStore; + + import org.apache.geode.internal.InternalStatisticsDisabledException; + + + + + + import org.apache.geode.distributed.internal.membership.InternalDistributedMember; import org.apache.geode.internal.cache.versions.VersionSource; import org.apache.geode.internal.cache.versions.VersionStamp; import org.apache.geode.internal.cache.versions.VersionTag; + + import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper; import org.apache.geode.internal.offheap.annotations.Released; import org.apache.geode.internal.offheap.annotations.Retained; import org.apache.geode.internal.offheap.annotations.Unretained; + import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry; // macros whose definition changes this class: -// disk: DISK +// disk: 1 // lru: LRU -// stats: STATS -// versioned: VERSIONED -// offheap: OFFHEAP +// stats: 1 +// versioned: 1 +// offheap: 1 // One of the following key macros must be defined: -// key object: KEY_OBJECT +// key object: 1 // key int: KEY_INT // key long: KEY_LONG // key uuid: KEY_UUID // key string1: KEY_STRING1 // key string2: KEY_STRING2 + /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ -public class VersionedStatsDiskRegionEntryOffHeapObjectKey - extends VersionedStatsDiskRegionEntryOffHeap { - public VersionedStatsDiskRegionEntryOffHeapObjectKey(RegionEntryContext context, Object key, - @Retained Object value) { - super(context, (value instanceof RecoveredEntry ? null : value)); +public class VersionedStatsDiskRegionEntryOffHeapObjectKey extends VersionedStatsDiskRegionEntryOffHeap { + public VersionedStatsDiskRegionEntryOffHeapObjectKey (RegionEntryContext context, Object key, + + @Retained + + Object value + + + + ) { + super(context, + + (value instanceof RecoveredEntry ? null : value) + + + + ); // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + initialize(context, value); + + this.key = key; + } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // common code protected int hash; private HashEntry<Object, Object> next; @SuppressWarnings("unused") private volatile long lastModified; - private static final AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapObjectKey> lastModifiedUpdater = - AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapObjectKey.class, - "lastModified"); + private static final AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapObjectKey> lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapObjectKey.class, "lastModified"); + /** * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is. */ @SuppressWarnings("unused") - @Retained - @Released - private volatile long ohAddress; + @Retained @Released private volatile long ohAddress; /** - * I needed to add this because I wanted clear to call setValue which normally can only be called - * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the - * disk regions because they also get a rw lock in clear. Some hardware platforms do not support - * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the - * re and we will once again be deadlocked. I don't know if we support any of the hardware - * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions. + * I needed to add this because I wanted clear to call setValue which normally can only be called while the re is synced. + * But if I sync in that code it causes a lock ordering deadlock with the disk regions because they also get a rw lock in clear. + * Some hardware platforms do not support CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync + * on the re and we will once again be deadlocked. + * I don't know if we support any of the hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks + * on disk regions. */ - private final static AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapObjectKey> ohAddrUpdater = - AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapObjectKey.class, - "ohAddress"); - + private final static AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapObjectKey> ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapObjectKey.class, "ohAddress"); + @Override public Token getValueAsToken() { return OffHeapRegionEntryHelper.getValueAsToken(this); } - + @Override protected Object getValueField() { return OffHeapRegionEntryHelper._getValue(this); @@ -98,13 +135,18 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey // DO NOT modify this class. It was generated from LeafRegionEntry.cpp @Override + @Unretained protected void setValueField(@Unretained Object v) { + + + OffHeapRegionEntryHelper.setValue(this, v); } - @Override + @Retained + public Object _getValueRetain(RegionEntryContext context, boolean decompress) { return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context); } @@ -118,47 +160,44 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey public boolean setAddress(long expectedAddr, long newAddr) { return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr); } - + @Override + @Released + public void release() { OffHeapRegionEntryHelper.releaseEntry(this); } - + @Override public void returnToPool() { // Deadcoded for now; never was working - // if (this instanceof VMThinRegionEntryLongKey) { - // factory.returnToPool((VMThinRegionEntryLongKey)this); - // } +// if (this instanceof VMThinRegionEntryLongKey) { +// factory.returnToPool((VMThinRegionEntryLongKey)this); +// } } - protected long getlastModifiedField() { + protected long getLastModifiedField() { return lastModifiedUpdater.get(this); } - protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) { return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue); } - /** * @see HashEntry#getEntryHash() */ public final int getEntryHash() { return this.hash; } - protected void setEntryHash(int v) { this.hash = v; } - /** * @see HashEntry#getNextEntry() */ public final HashEntry<Object, Object> getNextEntry() { return this.next; } - /** * @see HashEntry#setNextEntry */ @@ -166,23 +205,27 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey this.next = n; } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // disk code + protected void initialize(RegionEntryContext context, Object value) { diskInitialize(context, value); } - @Override public int updateAsyncEntrySize(EnableLRU capacityController) { throw new IllegalStateException("should never be called"); } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + private void diskInitialize(RegionEntryContext context, Object value) { - DiskRecoveryStore drs = (DiskRecoveryStore) context; + DiskRecoveryStore drs = (DiskRecoveryStore)context; DiskStoreImpl ds = drs.getDiskStore(); long maxOplogSize = ds.getMaxOplogSize(); - // get appropriate instance of DiskId implementation based on maxOplogSize + //get appropriate instance of DiskId implementation based on maxOplogSize this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList()); Helper.initialize(this, drs, value); } @@ -192,60 +235,64 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey * * @since GemFire 5.1 */ - protected DiskId id;// = new DiskId(); - + protected DiskId id;//= new DiskId(); public DiskId getDiskId() { return this.id; } - @Override void setDiskId(RegionEntry old) { - this.id = ((AbstractDiskRegionEntry) old).getDiskId(); - } - - // // inlining DiskId - // // always have these fields - // /** - // * id consists of - // * most significant - // * 1 byte = users bits - // * 2-8 bytes = oplog id - // * least significant. - // * - // * The highest bit in the oplog id part is set to 1 if the oplog id - // * is negative. - // * @todo this field could be an int for an overflow only region - // */ - // private long id; - // /** - // * Length of the bytes on disk. - // * This is always set. If the value is invalid then it will be set to 0. - // * The most significant bit is used by overflow to mark it as needing to be written. - // */ - // protected int valueLength = 0; - // // have intOffset or longOffset - // // intOffset - // /** - // * The position in the oplog (the oplog offset) where this entry's value is - // * stored - // */ - // private volatile int offsetInOplog; - // // longOffset - // /** - // * The position in the oplog (the oplog offset) where this entry's value is - // * stored - // */ - // private volatile long offsetInOplog; - // // have overflowOnly or persistence - // // overflowOnly - // // no fields - // // persistent - // /** unique entry identifier * */ - // private long keyId; + this.id = ((AbstractDiskRegionEntry)old).getDiskId(); + } +// // inlining DiskId +// // always have these fields +// /** +// * id consists of +// * most significant +// * 1 byte = users bits +// * 2-8 bytes = oplog id +// * least significant. +// * +// * The highest bit in the oplog id part is set to 1 if the oplog id +// * is negative. +// * @todo this field could be an int for an overflow only region +// */ +// private long id; +// /** +// * Length of the bytes on disk. +// * This is always set. If the value is invalid then it will be set to 0. +// * The most significant bit is used by overflow to mark it as needing to be written. +// */ +// protected int valueLength = 0; +// // have intOffset or longOffset +// // intOffset +// /** +// * The position in the oplog (the oplog offset) where this entry's value is +// * stored +// */ +// private volatile int offsetInOplog; +// // longOffset +// /** +// * The position in the oplog (the oplog offset) where this entry's value is +// * stored +// */ +// private volatile long offsetInOplog; +// // have overflowOnly or persistence +// // overflowOnly +// // no fields +// // persistent +// /** unique entry identifier * */ +// private long keyId; + + + + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // stats code @Override - public final void updateStatsForGet(boolean hit, long time) { + public final void updateStatsForGet(boolean hit, long time) + { setLastAccessed(time); if (hit) { incrementHitCount(); @@ -253,59 +300,51 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey incrementMissCount(); } } - @Override protected final void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) { _setLastModified(lastModified); - if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { setLastAccessed(lastAccessed); } } - private volatile long lastAccessed; private volatile int hitCount; private volatile int missCount; - private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapObjectKey> hitCountUpdater = - AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapObjectKey.class, - "hitCount"); - private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapObjectKey> missCountUpdater = - AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapObjectKey.class, - "missCount"); - + + private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapObjectKey> hitCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapObjectKey.class, "hitCount"); + private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapObjectKey> missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapObjectKey.class, "missCount"); + @Override public final long getLastAccessed() throws InternalStatisticsDisabledException { return this.lastAccessed; } - private void setLastAccessed(long lastAccessed) { this.lastAccessed = lastAccessed; } - @Override public final long getHitCount() throws InternalStatisticsDisabledException { return this.hitCount & 0xFFFFFFFFL; } - @Override public final long getMissCount() throws InternalStatisticsDisabledException { return this.missCount & 0xFFFFFFFFL; } - private void incrementHitCount() { hitCountUpdater.incrementAndGet(this); } - private void incrementMissCount() { missCountUpdater.incrementAndGet(this); } - @Override public final void resetCounts() throws InternalStatisticsDisabledException { - hitCountUpdater.set(this, 0); - missCountUpdater.set(this, 0); + hitCountUpdater.set(this,0); + missCountUpdater.set(this,0); } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override public final void txDidDestroy(long currTime) { setLastModified(currTime); @@ -313,13 +352,15 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey this.hitCount = 0; this.missCount = 0; } - @Override public boolean hasStats() { return true; } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // versioned code private VersionSource memberID; private short entryVersionLowBytes; @@ -331,15 +372,16 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey public int getEntryVersion() { return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF); } - + public long getRegionVersion() { - return (((long) regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); + return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); } - + + public long getVersionTimeStamp() { return getLastModified(); } - + public void setVersionTimeStamp(long time) { setLastModified(time); } @@ -347,17 +389,17 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey public VersionSource getMemberID() { return this.memberID; } - public int getDistributedSystemId() { return this.distributedSystemId; } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public void setVersions(VersionTag tag) { this.memberID = tag.getMemberID(); int eVersion = tag.getEntryVersion(); - this.entryVersionLowBytes = (short) (eVersion & 0xffff); - this.entryVersionHighByte = (byte) ((eVersion & 0xff0000) >> 16); + this.entryVersionLowBytes = (short)(eVersion & 0xffff); + this.entryVersionHighByte = (byte)((eVersion & 0xff0000) >> 16); this.regionVersionHighBytes = tag.getRegionVersionHighBytes(); this.regionVersionLowBytes = tag.getRegionVersionLowBytes(); if (!(tag.isGatewayTag()) && this.distributedSystemId == tag.getDistributedSystemId()) { @@ -369,11 +411,11 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey } else { setVersionTimeStamp(tag.getVersionTimeStamp()); } - this.distributedSystemId = (byte) (tag.getDistributedSystemId() & 0xff); + this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff); } public void setMemberID(VersionSource memberID) { - this.memberID = memberID; + this.memberID = memberID; } @Override @@ -382,6 +424,7 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public VersionTag asVersionTag() { VersionTag tag = VersionTag.create(memberID); tag.setEntryVersion(getEntryVersion()); @@ -391,9 +434,9 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey return tag; } - public void processVersionTag(LocalRegion r, VersionTag tag, boolean isTombstoneFromGII, - boolean hasDelta, VersionSource thisVM, InternalDistributedMember sender, - boolean checkForConflicts) { + public void processVersionTag(LocalRegion r, VersionTag tag, + boolean isTombstoneFromGII, boolean hasDelta, + VersionSource thisVM, InternalDistributedMember sender, boolean checkForConflicts) { basicProcessVersionTag(r, tag, isTombstoneFromGII, hasDelta, thisVM, sender, checkForConflicts); } @@ -408,19 +451,24 @@ public class VersionedStatsDiskRegionEntryOffHeapObjectKey public short getRegionVersionHighBytes() { return this.regionVersionHighBytes; } - + /** get rvv internal low bytes. Used by region entries for transferring to storage */ public int getRegionVersionLowBytes() { return this.regionVersionLowBytes; } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code - private final Object key; + private final Object key; @Override public final Object getKey() { return this.key; } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp } + http://git-wip-us.apache.org/repos/asf/geode/blob/d4f23332/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey1.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey1.java index 3f5e15d..e0c8d38 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey1.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey1.java @@ -15,99 +15,134 @@ package org.apache.geode.internal.cache; // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + + + + + import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; + import java.util.concurrent.atomic.AtomicLongFieldUpdater; + import org.apache.geode.cache.EntryEvent; + + import org.apache.geode.internal.cache.lru.EnableLRU; + + import org.apache.geode.internal.cache.persistence.DiskRecoveryStore; + + import org.apache.geode.internal.InternalStatisticsDisabledException; + + + + + + import org.apache.geode.distributed.internal.membership.InternalDistributedMember; import org.apache.geode.internal.cache.versions.VersionSource; import org.apache.geode.internal.cache.versions.VersionStamp; import org.apache.geode.internal.cache.versions.VersionTag; + + import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper; import org.apache.geode.internal.offheap.annotations.Released; import org.apache.geode.internal.offheap.annotations.Retained; import org.apache.geode.internal.offheap.annotations.Unretained; + import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry; // macros whose definition changes this class: -// disk: DISK +// disk: 1 // lru: LRU -// stats: STATS -// versioned: VERSIONED -// offheap: OFFHEAP +// stats: 1 +// versioned: 1 +// offheap: 1 // One of the following key macros must be defined: // key object: KEY_OBJECT // key int: KEY_INT // key long: KEY_LONG // key uuid: KEY_UUID -// key string1: KEY_STRING1 +// key string1: 1 // key string2: KEY_STRING2 + /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ -public class VersionedStatsDiskRegionEntryOffHeapStringKey1 - extends VersionedStatsDiskRegionEntryOffHeap { - public VersionedStatsDiskRegionEntryOffHeapStringKey1(RegionEntryContext context, String key, - @Retained Object value, boolean byteEncode) { - super(context, (value instanceof RecoveredEntry ? null : value)); +public class VersionedStatsDiskRegionEntryOffHeapStringKey1 extends VersionedStatsDiskRegionEntryOffHeap { + public VersionedStatsDiskRegionEntryOffHeapStringKey1 (RegionEntryContext context, String key, + + @Retained + + Object value + + , boolean byteEncode + + ) { + super(context, + + (value instanceof RecoveredEntry ? null : value) + + + + ); // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + initialize(context, value); + // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY long tmpBits1 = 0L; if (byteEncode) { - for (int i = key.length() - 1; i >= 0; i--) { - // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to - // keep findbugs happy. - tmpBits1 |= (byte) key.charAt(i) & 0xff; + for (int i=key.length()-1; i >= 0; i--) { + // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to keep findbugs happy. + tmpBits1 |= (byte)key.charAt(i) & 0xff; tmpBits1 <<= 8; } - tmpBits1 |= 1 << 6; + tmpBits1 |= 1<<6; } else { - for (int i = key.length() - 1; i >= 0; i--) { + for (int i=key.length()-1; i >= 0; i--) { tmpBits1 |= key.charAt(i); tmpBits1 <<= 16; } } tmpBits1 |= key.length(); this.bits1 = tmpBits1; + } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // common code protected int hash; private HashEntry<Object, Object> next; @SuppressWarnings("unused") private volatile long lastModified; - private static final AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey1> lastModifiedUpdater = - AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey1.class, - "lastModified"); + private static final AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey1> lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey1.class, "lastModified"); + /** * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is. */ @SuppressWarnings("unused") - @Retained - @Released - private volatile long ohAddress; + @Retained @Released private volatile long ohAddress; /** - * I needed to add this because I wanted clear to call setValue which normally can only be called - * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the - * disk regions because they also get a rw lock in clear. Some hardware platforms do not support - * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the - * re and we will once again be deadlocked. I don't know if we support any of the hardware - * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions. + * I needed to add this because I wanted clear to call setValue which normally can only be called while the re is synced. + * But if I sync in that code it causes a lock ordering deadlock with the disk regions because they also get a rw lock in clear. + * Some hardware platforms do not support CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync + * on the re and we will once again be deadlocked. + * I don't know if we support any of the hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks + * on disk regions. */ - private final static AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey1> ohAddrUpdater = - AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey1.class, - "ohAddress"); - + private final static AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey1> ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey1.class, "ohAddress"); + @Override public Token getValueAsToken() { return OffHeapRegionEntryHelper.getValueAsToken(this); } - + @Override protected Object getValueField() { return OffHeapRegionEntryHelper._getValue(this); @@ -115,13 +150,18 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 // DO NOT modify this class. It was generated from LeafRegionEntry.cpp @Override + @Unretained protected void setValueField(@Unretained Object v) { + + + OffHeapRegionEntryHelper.setValue(this, v); } - @Override + @Retained + public Object _getValueRetain(RegionEntryContext context, boolean decompress) { return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context); } @@ -135,47 +175,44 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 public boolean setAddress(long expectedAddr, long newAddr) { return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr); } - + @Override + @Released + public void release() { OffHeapRegionEntryHelper.releaseEntry(this); } - + @Override public void returnToPool() { // Deadcoded for now; never was working - // if (this instanceof VMThinRegionEntryLongKey) { - // factory.returnToPool((VMThinRegionEntryLongKey)this); - // } +// if (this instanceof VMThinRegionEntryLongKey) { +// factory.returnToPool((VMThinRegionEntryLongKey)this); +// } } - protected long getlastModifiedField() { + protected long getLastModifiedField() { return lastModifiedUpdater.get(this); } - protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) { return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue); } - /** * @see HashEntry#getEntryHash() */ public final int getEntryHash() { return this.hash; } - protected void setEntryHash(int v) { this.hash = v; } - /** * @see HashEntry#getNextEntry() */ public final HashEntry<Object, Object> getNextEntry() { return this.next; } - /** * @see HashEntry#setNextEntry */ @@ -183,23 +220,27 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 this.next = n; } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // disk code + protected void initialize(RegionEntryContext context, Object value) { diskInitialize(context, value); } - @Override public int updateAsyncEntrySize(EnableLRU capacityController) { throw new IllegalStateException("should never be called"); } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + private void diskInitialize(RegionEntryContext context, Object value) { - DiskRecoveryStore drs = (DiskRecoveryStore) context; + DiskRecoveryStore drs = (DiskRecoveryStore)context; DiskStoreImpl ds = drs.getDiskStore(); long maxOplogSize = ds.getMaxOplogSize(); - // get appropriate instance of DiskId implementation based on maxOplogSize + //get appropriate instance of DiskId implementation based on maxOplogSize this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList()); Helper.initialize(this, drs, value); } @@ -209,60 +250,64 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 * * @since GemFire 5.1 */ - protected DiskId id;// = new DiskId(); - + protected DiskId id;//= new DiskId(); public DiskId getDiskId() { return this.id; } - @Override void setDiskId(RegionEntry old) { - this.id = ((AbstractDiskRegionEntry) old).getDiskId(); - } - - // // inlining DiskId - // // always have these fields - // /** - // * id consists of - // * most significant - // * 1 byte = users bits - // * 2-8 bytes = oplog id - // * least significant. - // * - // * The highest bit in the oplog id part is set to 1 if the oplog id - // * is negative. - // * @todo this field could be an int for an overflow only region - // */ - // private long id; - // /** - // * Length of the bytes on disk. - // * This is always set. If the value is invalid then it will be set to 0. - // * The most significant bit is used by overflow to mark it as needing to be written. - // */ - // protected int valueLength = 0; - // // have intOffset or longOffset - // // intOffset - // /** - // * The position in the oplog (the oplog offset) where this entry's value is - // * stored - // */ - // private volatile int offsetInOplog; - // // longOffset - // /** - // * The position in the oplog (the oplog offset) where this entry's value is - // * stored - // */ - // private volatile long offsetInOplog; - // // have overflowOnly or persistence - // // overflowOnly - // // no fields - // // persistent - // /** unique entry identifier * */ - // private long keyId; + this.id = ((AbstractDiskRegionEntry)old).getDiskId(); + } +// // inlining DiskId +// // always have these fields +// /** +// * id consists of +// * most significant +// * 1 byte = users bits +// * 2-8 bytes = oplog id +// * least significant. +// * +// * The highest bit in the oplog id part is set to 1 if the oplog id +// * is negative. +// * @todo this field could be an int for an overflow only region +// */ +// private long id; +// /** +// * Length of the bytes on disk. +// * This is always set. If the value is invalid then it will be set to 0. +// * The most significant bit is used by overflow to mark it as needing to be written. +// */ +// protected int valueLength = 0; +// // have intOffset or longOffset +// // intOffset +// /** +// * The position in the oplog (the oplog offset) where this entry's value is +// * stored +// */ +// private volatile int offsetInOplog; +// // longOffset +// /** +// * The position in the oplog (the oplog offset) where this entry's value is +// * stored +// */ +// private volatile long offsetInOplog; +// // have overflowOnly or persistence +// // overflowOnly +// // no fields +// // persistent +// /** unique entry identifier * */ +// private long keyId; + + + + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // stats code @Override - public final void updateStatsForGet(boolean hit, long time) { + public final void updateStatsForGet(boolean hit, long time) + { setLastAccessed(time); if (hit) { incrementHitCount(); @@ -270,59 +315,51 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 incrementMissCount(); } } - @Override protected final void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) { _setLastModified(lastModified); - if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { setLastAccessed(lastAccessed); } } - private volatile long lastAccessed; private volatile int hitCount; private volatile int missCount; - private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey1> hitCountUpdater = - AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey1.class, - "hitCount"); - private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey1> missCountUpdater = - AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey1.class, - "missCount"); - + + private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey1> hitCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey1.class, "hitCount"); + private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey1> missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey1.class, "missCount"); + @Override public final long getLastAccessed() throws InternalStatisticsDisabledException { return this.lastAccessed; } - private void setLastAccessed(long lastAccessed) { this.lastAccessed = lastAccessed; } - @Override public final long getHitCount() throws InternalStatisticsDisabledException { return this.hitCount & 0xFFFFFFFFL; } - @Override public final long getMissCount() throws InternalStatisticsDisabledException { return this.missCount & 0xFFFFFFFFL; } - private void incrementHitCount() { hitCountUpdater.incrementAndGet(this); } - private void incrementMissCount() { missCountUpdater.incrementAndGet(this); } - @Override public final void resetCounts() throws InternalStatisticsDisabledException { - hitCountUpdater.set(this, 0); - missCountUpdater.set(this, 0); + hitCountUpdater.set(this,0); + missCountUpdater.set(this,0); } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override public final void txDidDestroy(long currTime) { setLastModified(currTime); @@ -330,13 +367,15 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 this.hitCount = 0; this.missCount = 0; } - @Override public boolean hasStats() { return true; } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // versioned code private VersionSource memberID; private short entryVersionLowBytes; @@ -348,15 +387,16 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 public int getEntryVersion() { return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF); } - + public long getRegionVersion() { - return (((long) regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); + return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); } - + + public long getVersionTimeStamp() { return getLastModified(); } - + public void setVersionTimeStamp(long time) { setLastModified(time); } @@ -364,17 +404,17 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 public VersionSource getMemberID() { return this.memberID; } - public int getDistributedSystemId() { return this.distributedSystemId; } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public void setVersions(VersionTag tag) { this.memberID = tag.getMemberID(); int eVersion = tag.getEntryVersion(); - this.entryVersionLowBytes = (short) (eVersion & 0xffff); - this.entryVersionHighByte = (byte) ((eVersion & 0xff0000) >> 16); + this.entryVersionLowBytes = (short)(eVersion & 0xffff); + this.entryVersionHighByte = (byte)((eVersion & 0xff0000) >> 16); this.regionVersionHighBytes = tag.getRegionVersionHighBytes(); this.regionVersionLowBytes = tag.getRegionVersionLowBytes(); if (!(tag.isGatewayTag()) && this.distributedSystemId == tag.getDistributedSystemId()) { @@ -386,11 +426,11 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 } else { setVersionTimeStamp(tag.getVersionTimeStamp()); } - this.distributedSystemId = (byte) (tag.getDistributedSystemId() & 0xff); + this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff); } public void setMemberID(VersionSource memberID) { - this.memberID = memberID; + this.memberID = memberID; } @Override @@ -399,6 +439,7 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public VersionTag asVersionTag() { VersionTag tag = VersionTag.create(memberID); tag.setEntryVersion(getEntryVersion()); @@ -408,9 +449,9 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 return tag; } - public void processVersionTag(LocalRegion r, VersionTag tag, boolean isTombstoneFromGII, - boolean hasDelta, VersionSource thisVM, InternalDistributedMember sender, - boolean checkForConflicts) { + public void processVersionTag(LocalRegion r, VersionTag tag, + boolean isTombstoneFromGII, boolean hasDelta, + VersionSource thisVM, InternalDistributedMember sender, boolean checkForConflicts) { basicProcessVersionTag(r, tag, isTombstoneFromGII, hasDelta, thisVM, sender, checkForConflicts); } @@ -425,38 +466,38 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 public short getRegionVersionHighBytes() { return this.regionVersionHighBytes; } - + /** get rvv internal low bytes. Used by region entries for transferring to storage */ public int getRegionVersionLowBytes() { return this.regionVersionLowBytes; } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code - private final long bits1; + private final long bits1; private int getKeyLength() { return (int) (this.bits1 & 0x003fL); } - private int getEncoding() { // 0 means encoded as char // 1 means encoded as bytes that are all <= 0x7f; return (int) (this.bits1 >> 6) & 0x03; } - @Override public final Object getKey() { int keylen = getKeyLength(); char[] chars = new char[keylen]; long tmpBits1 = this.bits1; if (getEncoding() == 1) { - for (int i = 0; i < keylen; i++) { + for (int i=0; i < keylen; i++) { tmpBits1 >>= 8; - chars[i] = (char) (tmpBits1 & 0x00ff); + chars[i] = (char) (tmpBits1 & 0x00ff); } } else { - for (int i = 0; i < keylen; i++) { + for (int i=0; i < keylen; i++) { tmpBits1 >>= 16; chars[i] = (char) (tmpBits1 & 0x00FFff); } @@ -465,15 +506,16 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override public boolean isKeyEqual(Object k) { if (k instanceof String) { - String str = (String) k; + String str = (String)k; int keylen = getKeyLength(); if (str.length() == keylen) { long tmpBits1 = this.bits1; if (getEncoding() == 1) { - for (int i = 0; i < keylen; i++) { + for (int i=0; i < keylen; i++) { tmpBits1 >>= 8; char c = (char) (tmpBits1 & 0x00ff); if (str.charAt(i) != c) { @@ -481,7 +523,7 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 } } } else { - for (int i = 0; i < keylen; i++) { + for (int i=0; i < keylen; i++) { tmpBits1 >>= 16; char c = (char) (tmpBits1 & 0x00FFff); if (str.charAt(i) != c) { @@ -494,5 +536,8 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey1 } return false; } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp } + http://git-wip-us.apache.org/repos/asf/geode/blob/d4f23332/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey2.java b/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey2.java index 8030f4a..2d1cc3c 100644 --- a/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey2.java +++ b/geode-core/src/main/java/org/apache/geode/internal/cache/VersionedStatsDiskRegionEntryOffHeapStringKey2.java @@ -15,64 +15,101 @@ package org.apache.geode.internal.cache; // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + + + + + + import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; + import java.util.concurrent.atomic.AtomicLongFieldUpdater; + import org.apache.geode.cache.EntryEvent; + + import org.apache.geode.internal.cache.lru.EnableLRU; + + import org.apache.geode.internal.cache.persistence.DiskRecoveryStore; + + import org.apache.geode.internal.InternalStatisticsDisabledException; + + + + + + import org.apache.geode.distributed.internal.membership.InternalDistributedMember; import org.apache.geode.internal.cache.versions.VersionSource; import org.apache.geode.internal.cache.versions.VersionStamp; import org.apache.geode.internal.cache.versions.VersionTag; + + import org.apache.geode.internal.offheap.OffHeapRegionEntryHelper; import org.apache.geode.internal.offheap.annotations.Released; import org.apache.geode.internal.offheap.annotations.Retained; import org.apache.geode.internal.offheap.annotations.Unretained; + import org.apache.geode.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry; // macros whose definition changes this class: -// disk: DISK +// disk: 1 // lru: LRU -// stats: STATS -// versioned: VERSIONED -// offheap: OFFHEAP +// stats: 1 +// versioned: 1 +// offheap: 1 // One of the following key macros must be defined: // key object: KEY_OBJECT // key int: KEY_INT // key long: KEY_LONG // key uuid: KEY_UUID // key string1: KEY_STRING1 -// key string2: KEY_STRING2 +// key string2: 1 + /** * Do not modify this class. It was generated. Instead modify LeafRegionEntry.cpp and then run * ./dev-tools/generateRegionEntryClasses.sh (it must be run from the top level directory). */ -public class VersionedStatsDiskRegionEntryOffHeapStringKey2 - extends VersionedStatsDiskRegionEntryOffHeap { - public VersionedStatsDiskRegionEntryOffHeapStringKey2(RegionEntryContext context, String key, - @Retained Object value, boolean byteEncode) { - super(context, (value instanceof RecoveredEntry ? null : value)); +public class VersionedStatsDiskRegionEntryOffHeapStringKey2 extends VersionedStatsDiskRegionEntryOffHeap { + public VersionedStatsDiskRegionEntryOffHeapStringKey2 (RegionEntryContext context, String key, + + @Retained + + Object value + + , boolean byteEncode + + ) { + super(context, + + (value instanceof RecoveredEntry ? null : value) + + + + ); // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + initialize(context, value); + // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY long tmpBits1 = 0L; long tmpBits2 = 0L; if (byteEncode) { - for (int i = key.length() - 1; i >= 0; i--) { - // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to - // keep findbugs happy. + for (int i=key.length()-1; i >= 0; i--) { + // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to keep findbugs happy. if (i < 7) { - tmpBits1 |= (byte) key.charAt(i) & 0xff; + tmpBits1 |= (byte)key.charAt(i) & 0xff; tmpBits1 <<= 8; } else { tmpBits2 <<= 8; - tmpBits2 |= (byte) key.charAt(i) & 0xff; + tmpBits2 |= (byte)key.charAt(i) & 0xff; } } - tmpBits1 |= 1 << 6; + tmpBits1 |= 1<<6; } else { - for (int i = key.length() - 1; i >= 0; i--) { + for (int i=key.length()-1; i >= 0; i--) { if (i < 3) { tmpBits1 |= key.charAt(i); tmpBits1 <<= 16; @@ -85,41 +122,39 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 tmpBits1 |= key.length(); this.bits1 = tmpBits1; this.bits2 = tmpBits2; + } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // common code protected int hash; private HashEntry<Object, Object> next; @SuppressWarnings("unused") private volatile long lastModified; - private static final AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey2> lastModifiedUpdater = - AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey2.class, - "lastModified"); + private static final AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey2> lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey2.class, "lastModified"); + /** * All access done using ohAddrUpdater so it is used even though the compiler can not tell it is. */ @SuppressWarnings("unused") - @Retained - @Released - private volatile long ohAddress; + @Retained @Released private volatile long ohAddress; /** - * I needed to add this because I wanted clear to call setValue which normally can only be called - * while the re is synced. But if I sync in that code it causes a lock ordering deadlock with the - * disk regions because they also get a rw lock in clear. Some hardware platforms do not support - * CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync on the - * re and we will once again be deadlocked. I don't know if we support any of the hardware - * platforms that do not have a 64bit CAS. If we do then we can expect deadlocks on disk regions. + * I needed to add this because I wanted clear to call setValue which normally can only be called while the re is synced. + * But if I sync in that code it causes a lock ordering deadlock with the disk regions because they also get a rw lock in clear. + * Some hardware platforms do not support CAS on a long. If gemfire is run on one of those the AtomicLongFieldUpdater does a sync + * on the re and we will once again be deadlocked. + * I don't know if we support any of the hardware platforms that do not have a 64bit CAS. If we do then we can expect deadlocks + * on disk regions. */ - private final static AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey2> ohAddrUpdater = - AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey2.class, - "ohAddress"); - + private final static AtomicLongFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey2> ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey2.class, "ohAddress"); + @Override public Token getValueAsToken() { return OffHeapRegionEntryHelper.getValueAsToken(this); } - + @Override protected Object getValueField() { return OffHeapRegionEntryHelper._getValue(this); @@ -127,13 +162,18 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 // DO NOT modify this class. It was generated from LeafRegionEntry.cpp @Override + @Unretained protected void setValueField(@Unretained Object v) { + + + OffHeapRegionEntryHelper.setValue(this, v); } - @Override + @Retained + public Object _getValueRetain(RegionEntryContext context, boolean decompress) { return OffHeapRegionEntryHelper._getValueRetain(this, decompress, context); } @@ -147,47 +187,44 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 public boolean setAddress(long expectedAddr, long newAddr) { return ohAddrUpdater.compareAndSet(this, expectedAddr, newAddr); } - + @Override + @Released + public void release() { OffHeapRegionEntryHelper.releaseEntry(this); } - + @Override public void returnToPool() { // Deadcoded for now; never was working - // if (this instanceof VMThinRegionEntryLongKey) { - // factory.returnToPool((VMThinRegionEntryLongKey)this); - // } +// if (this instanceof VMThinRegionEntryLongKey) { +// factory.returnToPool((VMThinRegionEntryLongKey)this); +// } } - protected long getlastModifiedField() { + protected long getLastModifiedField() { return lastModifiedUpdater.get(this); } - protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) { return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue); } - /** * @see HashEntry#getEntryHash() */ public final int getEntryHash() { return this.hash; } - protected void setEntryHash(int v) { this.hash = v; } - /** * @see HashEntry#getNextEntry() */ public final HashEntry<Object, Object> getNextEntry() { return this.next; } - /** * @see HashEntry#setNextEntry */ @@ -195,23 +232,27 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 this.next = n; } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // disk code + protected void initialize(RegionEntryContext context, Object value) { diskInitialize(context, value); } - @Override public int updateAsyncEntrySize(EnableLRU capacityController) { throw new IllegalStateException("should never be called"); } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + private void diskInitialize(RegionEntryContext context, Object value) { - DiskRecoveryStore drs = (DiskRecoveryStore) context; + DiskRecoveryStore drs = (DiskRecoveryStore)context; DiskStoreImpl ds = drs.getDiskStore(); long maxOplogSize = ds.getMaxOplogSize(); - // get appropriate instance of DiskId implementation based on maxOplogSize + //get appropriate instance of DiskId implementation based on maxOplogSize this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList()); Helper.initialize(this, drs, value); } @@ -221,60 +262,64 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 * * @since GemFire 5.1 */ - protected DiskId id;// = new DiskId(); - + protected DiskId id;//= new DiskId(); public DiskId getDiskId() { return this.id; } - @Override void setDiskId(RegionEntry old) { - this.id = ((AbstractDiskRegionEntry) old).getDiskId(); - } - - // // inlining DiskId - // // always have these fields - // /** - // * id consists of - // * most significant - // * 1 byte = users bits - // * 2-8 bytes = oplog id - // * least significant. - // * - // * The highest bit in the oplog id part is set to 1 if the oplog id - // * is negative. - // * @todo this field could be an int for an overflow only region - // */ - // private long id; - // /** - // * Length of the bytes on disk. - // * This is always set. If the value is invalid then it will be set to 0. - // * The most significant bit is used by overflow to mark it as needing to be written. - // */ - // protected int valueLength = 0; - // // have intOffset or longOffset - // // intOffset - // /** - // * The position in the oplog (the oplog offset) where this entry's value is - // * stored - // */ - // private volatile int offsetInOplog; - // // longOffset - // /** - // * The position in the oplog (the oplog offset) where this entry's value is - // * stored - // */ - // private volatile long offsetInOplog; - // // have overflowOnly or persistence - // // overflowOnly - // // no fields - // // persistent - // /** unique entry identifier * */ - // private long keyId; + this.id = ((AbstractDiskRegionEntry)old).getDiskId(); + } +// // inlining DiskId +// // always have these fields +// /** +// * id consists of +// * most significant +// * 1 byte = users bits +// * 2-8 bytes = oplog id +// * least significant. +// * +// * The highest bit in the oplog id part is set to 1 if the oplog id +// * is negative. +// * @todo this field could be an int for an overflow only region +// */ +// private long id; +// /** +// * Length of the bytes on disk. +// * This is always set. If the value is invalid then it will be set to 0. +// * The most significant bit is used by overflow to mark it as needing to be written. +// */ +// protected int valueLength = 0; +// // have intOffset or longOffset +// // intOffset +// /** +// * The position in the oplog (the oplog offset) where this entry's value is +// * stored +// */ +// private volatile int offsetInOplog; +// // longOffset +// /** +// * The position in the oplog (the oplog offset) where this entry's value is +// * stored +// */ +// private volatile long offsetInOplog; +// // have overflowOnly or persistence +// // overflowOnly +// // no fields +// // persistent +// /** unique entry identifier * */ +// private long keyId; + + + + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // stats code @Override - public final void updateStatsForGet(boolean hit, long time) { + public final void updateStatsForGet(boolean hit, long time) + { setLastAccessed(time); if (hit) { incrementHitCount(); @@ -282,59 +327,51 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 incrementMissCount(); } } - @Override protected final void setLastModifiedAndAccessedTimes(long lastModified, long lastAccessed) { _setLastModified(lastModified); - if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { setLastAccessed(lastAccessed); } } - private volatile long lastAccessed; private volatile int hitCount; private volatile int missCount; - private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey2> hitCountUpdater = - AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey2.class, - "hitCount"); - private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey2> missCountUpdater = - AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey2.class, - "missCount"); - + + private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey2> hitCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey2.class, "hitCount"); + private static final AtomicIntegerFieldUpdater<VersionedStatsDiskRegionEntryOffHeapStringKey2> missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VersionedStatsDiskRegionEntryOffHeapStringKey2.class, "missCount"); + @Override public final long getLastAccessed() throws InternalStatisticsDisabledException { return this.lastAccessed; } - private void setLastAccessed(long lastAccessed) { this.lastAccessed = lastAccessed; } - @Override public final long getHitCount() throws InternalStatisticsDisabledException { return this.hitCount & 0xFFFFFFFFL; } - @Override public final long getMissCount() throws InternalStatisticsDisabledException { return this.missCount & 0xFFFFFFFFL; } - private void incrementHitCount() { hitCountUpdater.incrementAndGet(this); } - private void incrementMissCount() { missCountUpdater.incrementAndGet(this); } - @Override public final void resetCounts() throws InternalStatisticsDisabledException { - hitCountUpdater.set(this, 0); - missCountUpdater.set(this, 0); + hitCountUpdater.set(this,0); + missCountUpdater.set(this,0); } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override public final void txDidDestroy(long currTime) { setLastModified(currTime); @@ -342,13 +379,15 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 this.hitCount = 0; this.missCount = 0; } - @Override public boolean hasStats() { return true; } + + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // versioned code private VersionSource memberID; private short entryVersionLowBytes; @@ -360,15 +399,16 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 public int getEntryVersion() { return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF); } - + public long getRegionVersion() { - return (((long) regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); + return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); } - + + public long getVersionTimeStamp() { return getLastModified(); } - + public void setVersionTimeStamp(long time) { setLastModified(time); } @@ -376,17 +416,17 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 public VersionSource getMemberID() { return this.memberID; } - public int getDistributedSystemId() { return this.distributedSystemId; } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public void setVersions(VersionTag tag) { this.memberID = tag.getMemberID(); int eVersion = tag.getEntryVersion(); - this.entryVersionLowBytes = (short) (eVersion & 0xffff); - this.entryVersionHighByte = (byte) ((eVersion & 0xff0000) >> 16); + this.entryVersionLowBytes = (short)(eVersion & 0xffff); + this.entryVersionHighByte = (byte)((eVersion & 0xff0000) >> 16); this.regionVersionHighBytes = tag.getRegionVersionHighBytes(); this.regionVersionLowBytes = tag.getRegionVersionLowBytes(); if (!(tag.isGatewayTag()) && this.distributedSystemId == tag.getDistributedSystemId()) { @@ -398,11 +438,11 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 } else { setVersionTimeStamp(tag.getVersionTimeStamp()); } - this.distributedSystemId = (byte) (tag.getDistributedSystemId() & 0xff); + this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff); } public void setMemberID(VersionSource memberID) { - this.memberID = memberID; + this.memberID = memberID; } @Override @@ -411,6 +451,7 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public VersionTag asVersionTag() { VersionTag tag = VersionTag.create(memberID); tag.setEntryVersion(getEntryVersion()); @@ -420,9 +461,9 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 return tag; } - public void processVersionTag(LocalRegion r, VersionTag tag, boolean isTombstoneFromGII, - boolean hasDelta, VersionSource thisVM, InternalDistributedMember sender, - boolean checkForConflicts) { + public void processVersionTag(LocalRegion r, VersionTag tag, + boolean isTombstoneFromGII, boolean hasDelta, + VersionSource thisVM, InternalDistributedMember sender, boolean checkForConflicts) { basicProcessVersionTag(r, tag, isTombstoneFromGII, hasDelta, thisVM, sender, checkForConflicts); } @@ -437,31 +478,31 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 public short getRegionVersionHighBytes() { return this.regionVersionHighBytes; } - + /** get rvv internal low bytes. Used by region entries for transferring to storage */ public int getRegionVersionLowBytes() { return this.regionVersionLowBytes; } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code + // strlen is encoded in lowest 6 bits (max strlen is 63) // character encoding info is in bits 7 and 8 // The other bits are used to encoded character data. private final long bits1; // bits2 encodes character data private final long bits2; - private int getKeyLength() { return (int) (this.bits1 & 0x003fL); } - private int getEncoding() { // 0 means encoded as char // 1 means encoded as bytes that are all <= 0x7f; return (int) (this.bits1 >> 6) & 0x03; } - @Override public final Object getKey() { int keylen = getKeyLength(); @@ -469,7 +510,7 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 long tmpBits1 = this.bits1; long tmpBits2 = this.bits2; if (getEncoding() == 1) { - for (int i = 0; i < keylen; i++) { + for (int i=0; i < keylen; i++) { if (i < 7) { tmpBits1 >>= 8; chars[i] = (char) (tmpBits1 & 0x00ff); @@ -479,10 +520,10 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 } } } else { - for (int i = 0; i < keylen; i++) { + for (int i=0; i < keylen; i++) { if (i < 3) { tmpBits1 >>= 16; - chars[i] = (char) (tmpBits1 & 0x00FFff); + chars[i] = (char) (tmpBits1 & 0x00FFff); } else { chars[i] = (char) (tmpBits2 & 0x00FFff); tmpBits2 >>= 16; @@ -493,16 +534,17 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 } // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override public boolean isKeyEqual(Object k) { if (k instanceof String) { - String str = (String) k; + String str = (String)k; int keylen = getKeyLength(); if (str.length() == keylen) { long tmpBits1 = this.bits1; long tmpBits2 = this.bits2; if (getEncoding() == 1) { - for (int i = 0; i < keylen; i++) { + for (int i=0; i < keylen; i++) { char c; if (i < 7) { tmpBits1 >>= 8; @@ -516,7 +558,7 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 } } } else { - for (int i = 0; i < keylen; i++) { + for (int i=0; i < keylen; i++) { char c; if (i < 3) { tmpBits1 >>= 16; @@ -535,5 +577,7 @@ public class VersionedStatsDiskRegionEntryOffHeapStringKey2 } return false; } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp } +
