Return-Path: X-Original-To: apmail-geode-commits-archive@minotaur.apache.org Delivered-To: apmail-geode-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id A844A18384 for ; Thu, 9 Jul 2015 17:04:26 +0000 (UTC) Received: (qmail 61575 invoked by uid 500); 9 Jul 2015 17:04:26 -0000 Delivered-To: apmail-geode-commits-archive@geode.apache.org Received: (qmail 61546 invoked by uid 500); 9 Jul 2015 17:04:26 -0000 Mailing-List: contact commits-help@geode.incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@geode.incubator.apache.org Delivered-To: mailing list commits@geode.incubator.apache.org Received: (qmail 61537 invoked by uid 99); 9 Jul 2015 17:04:26 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 09 Jul 2015 17:04:26 +0000 X-ASF-Spam-Status: No, hits=-2000.6 required=5.0 tests=ALL_TRUSTED,RP_MATCHES_RCVD X-Spam-Check-By: apache.org Received: from [140.211.11.3] (HELO mail.apache.org) (140.211.11.3) by apache.org (qpsmtpd/0.29) with SMTP; Thu, 09 Jul 2015 17:00:35 +0000 Received: (qmail 53968 invoked by uid 99); 9 Jul 2015 17:02:20 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Thu, 09 Jul 2015 17:02:20 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 41A53E6843; Thu, 9 Jul 2015 17:02:20 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: dschneider@apache.org To: commits@geode.incubator.apache.org Date: Thu, 09 Jul 2015 17:02:32 -0000 Message-Id: <1e96f3e374494409816cac2ba282235e@git.apache.org> In-Reply-To: <7f249334f8de4a87a653a7c04a138bba@git.apache.org> References: <7f249334f8de4a87a653a7c04a138bba@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [14/57] [partial] incubator-geode git commit: Initial import of geode-1.0.0.0-SNAPSHOT-2. All the new sub-project directories (like jvsd) were not imported. A diff was done to confirm that this commit is exactly the same as the open directory the snapsho X-Virus-Checked: Checked by ClamAV on apache.org http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey2.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey2.java new file mode 100644 index 0000000..f2930e2 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsDiskRegionEntryOffHeapStringKey2.java @@ -0,0 +1,391 @@ +/*========================================================================= + * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved. + * This product is protected by U.S. and international copyright + * and intellectual property laws. Pivotal products are covered by + * one or more patents listed at http://www.pivotal.io/patents. + *========================================================================= + */ +package com.gemstone.gemfire.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 com.gemstone.gemfire.internal.cache.lru.EnableLRU; +import com.gemstone.gemfire.internal.cache.persistence.DiskRecoveryStore; +import com.gemstone.gemfire.internal.InternalStatisticsDisabledException; +import com.gemstone.gemfire.internal.offheap.OffHeapRegionEntryHelper; +import com.gemstone.gemfire.internal.offheap.annotations.Released; +import com.gemstone.gemfire.internal.offheap.annotations.Retained; +import com.gemstone.gemfire.internal.offheap.annotations.Unretained; +import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry; +// macros whose definition changes this class: +// disk: DISK +// lru: LRU +// stats: STATS +// versioned: VERSIONED +// offheap: OFFHEAP +// 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 +/** + * Do not modify this class. It was generated. + * Instead modify LeafRegionEntry.cpp and then run + * bin/generateRegionEntryClasses.sh from the directory + * that contains your build.xml. + */ +public class VMStatsDiskRegionEntryOffHeapStringKey2 extends VMStatsDiskRegionEntryOffHeap { + public VMStatsDiskRegionEntryOffHeapStringKey2 (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. + if (i < 7) { + tmpBits1 |= (byte)key.charAt(i) & 0xff; + tmpBits1 <<= 8; + } else { + tmpBits2 <<= 8; + tmpBits2 |= (byte)key.charAt(i) & 0xff; + } + } + tmpBits1 |= 1<<6; + } else { + for (int i=key.length()-1; i >= 0; i--) { + if (i < 3) { + tmpBits1 |= key.charAt(i); + tmpBits1 <<= 16; + } else { + tmpBits2 <<= 16; + tmpBits2 |= key.charAt(i); + } + } + } + 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 next; + @SuppressWarnings("unused") + private volatile long lastModified; + private static final AtomicLongFieldUpdater lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.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; + /** + * 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 ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class, "ohAddress"); + @Override + public Token getValueAsToken() { + return OffHeapRegionEntryHelper.getValueAsToken(this); + } + @Override + protected Object getValueField() { + return OffHeapRegionEntryHelper._getValue(this); + } + // 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); + } + @Override + public long getAddress() { + return ohAddrUpdater.get(this); + } + @Override + 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); +// } + } + 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 getNextEntry() { + return this.next; + } + /** + * @see HashEntry#setNextEntry + */ + public final void setNextEntry(final HashEntry n) { + 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; + DiskStoreImpl ds = drs.getDiskStore(); + long maxOplogSize = ds.getMaxOplogSize(); + //get appropriate instance of DiskId implementation based on maxOplogSize + this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList()); + Helper.initialize(this, drs, value); + } + /** + * DiskId + * + * @since 5.1 + */ + 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; + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // stats code + @Override + public final void updateStatsForGet(boolean hit, long time) + { + setLastAccessed(time); + if (hit) { + incrementHitCount(); + } else { + incrementMissCount(); + } + } + @Override + protected final void setLastModified(long lastModified) { + _setLastModified(lastModified); + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + setLastAccessed(lastModified); + } + } + private volatile long lastAccessed; + private volatile int hitCount; + private volatile int missCount; + private static final AtomicIntegerFieldUpdater hitCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.class, "hitCount"); + private static final AtomicIntegerFieldUpdater missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapStringKey2.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); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override + public final void txDidDestroy(long currTime) { + setLastModified(currTime); + setLastAccessed(currTime); + this.hitCount = 0; + this.missCount = 0; + } + @Override + public boolean hasStats() { + return true; + } + // 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(); + char[] chars = new char[keylen]; + long tmpBits1 = this.bits1; + long tmpBits2 = this.bits2; + if (getEncoding() == 1) { + for (int i=0; i < keylen; i++) { + if (i < 7) { + tmpBits1 >>= 8; + chars[i] = (char) (tmpBits1 & 0x00ff); + } else { + chars[i] = (char) (tmpBits2 & 0x00ff); + tmpBits2 >>= 8; + } + } + } else { + for (int i=0; i < keylen; i++) { + if (i < 3) { + tmpBits1 >>= 16; + chars[i] = (char) (tmpBits1 & 0x00FFff); + } else { + chars[i] = (char) (tmpBits2 & 0x00FFff); + tmpBits2 >>= 16; + } + } + } + return new String(chars); + } + // 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; + 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++) { + char c; + if (i < 7) { + tmpBits1 >>= 8; + c = (char) (tmpBits1 & 0x00ff); + } else { + c = (char) (tmpBits2 & 0x00ff); + tmpBits2 >>= 8; + } + if (str.charAt(i) != c) { + return false; + } + } + } else { + for (int i=0; i < keylen; i++) { + char c; + if (i < 3) { + tmpBits1 >>= 16; + c = (char) (tmpBits1 & 0x00FFff); + } else { + c = (char) (tmpBits2 & 0x00FFff); + tmpBits2 >>= 16; + } + if (str.charAt(i) != c) { + return false; + } + } + } + return true; + } + } + return false; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsDiskRegionEntryOffHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsDiskRegionEntryOffHeapUUIDKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsDiskRegionEntryOffHeapUUIDKey.java new file mode 100644 index 0000000..e5a6a28 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsDiskRegionEntryOffHeapUUIDKey.java @@ -0,0 +1,292 @@ +/*========================================================================= + * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved. + * This product is protected by U.S. and international copyright + * and intellectual property laws. Pivotal products are covered by + * one or more patents listed at http://www.pivotal.io/patents. + *========================================================================= + */ +package com.gemstone.gemfire.internal.cache; +// DO NOT modify this class. It was generated from LeafRegionEntry.cpp +import java.util.UUID; +import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; +import java.util.concurrent.atomic.AtomicLongFieldUpdater; +import com.gemstone.gemfire.internal.cache.lru.EnableLRU; +import com.gemstone.gemfire.internal.cache.persistence.DiskRecoveryStore; +import com.gemstone.gemfire.internal.InternalStatisticsDisabledException; +import com.gemstone.gemfire.internal.offheap.OffHeapRegionEntryHelper; +import com.gemstone.gemfire.internal.offheap.annotations.Released; +import com.gemstone.gemfire.internal.offheap.annotations.Retained; +import com.gemstone.gemfire.internal.offheap.annotations.Unretained; +import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry; +// macros whose definition changes this class: +// disk: DISK +// lru: LRU +// stats: STATS +// versioned: VERSIONED +// offheap: OFFHEAP +// 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 +/** + * Do not modify this class. It was generated. + * Instead modify LeafRegionEntry.cpp and then run + * bin/generateRegionEntryClasses.sh from the directory + * that contains your build.xml. + */ +public class VMStatsDiskRegionEntryOffHeapUUIDKey extends VMStatsDiskRegionEntryOffHeap { + public VMStatsDiskRegionEntryOffHeapUUIDKey (RegionEntryContext context, UUID 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.keyMostSigBits = key.getMostSignificantBits(); + this.keyLeastSigBits = key.getLeastSignificantBits(); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // common code + protected int hash; + private HashEntry next; + @SuppressWarnings("unused") + private volatile long lastModified; + private static final AtomicLongFieldUpdater lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.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; + /** + * 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 ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class, "ohAddress"); + @Override + public Token getValueAsToken() { + return OffHeapRegionEntryHelper.getValueAsToken(this); + } + @Override + protected Object getValueField() { + return OffHeapRegionEntryHelper._getValue(this); + } + // 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); + } + @Override + public long getAddress() { + return ohAddrUpdater.get(this); + } + @Override + 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); +// } + } + 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 getNextEntry() { + return this.next; + } + /** + * @see HashEntry#setNextEntry + */ + public final void setNextEntry(final HashEntry n) { + 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; + DiskStoreImpl ds = drs.getDiskStore(); + long maxOplogSize = ds.getMaxOplogSize(); + //get appropriate instance of DiskId implementation based on maxOplogSize + this.id = DiskId.createDiskId(maxOplogSize, true/* is persistence */, ds.needsLinkedList()); + Helper.initialize(this, drs, value); + } + /** + * DiskId + * + * @since 5.1 + */ + 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; + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // stats code + @Override + public final void updateStatsForGet(boolean hit, long time) + { + setLastAccessed(time); + if (hit) { + incrementHitCount(); + } else { + incrementMissCount(); + } + } + @Override + protected final void setLastModified(long lastModified) { + _setLastModified(lastModified); + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + setLastAccessed(lastModified); + } + } + private volatile long lastAccessed; + private volatile int hitCount; + private volatile int missCount; + private static final AtomicIntegerFieldUpdater hitCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.class, "hitCount"); + private static final AtomicIntegerFieldUpdater missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsDiskRegionEntryOffHeapUUIDKey.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); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override + public final void txDidDestroy(long currTime) { + setLastModified(currTime); + setLastAccessed(currTime); + this.hitCount = 0; + this.missCount = 0; + } + @Override + public boolean hasStats() { + return true; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code + private final long keyMostSigBits; + private final long keyLeastSigBits; + @Override + public final Object getKey() { + return new UUID(this.keyMostSigBits, this.keyLeastSigBits); + } + @Override + public boolean isKeyEqual(Object k) { + if (k instanceof UUID) { + UUID uuid = (UUID)k; + return uuid.getLeastSignificantBits() == this.keyLeastSigBits && uuid.getMostSignificantBits() == this.keyMostSigBits; + } + return false; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeap.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeap.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeap.java index 915b7c9..d03d490 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeap.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeap.java @@ -52,5 +52,9 @@ public abstract class VMStatsLRURegionEntryHeap extends VMStatsLRURegionEntry { public RegionEntryFactory makeVersioned() { return VersionedStatsLRURegionEntryHeap.getEntryFactory(); } + @Override + public RegionEntryFactory makeOnHeap() { + return this; + } } } http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapIntKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapIntKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapIntKey.java index 4e90844..ab3ba18 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapIntKey.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapIntKey.java @@ -19,6 +19,7 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa // lru: LRU // stats: STATS // versioned: VERSIONED +// offheap: OFFHEAP // One of the following key macros must be defined: // key object: KEY_OBJECT // key int: KEY_INT @@ -33,7 +34,8 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa * that contains your build.xml. */ public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap { - public VMStatsLRURegionEntryHeapIntKey (RegionEntryContext context, int key, Object value + public VMStatsLRURegionEntryHeapIntKey (RegionEntryContext context, int key, + Object value ) { super(context, value @@ -50,10 +52,12 @@ public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap { private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapIntKey.class, "lastModified"); private volatile Object value; - protected final Object areGetValue() { + @Override + protected final Object getValueField() { return this.value; } - protected void areSetValue(Object v) { + @Override + protected void setValueField(Object v) { this.value = v; } protected long getlastModifiedField() { @@ -97,8 +101,6 @@ public class VMStatsLRURegionEntryHeapIntKey extends VMStatsLRURegionEntryHeap { Object value) { int oldSize = getEntrySize(); int newSize = capacityController.entrySize( getKeyForSizing(), value); - // GemFireCacheImpl.getInstance().getLoggerI18n().info("DEBUG updateEntrySize: oldSize=" + oldSize - // + " newSize=" + newSize); setEntrySize(newSize); int delta = newSize - oldSize; // if ( debug ) log( "updateEntrySize key=" + getKey() http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapLongKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapLongKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapLongKey.java index f128924..391ed79 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapLongKey.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapLongKey.java @@ -19,6 +19,7 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa // lru: LRU // stats: STATS // versioned: VERSIONED +// offheap: OFFHEAP // One of the following key macros must be defined: // key object: KEY_OBJECT // key int: KEY_INT @@ -33,7 +34,8 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa * that contains your build.xml. */ public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap { - public VMStatsLRURegionEntryHeapLongKey (RegionEntryContext context, long key, Object value + public VMStatsLRURegionEntryHeapLongKey (RegionEntryContext context, long key, + Object value ) { super(context, value @@ -50,10 +52,12 @@ public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapLongKey.class, "lastModified"); private volatile Object value; - protected final Object areGetValue() { + @Override + protected final Object getValueField() { return this.value; } - protected void areSetValue(Object v) { + @Override + protected void setValueField(Object v) { this.value = v; } protected long getlastModifiedField() { @@ -97,8 +101,6 @@ public class VMStatsLRURegionEntryHeapLongKey extends VMStatsLRURegionEntryHeap Object value) { int oldSize = getEntrySize(); int newSize = capacityController.entrySize( getKeyForSizing(), value); - // GemFireCacheImpl.getInstance().getLoggerI18n().info("DEBUG updateEntrySize: oldSize=" + oldSize - // + " newSize=" + newSize); setEntrySize(newSize); int delta = newSize - oldSize; // if ( debug ) log( "updateEntrySize key=" + getKey() http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java index ca2f400..4bf4b1e 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapObjectKey.java @@ -19,6 +19,7 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa // lru: LRU // stats: STATS // versioned: VERSIONED +// offheap: OFFHEAP // One of the following key macros must be defined: // key object: KEY_OBJECT // key int: KEY_INT @@ -33,7 +34,8 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa * that contains your build.xml. */ public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHeap { - public VMStatsLRURegionEntryHeapObjectKey (RegionEntryContext context, Object key, Object value + public VMStatsLRURegionEntryHeapObjectKey (RegionEntryContext context, Object key, + Object value ) { super(context, value @@ -50,10 +52,12 @@ public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHea private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapObjectKey.class, "lastModified"); private volatile Object value; - protected final Object areGetValue() { + @Override + protected final Object getValueField() { return this.value; } - protected void areSetValue(Object v) { + @Override + protected void setValueField(Object v) { this.value = v; } protected long getlastModifiedField() { @@ -97,8 +101,6 @@ public class VMStatsLRURegionEntryHeapObjectKey extends VMStatsLRURegionEntryHea Object value) { int oldSize = getEntrySize(); int newSize = capacityController.entrySize( getKeyForSizing(), value); - // GemFireCacheImpl.getInstance().getLoggerI18n().info("DEBUG updateEntrySize: oldSize=" + oldSize - // + " newSize=" + newSize); setEntrySize(newSize); int delta = newSize - oldSize; // if ( debug ) log( "updateEntrySize key=" + getKey() http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java index fa6355e..bc57946 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey1.java @@ -19,6 +19,7 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa // lru: LRU // stats: STATS // versioned: VERSIONED +// offheap: OFFHEAP // One of the following key macros must be defined: // key object: KEY_OBJECT // key int: KEY_INT @@ -33,7 +34,8 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa * that contains your build.xml. */ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHeap { - public VMStatsLRURegionEntryHeapStringKey1 (RegionEntryContext context, String key, Object value + public VMStatsLRURegionEntryHeapStringKey1 (RegionEntryContext context, String key, + Object value , boolean byteEncode ) { super(context, @@ -67,10 +69,12 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey1.class, "lastModified"); private volatile Object value; - protected final Object areGetValue() { + @Override + protected final Object getValueField() { return this.value; } - protected void areSetValue(Object v) { + @Override + protected void setValueField(Object v) { this.value = v; } protected long getlastModifiedField() { @@ -114,8 +118,6 @@ public class VMStatsLRURegionEntryHeapStringKey1 extends VMStatsLRURegionEntryHe Object value) { int oldSize = getEntrySize(); int newSize = capacityController.entrySize( getKeyForSizing(), value); - // GemFireCacheImpl.getInstance().getLoggerI18n().info("DEBUG updateEntrySize: oldSize=" + oldSize - // + " newSize=" + newSize); setEntrySize(newSize); int delta = newSize - oldSize; // if ( debug ) log( "updateEntrySize key=" + getKey() http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java index 3c2db7e..2fc5f99 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapStringKey2.java @@ -19,6 +19,7 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa // lru: LRU // stats: STATS // versioned: VERSIONED +// offheap: OFFHEAP // One of the following key macros must be defined: // key object: KEY_OBJECT // key int: KEY_INT @@ -33,7 +34,8 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa * that contains your build.xml. */ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHeap { - public VMStatsLRURegionEntryHeapStringKey2 (RegionEntryContext context, String key, Object value + public VMStatsLRURegionEntryHeapStringKey2 (RegionEntryContext context, String key, + Object value , boolean byteEncode ) { super(context, @@ -79,10 +81,12 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapStringKey2.class, "lastModified"); private volatile Object value; - protected final Object areGetValue() { + @Override + protected final Object getValueField() { return this.value; } - protected void areSetValue(Object v) { + @Override + protected void setValueField(Object v) { this.value = v; } protected long getlastModifiedField() { @@ -126,8 +130,6 @@ public class VMStatsLRURegionEntryHeapStringKey2 extends VMStatsLRURegionEntryHe Object value) { int oldSize = getEntrySize(); int newSize = capacityController.entrySize( getKeyForSizing(), value); - // GemFireCacheImpl.getInstance().getLoggerI18n().info("DEBUG updateEntrySize: oldSize=" + oldSize - // + " newSize=" + newSize); setEntrySize(newSize); int delta = newSize - oldSize; // if ( debug ) log( "updateEntrySize key=" + getKey() http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java index fb8f695..8ab316d 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryHeapUUIDKey.java @@ -20,6 +20,7 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa // lru: LRU // stats: STATS // versioned: VERSIONED +// offheap: OFFHEAP // One of the following key macros must be defined: // key object: KEY_OBJECT // key int: KEY_INT @@ -34,7 +35,8 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa * that contains your build.xml. */ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap { - public VMStatsLRURegionEntryHeapUUIDKey (RegionEntryContext context, UUID key, Object value + public VMStatsLRURegionEntryHeapUUIDKey (RegionEntryContext context, UUID key, + Object value ) { super(context, value @@ -52,10 +54,12 @@ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryHeapUUIDKey.class, "lastModified"); private volatile Object value; - protected final Object areGetValue() { + @Override + protected final Object getValueField() { return this.value; } - protected void areSetValue(Object v) { + @Override + protected void setValueField(Object v) { this.value = v; } protected long getlastModifiedField() { @@ -99,8 +103,6 @@ public class VMStatsLRURegionEntryHeapUUIDKey extends VMStatsLRURegionEntryHeap Object value) { int oldSize = getEntrySize(); int newSize = capacityController.entrySize( getKeyForSizing(), value); - // GemFireCacheImpl.getInstance().getLoggerI18n().info("DEBUG updateEntrySize: oldSize=" + oldSize - // + " newSize=" + newSize); setEntrySize(newSize); int delta = newSize - oldSize; // if ( debug ) log( "updateEntrySize key=" + getKey() http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeap.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeap.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeap.java new file mode 100644 index 0000000..b836e0d --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeap.java @@ -0,0 +1,60 @@ +/*========================================================================= + * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved. + * This product is protected by U.S. and international copyright + * and intellectual property laws. Pivotal products are covered by + * one or more patents listed at http://www.pivotal.io/patents. + *========================================================================= + */ +package com.gemstone.gemfire.internal.cache; + +import java.util.UUID; + +public abstract class VMStatsLRURegionEntryOffHeap extends VMStatsLRURegionEntry implements OffHeapRegionEntry { + public VMStatsLRURegionEntryOffHeap(RegionEntryContext context, Object value) { + super(context, value); + } + private static final VMStatsLRURegionEntryOffHeapFactory factory = new VMStatsLRURegionEntryOffHeapFactory(); + + public static RegionEntryFactory getEntryFactory() { + return factory; + } + private static class VMStatsLRURegionEntryOffHeapFactory implements RegionEntryFactory { + public final RegionEntry createEntry(RegionEntryContext context, Object key, Object value) { + if (InlineKeyHelper.INLINE_REGION_KEYS) { + Class keyClass = key.getClass(); + if (keyClass == Integer.class) { + return new VMStatsLRURegionEntryOffHeapIntKey(context, (Integer)key, value); + } else if (keyClass == Long.class) { + return new VMStatsLRURegionEntryOffHeapLongKey(context, (Long)key, value); + } else if (keyClass == String.class) { + final String skey = (String) key; + final Boolean info = InlineKeyHelper.canStringBeInlineEncoded(skey); + if (info != null) { + final boolean byteEncoded = info; + if (skey.length() <= InlineKeyHelper.getMaxInlineStringKey(1, byteEncoded)) { + return new VMStatsLRURegionEntryOffHeapStringKey1(context, skey, value, byteEncoded); + } else { + return new VMStatsLRURegionEntryOffHeapStringKey2(context, skey, value, byteEncoded); + } + } + } else if (keyClass == UUID.class) { + return new VMStatsLRURegionEntryOffHeapUUIDKey(context, (UUID)key, value); + } + } + return new VMStatsLRURegionEntryOffHeapObjectKey(context, key, value); + } + + public final Class getEntryClass() { + // The class returned from this method is used to estimate the memory size. + // TODO OFFHEAP: This estimate will not take into account the memory saved by inlining the keys. + return VMStatsLRURegionEntryOffHeapObjectKey.class; + } + public RegionEntryFactory makeVersioned() { + return VersionedStatsLRURegionEntryOffHeap.getEntryFactory(); + } + @Override + public RegionEntryFactory makeOnHeap() { + return VMStatsLRURegionEntryHeap.getEntryFactory(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapIntKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapIntKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapIntKey.java new file mode 100644 index 0000000..696f2b9 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapIntKey.java @@ -0,0 +1,296 @@ +/*========================================================================= + * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved. + * This product is protected by U.S. and international copyright + * and intellectual property laws. Pivotal products are covered by + * one or more patents listed at http://www.pivotal.io/patents. + *========================================================================= + */ +package com.gemstone.gemfire.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 com.gemstone.gemfire.internal.cache.lru.EnableLRU; +import com.gemstone.gemfire.internal.InternalStatisticsDisabledException; +import com.gemstone.gemfire.internal.cache.lru.LRUClockNode; +import com.gemstone.gemfire.internal.cache.lru.NewLRUClockHand; +import com.gemstone.gemfire.internal.offheap.OffHeapRegionEntryHelper; +import com.gemstone.gemfire.internal.offheap.annotations.Released; +import com.gemstone.gemfire.internal.offheap.annotations.Retained; +import com.gemstone.gemfire.internal.offheap.annotations.Unretained; +import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry; +// macros whose definition changes this class: +// disk: DISK +// lru: LRU +// stats: STATS +// versioned: VERSIONED +// offheap: OFFHEAP +// 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 +/** + * Do not modify this class. It was generated. + * Instead modify LeafRegionEntry.cpp and then run + * bin/generateRegionEntryClasses.sh from the directory + * that contains your build.xml. + */ +public class VMStatsLRURegionEntryOffHeapIntKey extends VMStatsLRURegionEntryOffHeap { + public VMStatsLRURegionEntryOffHeapIntKey (RegionEntryContext context, int key, + @Retained + Object value + ) { + super(context, + value + ); + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + this.key = key; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // common code + protected int hash; + private HashEntry next; + @SuppressWarnings("unused") + private volatile long lastModified; + private static final AtomicLongFieldUpdater lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.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; + /** + * 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 ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "ohAddress"); + @Override + public Token getValueAsToken() { + return OffHeapRegionEntryHelper.getValueAsToken(this); + } + @Override + protected Object getValueField() { + return OffHeapRegionEntryHelper._getValue(this); + } + // 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); + } + @Override + public long getAddress() { + return ohAddrUpdater.get(this); + } + @Override + 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); +// } + } + 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 getNextEntry() { + return this.next; + } + /** + * @see HashEntry#setNextEntry + */ + public final void setNextEntry(final HashEntry n) { + this.next = n; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // lru code + @Override + public void setDelayedDiskId(LocalRegion r) { + // nothing needed for LRUs with no disk + } + public final synchronized int updateEntrySize(EnableLRU capacityController) { + return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing refcount because we are synced and only getting the size + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public final synchronized int updateEntrySize(EnableLRU capacityController, + Object value) { + int oldSize = getEntrySize(); + int newSize = capacityController.entrySize( getKeyForSizing(), value); + setEntrySize(newSize); + int delta = newSize - oldSize; + // if ( debug ) log( "updateEntrySize key=" + getKey() + // + (_getValue() == Token.INVALID ? " invalid" : + // (_getValue() == Token.LOCAL_INVALID ? "local_invalid" : + // (_getValue()==null ? " evicted" : " valid"))) + // + " oldSize=" + oldSize + // + " newSize=" + this.size ); + return delta; + } + public final boolean testRecentlyUsed() { + return areAnyBitsSet(RECENTLY_USED); + } + @Override + public final void setRecentlyUsed() { + setBits(RECENTLY_USED); + } + public final void unsetRecentlyUsed() { + clearBits(~RECENTLY_USED); + } + public final boolean testEvicted() { + return areAnyBitsSet(EVICTED); + } + public final void setEvicted() { + setBits(EVICTED); + } + public final void unsetEvicted() { + clearBits(~EVICTED); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + private LRUClockNode nextLRU; + private LRUClockNode prevLRU; + private int size; + public final void setNextLRUNode( LRUClockNode next ) { + this.nextLRU = next; + } + public final LRUClockNode nextLRUNode() { + return this.nextLRU; + } + public final void setPrevLRUNode( LRUClockNode prev ) { + this.prevLRU = prev; + } + public final LRUClockNode prevLRUNode() { + return this.prevLRU; + } + public final int getEntrySize() { + return this.size; + } + protected final void setEntrySize(int size) { + this.size = size; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +//@Override +//public StringBuilder appendFieldsToString(final StringBuilder sb) { +// StringBuilder result = super.appendFieldsToString(sb); +// result.append("; prev=").append(this.prevLRU==null?"null":"not null"); +// result.append("; next=").append(this.nextLRU==null?"null":"not null"); +// return result; +//} + @Override + public Object getKeyForSizing() { + // inline keys always report null for sizing since the size comes from the entry size + return null; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // stats code + @Override + public final void updateStatsForGet(boolean hit, long time) + { + setLastAccessed(time); + if (hit) { + incrementHitCount(); + } else { + incrementMissCount(); + } + } + @Override + protected final void setLastModified(long lastModified) { + _setLastModified(lastModified); + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + setLastAccessed(lastModified); + } + } + private volatile long lastAccessed; + private volatile int hitCount; + private volatile int missCount; + private static final AtomicIntegerFieldUpdater hitCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.class, "hitCount"); + private static final AtomicIntegerFieldUpdater missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapIntKey.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); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override + public final void txDidDestroy(long currTime) { + setLastModified(currTime); + setLastAccessed(currTime); + this.hitCount = 0; + this.missCount = 0; + } + @Override + public boolean hasStats() { + return true; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code + private final int key; + @Override + public final Object getKey() { + return this.key; + } + @Override + public boolean isKeyEqual(Object k) { + if (k instanceof Integer) { + return ((Integer) k).intValue() == this.key; + } + return false; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapLongKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapLongKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapLongKey.java new file mode 100644 index 0000000..6b06fc8 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapLongKey.java @@ -0,0 +1,296 @@ +/*========================================================================= + * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved. + * This product is protected by U.S. and international copyright + * and intellectual property laws. Pivotal products are covered by + * one or more patents listed at http://www.pivotal.io/patents. + *========================================================================= + */ +package com.gemstone.gemfire.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 com.gemstone.gemfire.internal.cache.lru.EnableLRU; +import com.gemstone.gemfire.internal.InternalStatisticsDisabledException; +import com.gemstone.gemfire.internal.cache.lru.LRUClockNode; +import com.gemstone.gemfire.internal.cache.lru.NewLRUClockHand; +import com.gemstone.gemfire.internal.offheap.OffHeapRegionEntryHelper; +import com.gemstone.gemfire.internal.offheap.annotations.Released; +import com.gemstone.gemfire.internal.offheap.annotations.Retained; +import com.gemstone.gemfire.internal.offheap.annotations.Unretained; +import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry; +// macros whose definition changes this class: +// disk: DISK +// lru: LRU +// stats: STATS +// versioned: VERSIONED +// offheap: OFFHEAP +// 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 +/** + * Do not modify this class. It was generated. + * Instead modify LeafRegionEntry.cpp and then run + * bin/generateRegionEntryClasses.sh from the directory + * that contains your build.xml. + */ +public class VMStatsLRURegionEntryOffHeapLongKey extends VMStatsLRURegionEntryOffHeap { + public VMStatsLRURegionEntryOffHeapLongKey (RegionEntryContext context, long key, + @Retained + Object value + ) { + super(context, + value + ); + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + this.key = key; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // common code + protected int hash; + private HashEntry next; + @SuppressWarnings("unused") + private volatile long lastModified; + private static final AtomicLongFieldUpdater lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.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; + /** + * 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 ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class, "ohAddress"); + @Override + public Token getValueAsToken() { + return OffHeapRegionEntryHelper.getValueAsToken(this); + } + @Override + protected Object getValueField() { + return OffHeapRegionEntryHelper._getValue(this); + } + // 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); + } + @Override + public long getAddress() { + return ohAddrUpdater.get(this); + } + @Override + 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); +// } + } + 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 getNextEntry() { + return this.next; + } + /** + * @see HashEntry#setNextEntry + */ + public final void setNextEntry(final HashEntry n) { + this.next = n; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // lru code + @Override + public void setDelayedDiskId(LocalRegion r) { + // nothing needed for LRUs with no disk + } + public final synchronized int updateEntrySize(EnableLRU capacityController) { + return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing refcount because we are synced and only getting the size + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public final synchronized int updateEntrySize(EnableLRU capacityController, + Object value) { + int oldSize = getEntrySize(); + int newSize = capacityController.entrySize( getKeyForSizing(), value); + setEntrySize(newSize); + int delta = newSize - oldSize; + // if ( debug ) log( "updateEntrySize key=" + getKey() + // + (_getValue() == Token.INVALID ? " invalid" : + // (_getValue() == Token.LOCAL_INVALID ? "local_invalid" : + // (_getValue()==null ? " evicted" : " valid"))) + // + " oldSize=" + oldSize + // + " newSize=" + this.size ); + return delta; + } + public final boolean testRecentlyUsed() { + return areAnyBitsSet(RECENTLY_USED); + } + @Override + public final void setRecentlyUsed() { + setBits(RECENTLY_USED); + } + public final void unsetRecentlyUsed() { + clearBits(~RECENTLY_USED); + } + public final boolean testEvicted() { + return areAnyBitsSet(EVICTED); + } + public final void setEvicted() { + setBits(EVICTED); + } + public final void unsetEvicted() { + clearBits(~EVICTED); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + private LRUClockNode nextLRU; + private LRUClockNode prevLRU; + private int size; + public final void setNextLRUNode( LRUClockNode next ) { + this.nextLRU = next; + } + public final LRUClockNode nextLRUNode() { + return this.nextLRU; + } + public final void setPrevLRUNode( LRUClockNode prev ) { + this.prevLRU = prev; + } + public final LRUClockNode prevLRUNode() { + return this.prevLRU; + } + public final int getEntrySize() { + return this.size; + } + protected final void setEntrySize(int size) { + this.size = size; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +//@Override +//public StringBuilder appendFieldsToString(final StringBuilder sb) { +// StringBuilder result = super.appendFieldsToString(sb); +// result.append("; prev=").append(this.prevLRU==null?"null":"not null"); +// result.append("; next=").append(this.nextLRU==null?"null":"not null"); +// return result; +//} + @Override + public Object getKeyForSizing() { + // inline keys always report null for sizing since the size comes from the entry size + return null; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // stats code + @Override + public final void updateStatsForGet(boolean hit, long time) + { + setLastAccessed(time); + if (hit) { + incrementHitCount(); + } else { + incrementMissCount(); + } + } + @Override + protected final void setLastModified(long lastModified) { + _setLastModified(lastModified); + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + setLastAccessed(lastModified); + } + } + private volatile long lastAccessed; + private volatile int hitCount; + private volatile int missCount; + private static final AtomicIntegerFieldUpdater hitCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.class, "hitCount"); + private static final AtomicIntegerFieldUpdater missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapLongKey.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); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override + public final void txDidDestroy(long currTime) { + setLastModified(currTime); + setLastAccessed(currTime); + this.hitCount = 0; + this.missCount = 0; + } + @Override + public boolean hasStats() { + return true; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code + private final long key; + @Override + public final Object getKey() { + return this.key; + } + @Override + public boolean isKeyEqual(Object k) { + if (k instanceof Long) { + return ((Long) k).longValue() == this.key; + } + return false; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapObjectKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapObjectKey.java new file mode 100644 index 0000000..1f9d5b9 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsLRURegionEntryOffHeapObjectKey.java @@ -0,0 +1,289 @@ +/*========================================================================= + * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved. + * This product is protected by U.S. and international copyright + * and intellectual property laws. Pivotal products are covered by + * one or more patents listed at http://www.pivotal.io/patents. + *========================================================================= + */ +package com.gemstone.gemfire.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 com.gemstone.gemfire.internal.cache.lru.EnableLRU; +import com.gemstone.gemfire.internal.InternalStatisticsDisabledException; +import com.gemstone.gemfire.internal.cache.lru.LRUClockNode; +import com.gemstone.gemfire.internal.cache.lru.NewLRUClockHand; +import com.gemstone.gemfire.internal.offheap.OffHeapRegionEntryHelper; +import com.gemstone.gemfire.internal.offheap.annotations.Released; +import com.gemstone.gemfire.internal.offheap.annotations.Retained; +import com.gemstone.gemfire.internal.offheap.annotations.Unretained; +import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMap.HashEntry; +// macros whose definition changes this class: +// disk: DISK +// lru: LRU +// stats: STATS +// versioned: VERSIONED +// offheap: OFFHEAP +// 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 +/** + * Do not modify this class. It was generated. + * Instead modify LeafRegionEntry.cpp and then run + * bin/generateRegionEntryClasses.sh from the directory + * that contains your build.xml. + */ +public class VMStatsLRURegionEntryOffHeapObjectKey extends VMStatsLRURegionEntryOffHeap { + public VMStatsLRURegionEntryOffHeapObjectKey (RegionEntryContext context, Object key, + @Retained + Object value + ) { + super(context, + value + ); + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + this.key = key; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // common code + protected int hash; + private HashEntry next; + @SuppressWarnings("unused") + private volatile long lastModified; + private static final AtomicLongFieldUpdater lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.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; + /** + * 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 ohAddrUpdater = AtomicLongFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class, "ohAddress"); + @Override + public Token getValueAsToken() { + return OffHeapRegionEntryHelper.getValueAsToken(this); + } + @Override + protected Object getValueField() { + return OffHeapRegionEntryHelper._getValue(this); + } + // 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); + } + @Override + public long getAddress() { + return ohAddrUpdater.get(this); + } + @Override + 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); +// } + } + 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 getNextEntry() { + return this.next; + } + /** + * @see HashEntry#setNextEntry + */ + public final void setNextEntry(final HashEntry n) { + this.next = n; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // lru code + @Override + public void setDelayedDiskId(LocalRegion r) { + // nothing needed for LRUs with no disk + } + public final synchronized int updateEntrySize(EnableLRU capacityController) { + return updateEntrySize(capacityController, _getValue()); // OFHEAP: _getValue ok w/o incing refcount because we are synced and only getting the size + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public final synchronized int updateEntrySize(EnableLRU capacityController, + Object value) { + int oldSize = getEntrySize(); + int newSize = capacityController.entrySize( getKeyForSizing(), value); + setEntrySize(newSize); + int delta = newSize - oldSize; + // if ( debug ) log( "updateEntrySize key=" + getKey() + // + (_getValue() == Token.INVALID ? " invalid" : + // (_getValue() == Token.LOCAL_INVALID ? "local_invalid" : + // (_getValue()==null ? " evicted" : " valid"))) + // + " oldSize=" + oldSize + // + " newSize=" + this.size ); + return delta; + } + public final boolean testRecentlyUsed() { + return areAnyBitsSet(RECENTLY_USED); + } + @Override + public final void setRecentlyUsed() { + setBits(RECENTLY_USED); + } + public final void unsetRecentlyUsed() { + clearBits(~RECENTLY_USED); + } + public final boolean testEvicted() { + return areAnyBitsSet(EVICTED); + } + public final void setEvicted() { + setBits(EVICTED); + } + public final void unsetEvicted() { + clearBits(~EVICTED); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + private LRUClockNode nextLRU; + private LRUClockNode prevLRU; + private int size; + public final void setNextLRUNode( LRUClockNode next ) { + this.nextLRU = next; + } + public final LRUClockNode nextLRUNode() { + return this.nextLRU; + } + public final void setPrevLRUNode( LRUClockNode prev ) { + this.prevLRU = prev; + } + public final LRUClockNode prevLRUNode() { + return this.prevLRU; + } + public final int getEntrySize() { + return this.size; + } + protected final void setEntrySize(int size) { + this.size = size; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +//@Override +//public StringBuilder appendFieldsToString(final StringBuilder sb) { +// StringBuilder result = super.appendFieldsToString(sb); +// result.append("; prev=").append(this.prevLRU==null?"null":"not null"); +// result.append("; next=").append(this.nextLRU==null?"null":"not null"); +// return result; +//} + @Override + public Object getKeyForSizing() { + // default implementation. + return getKey(); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // stats code + @Override + public final void updateStatsForGet(boolean hit, long time) + { + setLastAccessed(time); + if (hit) { + incrementHitCount(); + } else { + incrementMissCount(); + } + } + @Override + protected final void setLastModified(long lastModified) { + _setLastModified(lastModified); + if (!DISABLE_ACCESS_TIME_UPDATE_ON_PUT) { + setLastAccessed(lastModified); + } + } + private volatile long lastAccessed; + private volatile int hitCount; + private volatile int missCount; + private static final AtomicIntegerFieldUpdater hitCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.class, "hitCount"); + private static final AtomicIntegerFieldUpdater missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsLRURegionEntryOffHeapObjectKey.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); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + @Override + public final void txDidDestroy(long currTime) { + setLastModified(currTime); + setLastAccessed(currTime); + this.hitCount = 0; + this.missCount = 0; + } + @Override + public boolean hasStats() { + return true; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code + private final Object key; + @Override + public final Object getKey() { + return this.key; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +}