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 1A29A1836A for ; Thu, 9 Jul 2015 17:03:48 +0000 (UTC) Received: (qmail 57364 invoked by uid 500); 9 Jul 2015 17:03:48 -0000 Delivered-To: apmail-geode-commits-archive@geode.apache.org Received: (qmail 57333 invoked by uid 500); 9 Jul 2015 17:03:47 -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 57324 invoked by uid 99); 9 Jul 2015 17:03:47 -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:03:47 +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 53967 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 38EF2E6841; 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:30 -0000 Message-Id: <7a06c20f2fd249d99bdefdb122e588cc@git.apache.org> In-Reply-To: <7f249334f8de4a87a653a7c04a138bba@git.apache.org> References: <7f249334f8de4a87a653a7c04a138bba@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [12/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/VMStatsRegionEntryOffHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsRegionEntryOffHeapStringKey1.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsRegionEntryOffHeapStringKey1.java new file mode 100644 index 0000000..405f7a2 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsRegionEntryOffHeapStringKey1.java @@ -0,0 +1,277 @@ +/*========================================================================= + * 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.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 VMStatsRegionEntryOffHeapStringKey1 extends VMStatsRegionEntryOffHeap { + public VMStatsRegionEntryOffHeapStringKey1 (RegionEntryContext context, String key, + @Retained + Object value + , boolean byteEncode + ) { + super(context, + value + ); + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // 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; + tmpBits1 <<= 8; + } + tmpBits1 |= 1<<6; + } else { + 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 next; + @SuppressWarnings("unused") + private volatile long lastModified; + private static final AtomicLongFieldUpdater lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.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(VMStatsRegionEntryOffHeapStringKey1.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 + // 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(VMStatsRegionEntryOffHeapStringKey1.class, "hitCount"); + private static final AtomicIntegerFieldUpdater missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey1.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 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++) { + tmpBits1 >>= 8; + chars[i] = (char) (tmpBits1 & 0x00ff); + } + } else { + for (int i=0; i < keylen; i++) { + tmpBits1 >>= 16; + chars[i] = (char) (tmpBits1 & 0x00FFff); + } + } + 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; + if (getEncoding() == 1) { + for (int i=0; i < keylen; i++) { + tmpBits1 >>= 8; + char c = (char) (tmpBits1 & 0x00ff); + if (str.charAt(i) != c) { + return false; + } + } + } else { + for (int i=0; i < keylen; i++) { + tmpBits1 >>= 16; + char c = (char) (tmpBits1 & 0x00FFff); + 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/VMStatsRegionEntryOffHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsRegionEntryOffHeapStringKey2.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsRegionEntryOffHeapStringKey2.java new file mode 100644 index 0000000..6700658 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsRegionEntryOffHeapStringKey2.java @@ -0,0 +1,318 @@ +/*========================================================================= + * 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.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 VMStatsRegionEntryOffHeapStringKey2 extends VMStatsRegionEntryOffHeap { + public VMStatsRegionEntryOffHeapStringKey2 (RegionEntryContext context, String key, + @Retained + Object value + , boolean byteEncode + ) { + super(context, + value + ); + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // 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(VMStatsRegionEntryOffHeapStringKey2.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(VMStatsRegionEntryOffHeapStringKey2.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 + // 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(VMStatsRegionEntryOffHeapStringKey2.class, "hitCount"); + private static final AtomicIntegerFieldUpdater missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapStringKey2.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/VMStatsRegionEntryOffHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsRegionEntryOffHeapUUIDKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsRegionEntryOffHeapUUIDKey.java new file mode 100644 index 0000000..0a2fc12 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMStatsRegionEntryOffHeapUUIDKey.java @@ -0,0 +1,219 @@ +/*========================================================================= + * 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.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 VMStatsRegionEntryOffHeapUUIDKey extends VMStatsRegionEntryOffHeap { + public VMStatsRegionEntryOffHeapUUIDKey (RegionEntryContext context, UUID key, + @Retained + Object value + ) { + super(context, + value + ); + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + 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(VMStatsRegionEntryOffHeapUUIDKey.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(VMStatsRegionEntryOffHeapUUIDKey.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 + // 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(VMStatsRegionEntryOffHeapUUIDKey.class, "hitCount"); + private static final AtomicIntegerFieldUpdater missCountUpdater + = AtomicIntegerFieldUpdater.newUpdater(VMStatsRegionEntryOffHeapUUIDKey.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/VMThinDiskLRURegionEntryHeap.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeap.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeap.java index 74b62b1..2f59430 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeap.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeap.java @@ -52,5 +52,9 @@ public abstract class VMThinDiskLRURegionEntryHeap extends VMThinDiskLRURegionEn public RegionEntryFactory makeVersioned() { return VersionedThinDiskLRURegionEntryHeap.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/VMThinDiskLRURegionEntryHeapIntKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapIntKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapIntKey.java index 88a0dee..aa8ad42 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapIntKey.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapIntKey.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 VMThinDiskLRURegionEntryHeapIntKey extends VMThinDiskLRURegionEntryHeap { - public VMThinDiskLRURegionEntryHeapIntKey (RegionEntryContext context, int key, Object value + public VMThinDiskLRURegionEntryHeapIntKey (RegionEntryContext context, int key, + Object value ) { super(context, (value instanceof RecoveredEntry ? null : value) @@ -51,10 +53,12 @@ public class VMThinDiskLRURegionEntryHeapIntKey extends VMThinDiskLRURegionEntry private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapIntKey.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() { @@ -185,8 +189,6 @@ public class VMThinDiskLRURegionEntryHeapIntKey extends VMThinDiskLRURegionEntry 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/VMThinDiskLRURegionEntryHeapLongKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapLongKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapLongKey.java index 29fb7c7..3aa3dfc 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapLongKey.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapLongKey.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 VMThinDiskLRURegionEntryHeapLongKey extends VMThinDiskLRURegionEntryHeap { - public VMThinDiskLRURegionEntryHeapLongKey (RegionEntryContext context, long key, Object value + public VMThinDiskLRURegionEntryHeapLongKey (RegionEntryContext context, long key, + Object value ) { super(context, (value instanceof RecoveredEntry ? null : value) @@ -51,10 +53,12 @@ public class VMThinDiskLRURegionEntryHeapLongKey extends VMThinDiskLRURegionEntr private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapLongKey.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() { @@ -185,8 +189,6 @@ public class VMThinDiskLRURegionEntryHeapLongKey extends VMThinDiskLRURegionEntr 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/VMThinDiskLRURegionEntryHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapObjectKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapObjectKey.java index d3504af..7224ec4 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapObjectKey.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapObjectKey.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 VMThinDiskLRURegionEntryHeapObjectKey extends VMThinDiskLRURegionEntryHeap { - public VMThinDiskLRURegionEntryHeapObjectKey (RegionEntryContext context, Object key, Object value + public VMThinDiskLRURegionEntryHeapObjectKey (RegionEntryContext context, Object key, + Object value ) { super(context, (value instanceof RecoveredEntry ? null : value) @@ -51,10 +53,12 @@ public class VMThinDiskLRURegionEntryHeapObjectKey extends VMThinDiskLRURegionEn private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapObjectKey.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() { @@ -185,8 +189,6 @@ public class VMThinDiskLRURegionEntryHeapObjectKey extends VMThinDiskLRURegionEn 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/VMThinDiskLRURegionEntryHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapStringKey1.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapStringKey1.java index 5d7d843..8e94dc7 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapStringKey1.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapStringKey1.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 VMThinDiskLRURegionEntryHeapStringKey1 extends VMThinDiskLRURegionEntryHeap { - public VMThinDiskLRURegionEntryHeapStringKey1 (RegionEntryContext context, String key, Object value + public VMThinDiskLRURegionEntryHeapStringKey1 (RegionEntryContext context, String key, + Object value , boolean byteEncode ) { super(context, @@ -68,10 +70,12 @@ public class VMThinDiskLRURegionEntryHeapStringKey1 extends VMThinDiskLRURegionE private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapStringKey1.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() { @@ -202,8 +206,6 @@ public class VMThinDiskLRURegionEntryHeapStringKey1 extends VMThinDiskLRURegionE 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/VMThinDiskLRURegionEntryHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapStringKey2.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapStringKey2.java index b58c8f9..aa8767d 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapStringKey2.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapStringKey2.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 VMThinDiskLRURegionEntryHeapStringKey2 extends VMThinDiskLRURegionEntryHeap { - public VMThinDiskLRURegionEntryHeapStringKey2 (RegionEntryContext context, String key, Object value + public VMThinDiskLRURegionEntryHeapStringKey2 (RegionEntryContext context, String key, + Object value , boolean byteEncode ) { super(context, @@ -80,10 +82,12 @@ public class VMThinDiskLRURegionEntryHeapStringKey2 extends VMThinDiskLRURegionE private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapStringKey2.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() { @@ -214,8 +218,6 @@ public class VMThinDiskLRURegionEntryHeapStringKey2 extends VMThinDiskLRURegionE 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/VMThinDiskLRURegionEntryHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapUUIDKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapUUIDKey.java index dd16856..74f6aae 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapUUIDKey.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryHeapUUIDKey.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 VMThinDiskLRURegionEntryHeapUUIDKey extends VMThinDiskLRURegionEntryHeap { - public VMThinDiskLRURegionEntryHeapUUIDKey (RegionEntryContext context, UUID key, Object value + public VMThinDiskLRURegionEntryHeapUUIDKey (RegionEntryContext context, UUID key, + Object value ) { super(context, (value instanceof RecoveredEntry ? null : value) @@ -53,10 +55,12 @@ public class VMThinDiskLRURegionEntryHeapUUIDKey extends VMThinDiskLRURegionEntr private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryHeapUUIDKey.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() { @@ -187,8 +191,6 @@ public class VMThinDiskLRURegionEntryHeapUUIDKey extends VMThinDiskLRURegionEntr 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/VMThinDiskLRURegionEntryOffHeap.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeap.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeap.java new file mode 100644 index 0000000..37455d8 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeap.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 VMThinDiskLRURegionEntryOffHeap extends VMThinDiskLRURegionEntry implements OffHeapRegionEntry { + public VMThinDiskLRURegionEntryOffHeap(RegionEntryContext context, Object value) { + super(context, value); + } + private static final VMThinDiskLRURegionEntryOffHeapFactory factory = new VMThinDiskLRURegionEntryOffHeapFactory(); + + public static RegionEntryFactory getEntryFactory() { + return factory; + } + private static class VMThinDiskLRURegionEntryOffHeapFactory 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 VMThinDiskLRURegionEntryOffHeapIntKey(context, (Integer)key, value); + } else if (keyClass == Long.class) { + return new VMThinDiskLRURegionEntryOffHeapLongKey(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 VMThinDiskLRURegionEntryOffHeapStringKey1(context, skey, value, byteEncoded); + } else { + return new VMThinDiskLRURegionEntryOffHeapStringKey2(context, skey, value, byteEncoded); + } + } + } else if (keyClass == UUID.class) { + return new VMThinDiskLRURegionEntryOffHeapUUIDKey(context, (UUID)key, value); + } + } + return new VMThinDiskLRURegionEntryOffHeapObjectKey(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 VMThinDiskLRURegionEntryOffHeapObjectKey.class; + } + public RegionEntryFactory makeVersioned() { + return VersionedThinDiskLRURegionEntryOffHeap.getEntryFactory(); + } + @Override + public RegionEntryFactory makeOnHeap() { + return VMThinDiskLRURegionEntryHeap.getEntryFactory(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeapIntKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeapIntKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeapIntKey.java new file mode 100644 index 0000000..785897b --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeapIntKey.java @@ -0,0 +1,320 @@ +/*========================================================================= + * 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.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 VMThinDiskLRURegionEntryOffHeapIntKey extends VMThinDiskLRURegionEntryOffHeap { + public VMThinDiskLRURegionEntryOffHeapIntKey (RegionEntryContext context, int 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 next; + @SuppressWarnings("unused") + private volatile long lastModified; + private static final AtomicLongFieldUpdater lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryOffHeapIntKey.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(VMThinDiskLRURegionEntryOffHeapIntKey.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 drs, Object value) { + boolean isBackup; + if (drs instanceof LocalRegion) { + isBackup = ((LocalRegion)drs).getDiskRegion().isBackup(); + } else if (drs instanceof PlaceHolderDiskRegion) { + isBackup = true; + } else { + throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion"); + } + // Delay the initialization of DiskID if overflow only + if (isBackup) { + diskInitialize(drs, value); + } + } + @Override + public final synchronized int updateAsyncEntrySize(EnableLRU capacityController) { + int oldSize = getEntrySize(); + int newSize = capacityController.entrySize( getKeyForSizing(), null); + setEntrySize(newSize); + int delta = newSize - oldSize; + return delta; + } + // 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 + // lru code + @Override + public void setDelayedDiskId(LocalRegion r) { + DiskStoreImpl ds = r.getDiskStore(); + long maxOplogSize = ds.getMaxOplogSize(); + this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList()); + } + 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 + // 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/VMThinDiskLRURegionEntryOffHeapLongKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeapLongKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeapLongKey.java new file mode 100644 index 0000000..0a24dc9 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VMThinDiskLRURegionEntryOffHeapLongKey.java @@ -0,0 +1,320 @@ +/*========================================================================= + * 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.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 VMThinDiskLRURegionEntryOffHeapLongKey extends VMThinDiskLRURegionEntryOffHeap { + public VMThinDiskLRURegionEntryOffHeapLongKey (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 next; + @SuppressWarnings("unused") + private volatile long lastModified; + private static final AtomicLongFieldUpdater lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VMThinDiskLRURegionEntryOffHeapLongKey.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(VMThinDiskLRURegionEntryOffHeapLongKey.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 drs, Object value) { + boolean isBackup; + if (drs instanceof LocalRegion) { + isBackup = ((LocalRegion)drs).getDiskRegion().isBackup(); + } else if (drs instanceof PlaceHolderDiskRegion) { + isBackup = true; + } else { + throw new IllegalArgumentException("expected a LocalRegion or PlaceHolderDiskRegion"); + } + // Delay the initialization of DiskID if overflow only + if (isBackup) { + diskInitialize(drs, value); + } + } + @Override + public final synchronized int updateAsyncEntrySize(EnableLRU capacityController) { + int oldSize = getEntrySize(); + int newSize = capacityController.entrySize( getKeyForSizing(), null); + setEntrySize(newSize); + int delta = newSize - oldSize; + return delta; + } + // 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 + // lru code + @Override + public void setDelayedDiskId(LocalRegion r) { + DiskStoreImpl ds = r.getDiskStore(); + long maxOplogSize = ds.getMaxOplogSize(); + this.id = DiskId.createDiskId(maxOplogSize, false /* over flow only */, ds.needsLinkedList()); + } + 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 + // 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 +}