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 50CF71837F for ; Thu, 9 Jul 2015 17:04:20 +0000 (UTC) Received: (qmail 61123 invoked by uid 500); 9 Jul 2015 17:04:20 -0000 Delivered-To: apmail-geode-commits-archive@geode.apache.org Received: (qmail 61092 invoked by uid 500); 9 Jul 2015 17:04:20 -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 61083 invoked by uid 99); 9 Jul 2015 17:04:20 -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:20 +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 53941 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 05911E6839; 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:20 -0000 Message-Id: In-Reply-To: <7f249334f8de4a87a653a7c04a138bba@git.apache.org> References: <7f249334f8de4a87a653a7c04a138bba@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [02/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/VersionedThinDiskLRURegionEntryHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapStringKey1.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapStringKey1.java index 141f160..81b0531 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapStringKey1.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapStringKey1.java @@ -24,6 +24,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 @@ -38,7 +39,8 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa * that contains your build.xml. */ public class VersionedThinDiskLRURegionEntryHeapStringKey1 extends VersionedThinDiskLRURegionEntryHeap { - public VersionedThinDiskLRURegionEntryHeapStringKey1 (RegionEntryContext context, String key, Object value + public VersionedThinDiskLRURegionEntryHeapStringKey1 (RegionEntryContext context, String key, + Object value , boolean byteEncode ) { super(context, @@ -73,10 +75,12 @@ public class VersionedThinDiskLRURegionEntryHeapStringKey1 extends VersionedThin private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VersionedThinDiskLRURegionEntryHeapStringKey1.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() { @@ -207,8 +211,6 @@ public class VersionedThinDiskLRURegionEntryHeapStringKey1 extends VersionedThin 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/VersionedThinDiskLRURegionEntryHeapStringKey2.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapStringKey2.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapStringKey2.java index 7adae9f..ce04de2 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapStringKey2.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapStringKey2.java @@ -24,6 +24,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 @@ -38,7 +39,8 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa * that contains your build.xml. */ public class VersionedThinDiskLRURegionEntryHeapStringKey2 extends VersionedThinDiskLRURegionEntryHeap { - public VersionedThinDiskLRURegionEntryHeapStringKey2 (RegionEntryContext context, String key, Object value + public VersionedThinDiskLRURegionEntryHeapStringKey2 (RegionEntryContext context, String key, + Object value , boolean byteEncode ) { super(context, @@ -85,10 +87,12 @@ public class VersionedThinDiskLRURegionEntryHeapStringKey2 extends VersionedThin private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VersionedThinDiskLRURegionEntryHeapStringKey2.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() { @@ -219,8 +223,6 @@ public class VersionedThinDiskLRURegionEntryHeapStringKey2 extends VersionedThin 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/VersionedThinDiskLRURegionEntryHeapUUIDKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapUUIDKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapUUIDKey.java index 1c3ddf2..d50eea1 100644 --- a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapUUIDKey.java +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryHeapUUIDKey.java @@ -25,6 +25,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 @@ -39,7 +40,8 @@ import com.gemstone.gemfire.internal.util.concurrent.CustomEntryConcurrentHashMa * that contains your build.xml. */ public class VersionedThinDiskLRURegionEntryHeapUUIDKey extends VersionedThinDiskLRURegionEntryHeap { - public VersionedThinDiskLRURegionEntryHeapUUIDKey (RegionEntryContext context, UUID key, Object value + public VersionedThinDiskLRURegionEntryHeapUUIDKey (RegionEntryContext context, UUID key, + Object value ) { super(context, (value instanceof RecoveredEntry ? null : value) @@ -58,10 +60,12 @@ public class VersionedThinDiskLRURegionEntryHeapUUIDKey extends VersionedThinDis private static final AtomicLongFieldUpdater lastModifiedUpdater = AtomicLongFieldUpdater.newUpdater(VersionedThinDiskLRURegionEntryHeapUUIDKey.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() { @@ -192,8 +196,6 @@ public class VersionedThinDiskLRURegionEntryHeapUUIDKey extends VersionedThinDis 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/VersionedThinDiskLRURegionEntryOffHeap.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeap.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeap.java new file mode 100644 index 0000000..483038e --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeap.java @@ -0,0 +1,61 @@ +/*========================================================================= + * 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 VersionedThinDiskLRURegionEntryOffHeap extends + VersionedThinDiskLRURegionEntry implements OffHeapRegionEntry { + public VersionedThinDiskLRURegionEntryOffHeap(RegionEntryContext context, Object value) { + super(context, value); + } + private static final VersionedThinDiskLRURegionEntryOffHeapFactory factory = new VersionedThinDiskLRURegionEntryOffHeapFactory(); + + public static RegionEntryFactory getEntryFactory() { + return factory; + } + private static class VersionedThinDiskLRURegionEntryOffHeapFactory 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 VersionedThinDiskLRURegionEntryOffHeapIntKey(context, (Integer)key, value); + } else if (keyClass == Long.class) { + return new VersionedThinDiskLRURegionEntryOffHeapLongKey(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 VersionedThinDiskLRURegionEntryOffHeapStringKey1(context, skey, value, byteEncoded); + } else { + return new VersionedThinDiskLRURegionEntryOffHeapStringKey2(context, skey, value, byteEncoded); + } + } + } else if (keyClass == UUID.class) { + return new VersionedThinDiskLRURegionEntryOffHeapUUIDKey(context, (UUID)key, value); + } + } + return new VersionedThinDiskLRURegionEntryOffHeapObjectKey(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 VersionedThinDiskLRURegionEntryOffHeapObjectKey.class; + } + public RegionEntryFactory makeVersioned() { + return this; + } + @Override + public RegionEntryFactory makeOnHeap() { + return VersionedThinDiskLRURegionEntryHeap.getEntryFactory(); + } + } +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapIntKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapIntKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapIntKey.java new file mode 100644 index 0000000..d2aedaf --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapIntKey.java @@ -0,0 +1,405 @@ +/*========================================================================= + * 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.cache.EntryEvent; +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.distributed.internal.membership.InternalDistributedMember; +import com.gemstone.gemfire.internal.cache.versions.VersionSource; +import com.gemstone.gemfire.internal.cache.versions.VersionStamp; +import com.gemstone.gemfire.internal.cache.versions.VersionTag; +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 VersionedThinDiskLRURegionEntryOffHeapIntKey extends VersionedThinDiskLRURegionEntryOffHeap { + public VersionedThinDiskLRURegionEntryOffHeapIntKey (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(VersionedThinDiskLRURegionEntryOffHeapIntKey.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(VersionedThinDiskLRURegionEntryOffHeapIntKey.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 + // versioned code + private VersionSource memberID; + private short entryVersionLowBytes; + private short regionVersionHighBytes; + private int regionVersionLowBytes; + private byte entryVersionHighByte; + private byte distributedSystemId; + public int getEntryVersion() { + return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF); + } + public long getRegionVersion() { + return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); + } + public long getVersionTimeStamp() { + return getLastModified(); + } + public void setVersionTimeStamp(long time) { + setLastModified(time); + } + public VersionSource getMemberID() { + return this.memberID; + } + public int getDistributedSystemId() { + return this.distributedSystemId; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public void setVersions(VersionTag tag) { + this.memberID = tag.getMemberID(); + int eVersion = tag.getEntryVersion(); + this.entryVersionLowBytes = (short)(eVersion & 0xffff); + this.entryVersionHighByte = (byte)((eVersion & 0xff0000) >> 16); + this.regionVersionHighBytes = tag.getRegionVersionHighBytes(); + this.regionVersionLowBytes = tag.getRegionVersionLowBytes(); + if (!(tag.isGatewayTag()) && this.distributedSystemId == tag.getDistributedSystemId()) { + if (getVersionTimeStamp() <= tag.getVersionTimeStamp()) { + setVersionTimeStamp(tag.getVersionTimeStamp()); + } else { + tag.setVersionTimeStamp(getVersionTimeStamp()); + } + } else { + setVersionTimeStamp(tag.getVersionTimeStamp()); + } + this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff); + } + public void setMemberID(VersionSource memberID) { + this.memberID = memberID; + } + @Override + public VersionStamp getVersionStamp() { + return this; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public VersionTag asVersionTag() { + VersionTag tag = VersionTag.create(memberID); + tag.setEntryVersion(getEntryVersion()); + tag.setRegionVersion(this.regionVersionHighBytes, this.regionVersionLowBytes); + tag.setVersionTimeStamp(getVersionTimeStamp()); + tag.setDistributedSystemId(this.distributedSystemId); + return tag; + } + public void processVersionTag(LocalRegion r, VersionTag tag, + boolean isTombstoneFromGII, boolean hasDelta, + VersionSource thisVM, InternalDistributedMember sender, boolean checkForConflicts) { + basicProcessVersionTag(r, tag, isTombstoneFromGII, hasDelta, thisVM, sender, checkForConflicts); + } + @Override + public void processVersionTag(EntryEvent cacheEvent) { + // this keeps Eclipse happy. without it the sender chain becomes confused + // while browsing this code + super.processVersionTag(cacheEvent); + } + /** get rvv internal high byte. Used by region entries for transferring to storage */ + public short getRegionVersionHighBytes() { + return this.regionVersionHighBytes; + } + /** get rvv internal low bytes. Used by region entries for transferring to storage */ + public int getRegionVersionLowBytes() { + return this.regionVersionLowBytes; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code + private final 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/VersionedThinDiskLRURegionEntryOffHeapLongKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapLongKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapLongKey.java new file mode 100644 index 0000000..73dfa19 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapLongKey.java @@ -0,0 +1,405 @@ +/*========================================================================= + * 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.cache.EntryEvent; +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.distributed.internal.membership.InternalDistributedMember; +import com.gemstone.gemfire.internal.cache.versions.VersionSource; +import com.gemstone.gemfire.internal.cache.versions.VersionStamp; +import com.gemstone.gemfire.internal.cache.versions.VersionTag; +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 VersionedThinDiskLRURegionEntryOffHeapLongKey extends VersionedThinDiskLRURegionEntryOffHeap { + public VersionedThinDiskLRURegionEntryOffHeapLongKey (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(VersionedThinDiskLRURegionEntryOffHeapLongKey.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(VersionedThinDiskLRURegionEntryOffHeapLongKey.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 + // versioned code + private VersionSource memberID; + private short entryVersionLowBytes; + private short regionVersionHighBytes; + private int regionVersionLowBytes; + private byte entryVersionHighByte; + private byte distributedSystemId; + public int getEntryVersion() { + return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF); + } + public long getRegionVersion() { + return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); + } + public long getVersionTimeStamp() { + return getLastModified(); + } + public void setVersionTimeStamp(long time) { + setLastModified(time); + } + public VersionSource getMemberID() { + return this.memberID; + } + public int getDistributedSystemId() { + return this.distributedSystemId; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public void setVersions(VersionTag tag) { + this.memberID = tag.getMemberID(); + int eVersion = tag.getEntryVersion(); + this.entryVersionLowBytes = (short)(eVersion & 0xffff); + this.entryVersionHighByte = (byte)((eVersion & 0xff0000) >> 16); + this.regionVersionHighBytes = tag.getRegionVersionHighBytes(); + this.regionVersionLowBytes = tag.getRegionVersionLowBytes(); + if (!(tag.isGatewayTag()) && this.distributedSystemId == tag.getDistributedSystemId()) { + if (getVersionTimeStamp() <= tag.getVersionTimeStamp()) { + setVersionTimeStamp(tag.getVersionTimeStamp()); + } else { + tag.setVersionTimeStamp(getVersionTimeStamp()); + } + } else { + setVersionTimeStamp(tag.getVersionTimeStamp()); + } + this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff); + } + public void setMemberID(VersionSource memberID) { + this.memberID = memberID; + } + @Override + public VersionStamp getVersionStamp() { + return this; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public VersionTag asVersionTag() { + VersionTag tag = VersionTag.create(memberID); + tag.setEntryVersion(getEntryVersion()); + tag.setRegionVersion(this.regionVersionHighBytes, this.regionVersionLowBytes); + tag.setVersionTimeStamp(getVersionTimeStamp()); + tag.setDistributedSystemId(this.distributedSystemId); + return tag; + } + public void processVersionTag(LocalRegion r, VersionTag tag, + boolean isTombstoneFromGII, boolean hasDelta, + VersionSource thisVM, InternalDistributedMember sender, boolean checkForConflicts) { + basicProcessVersionTag(r, tag, isTombstoneFromGII, hasDelta, thisVM, sender, checkForConflicts); + } + @Override + public void processVersionTag(EntryEvent cacheEvent) { + // this keeps Eclipse happy. without it the sender chain becomes confused + // while browsing this code + super.processVersionTag(cacheEvent); + } + /** get rvv internal high byte. Used by region entries for transferring to storage */ + public short getRegionVersionHighBytes() { + return this.regionVersionHighBytes; + } + /** get rvv internal low bytes. Used by region entries for transferring to storage */ + public int getRegionVersionLowBytes() { + return this.regionVersionLowBytes; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code + private final long key; + @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/VersionedThinDiskLRURegionEntryOffHeapObjectKey.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapObjectKey.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapObjectKey.java new file mode 100644 index 0000000..aec416b --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapObjectKey.java @@ -0,0 +1,398 @@ +/*========================================================================= + * 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.cache.EntryEvent; +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.distributed.internal.membership.InternalDistributedMember; +import com.gemstone.gemfire.internal.cache.versions.VersionSource; +import com.gemstone.gemfire.internal.cache.versions.VersionStamp; +import com.gemstone.gemfire.internal.cache.versions.VersionTag; +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 VersionedThinDiskLRURegionEntryOffHeapObjectKey extends VersionedThinDiskLRURegionEntryOffHeap { + public VersionedThinDiskLRURegionEntryOffHeapObjectKey (RegionEntryContext context, Object key, + @Retained + Object value + ) { + super(context, + (value instanceof RecoveredEntry ? null : value) + ); + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + initialize(context, value); + this.key = key; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // common code + protected int hash; + private HashEntry next; + @SuppressWarnings("unused") + private volatile long lastModified; + private static final AtomicLongFieldUpdater lastModifiedUpdater + = AtomicLongFieldUpdater.newUpdater(VersionedThinDiskLRURegionEntryOffHeapObjectKey.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(VersionedThinDiskLRURegionEntryOffHeapObjectKey.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() { + // default implementation. + return getKey(); + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // versioned code + private VersionSource memberID; + private short entryVersionLowBytes; + private short regionVersionHighBytes; + private int regionVersionLowBytes; + private byte entryVersionHighByte; + private byte distributedSystemId; + public int getEntryVersion() { + return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF); + } + public long getRegionVersion() { + return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); + } + public long getVersionTimeStamp() { + return getLastModified(); + } + public void setVersionTimeStamp(long time) { + setLastModified(time); + } + public VersionSource getMemberID() { + return this.memberID; + } + public int getDistributedSystemId() { + return this.distributedSystemId; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public void setVersions(VersionTag tag) { + this.memberID = tag.getMemberID(); + int eVersion = tag.getEntryVersion(); + this.entryVersionLowBytes = (short)(eVersion & 0xffff); + this.entryVersionHighByte = (byte)((eVersion & 0xff0000) >> 16); + this.regionVersionHighBytes = tag.getRegionVersionHighBytes(); + this.regionVersionLowBytes = tag.getRegionVersionLowBytes(); + if (!(tag.isGatewayTag()) && this.distributedSystemId == tag.getDistributedSystemId()) { + if (getVersionTimeStamp() <= tag.getVersionTimeStamp()) { + setVersionTimeStamp(tag.getVersionTimeStamp()); + } else { + tag.setVersionTimeStamp(getVersionTimeStamp()); + } + } else { + setVersionTimeStamp(tag.getVersionTimeStamp()); + } + this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff); + } + public void setMemberID(VersionSource memberID) { + this.memberID = memberID; + } + @Override + public VersionStamp getVersionStamp() { + return this; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public VersionTag asVersionTag() { + VersionTag tag = VersionTag.create(memberID); + tag.setEntryVersion(getEntryVersion()); + tag.setRegionVersion(this.regionVersionHighBytes, this.regionVersionLowBytes); + tag.setVersionTimeStamp(getVersionTimeStamp()); + tag.setDistributedSystemId(this.distributedSystemId); + return tag; + } + public void processVersionTag(LocalRegion r, VersionTag tag, + boolean isTombstoneFromGII, boolean hasDelta, + VersionSource thisVM, InternalDistributedMember sender, boolean checkForConflicts) { + basicProcessVersionTag(r, tag, isTombstoneFromGII, hasDelta, thisVM, sender, checkForConflicts); + } + @Override + public void processVersionTag(EntryEvent cacheEvent) { + // this keeps Eclipse happy. without it the sender chain becomes confused + // while browsing this code + super.processVersionTag(cacheEvent); + } + /** get rvv internal high byte. Used by region entries for transferring to storage */ + public short getRegionVersionHighBytes() { + return this.regionVersionHighBytes; + } + /** get rvv internal low bytes. Used by region entries for transferring to storage */ + public int getRegionVersionLowBytes() { + return this.regionVersionLowBytes; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code + private final Object key; + @Override + public final Object getKey() { + return this.key; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/31d1b20e/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapStringKey1.java ---------------------------------------------------------------------- diff --git a/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapStringKey1.java b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapStringKey1.java new file mode 100644 index 0000000..870c779 --- /dev/null +++ b/gemfire-core/src/main/java/com/gemstone/gemfire/internal/cache/VersionedThinDiskLRURegionEntryOffHeapStringKey1.java @@ -0,0 +1,467 @@ +/*========================================================================= + * 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.cache.EntryEvent; +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.distributed.internal.membership.InternalDistributedMember; +import com.gemstone.gemfire.internal.cache.versions.VersionSource; +import com.gemstone.gemfire.internal.cache.versions.VersionStamp; +import com.gemstone.gemfire.internal.cache.versions.VersionTag; +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 VersionedThinDiskLRURegionEntryOffHeapStringKey1 extends VersionedThinDiskLRURegionEntryOffHeap { + public VersionedThinDiskLRURegionEntryOffHeapStringKey1 (RegionEntryContext context, String key, + @Retained + Object value + , boolean byteEncode + ) { + super(context, + (value instanceof RecoveredEntry ? null : value) + ); + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + initialize(context, value); + // caller has already confirmed that key.length <= MAX_INLINE_STRING_KEY + long tmpBits1 = 0L; + if (byteEncode) { + for (int i=key.length()-1; i >= 0; i--) { + // Note: we know each byte is <= 0x7f so the "& 0xff" is not needed. But I added it in to keep findbugs happy. + tmpBits1 |= (byte)key.charAt(i) & 0xff; + 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(VersionedThinDiskLRURegionEntryOffHeapStringKey1.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(VersionedThinDiskLRURegionEntryOffHeapStringKey1.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 + // versioned code + private VersionSource memberID; + private short entryVersionLowBytes; + private short regionVersionHighBytes; + private int regionVersionLowBytes; + private byte entryVersionHighByte; + private byte distributedSystemId; + public int getEntryVersion() { + return ((entryVersionHighByte << 16) & 0xFF0000) | (entryVersionLowBytes & 0xFFFF); + } + public long getRegionVersion() { + return (((long)regionVersionHighBytes) << 32) | (regionVersionLowBytes & 0x00000000FFFFFFFFL); + } + public long getVersionTimeStamp() { + return getLastModified(); + } + public void setVersionTimeStamp(long time) { + setLastModified(time); + } + public VersionSource getMemberID() { + return this.memberID; + } + public int getDistributedSystemId() { + return this.distributedSystemId; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public void setVersions(VersionTag tag) { + this.memberID = tag.getMemberID(); + int eVersion = tag.getEntryVersion(); + this.entryVersionLowBytes = (short)(eVersion & 0xffff); + this.entryVersionHighByte = (byte)((eVersion & 0xff0000) >> 16); + this.regionVersionHighBytes = tag.getRegionVersionHighBytes(); + this.regionVersionLowBytes = tag.getRegionVersionLowBytes(); + if (!(tag.isGatewayTag()) && this.distributedSystemId == tag.getDistributedSystemId()) { + if (getVersionTimeStamp() <= tag.getVersionTimeStamp()) { + setVersionTimeStamp(tag.getVersionTimeStamp()); + } else { + tag.setVersionTimeStamp(getVersionTimeStamp()); + } + } else { + setVersionTimeStamp(tag.getVersionTimeStamp()); + } + this.distributedSystemId = (byte)(tag.getDistributedSystemId() & 0xff); + } + public void setMemberID(VersionSource memberID) { + this.memberID = memberID; + } + @Override + public VersionStamp getVersionStamp() { + return this; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + public VersionTag asVersionTag() { + VersionTag tag = VersionTag.create(memberID); + tag.setEntryVersion(getEntryVersion()); + tag.setRegionVersion(this.regionVersionHighBytes, this.regionVersionLowBytes); + tag.setVersionTimeStamp(getVersionTimeStamp()); + tag.setDistributedSystemId(this.distributedSystemId); + return tag; + } + public void processVersionTag(LocalRegion r, VersionTag tag, + boolean isTombstoneFromGII, boolean hasDelta, + VersionSource thisVM, InternalDistributedMember sender, boolean checkForConflicts) { + basicProcessVersionTag(r, tag, isTombstoneFromGII, hasDelta, thisVM, sender, checkForConflicts); + } + @Override + public void processVersionTag(EntryEvent cacheEvent) { + // this keeps Eclipse happy. without it the sender chain becomes confused + // while browsing this code + super.processVersionTag(cacheEvent); + } + /** get rvv internal high byte. Used by region entries for transferring to storage */ + public short getRegionVersionHighBytes() { + return this.regionVersionHighBytes; + } + /** get rvv internal low bytes. Used by region entries for transferring to storage */ + public int getRegionVersionLowBytes() { + return this.regionVersionLowBytes; + } + // DO NOT modify this class. It was generated from LeafRegionEntry.cpp + // key code + private final long bits1; + private 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 +}