com.gemstone.gemfire.internal.cache.VMThinDiskLRURegionEntryOffHeap Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gemfire-core Show documentation
Show all versions of gemfire-core Show documentation
SnappyData store based off Pivotal GemFireXD
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you
* may not use this file except in compliance with the License. You
* may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.internal.cache;
// DO NOT modify this class. It was generated from LeafRegionEntry.cpp
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
import com.gemstone.gemfire.internal.concurrent.AtomicUpdaterFactory;
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.cache.lru.EnableLRU;
import com.gemstone.gemfire.internal.cache.persistence.DiskRecoveryStore;
import com.gemstone.gemfire.internal.cache.lru.LRUClockNode;
import com.gemstone.gemfire.internal.concurrent.CustomEntryConcurrentHashMap.HashEntry;
import com.gemstone.gemfire.internal.size.ReflectionSingleObjectSizer;
// macros whose definition changes this class:
// disk: DISK
// lru: LRU
// stats: STATS
// versioned: VERSIONED
// offheap: OFFHEAP
// rowlocation: ROWLOCATION
// local: LOCAL
// bucket: BUCKET
// package: PKG
/**
* 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.
*/
@SuppressWarnings("serial")
public class VMThinDiskLRURegionEntryOffHeap extends VMThinDiskLRURegionEntry
implements OffHeapRegionEntry
{
public VMThinDiskLRURegionEntryOffHeap (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
= AtomicUpdaterFactory.newLongFieldUpdater(VMThinDiskLRURegionEntryOffHeap.class, "lastModified");
protected long getlastModifiedField() {
return lastModifiedUpdater.get(this);
}
protected boolean compareAndSetLastModifiedField(long expectedValue, long newValue) {
return lastModifiedUpdater.compareAndSet(this, expectedValue, newValue);
}
/**
* @see HashEntry#getEntryHash()
*/
@Override
public final int getEntryHash() {
return this.hash;
}
@Override
protected void setEntryHash(int v) {
this.hash = v;
}
/**
* @see HashEntry#getNextEntry()
*/
@Override
public final HashEntry getNextEntry() {
return this.next;
}
/**
* @see HashEntry#setNextEntry
*/
@Override
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 = getKeySize(getRawKey(), capacityController);
setEntrySize(newSize);
int delta = newSize - oldSize;
return delta;
}
private final int getKeySize(Object key, EnableLRU capacityController) {
final GemFireCacheImpl.StaticSystemCallbacks sysCb =
GemFireCacheImpl.getInternalProductCallbacks();
if (sysCb == null || capacityController.getEvictionAlgorithm().isLRUEntry()) {
return capacityController.entrySize(key, null);
}
else {
int tries = 1;
do {
final int size = sysCb.entryKeySizeInBytes(key, this);
if (size >= 0) {
/* reduce the ExtraInfo reference size */
return size - ReflectionSingleObjectSizer.REFERENCE_SIZE;
}
if ((tries % MAX_READ_TRIES_YIELD) == 0) {
// enough tries; give other threads a chance to proceed
Thread.yield();
}
} while (tries++ <= MAX_READ_TRIES);
throw sysCb.checkCacheForNullKeyValue("DiskLRU RegionEntry#getKeySize");
}
}
// 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
public void setDiskId(RegionEntry old) {
this.id = ((AbstractDiskRegionEntry)old).getDiskId();
}
// 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(getRawKey(), value);
// GemFireCacheImpl.getInstance().getLoggerI18n().info("DEBUG updateEntrySize: oldSize=" + oldSize
// + " newSize=" + newSize);
setEntrySize(newSize);
int delta = newSize - oldSize;
// if ( debug ) log( "updateEntrySize key=" + getRawKey()
// + (_getValue() == Token.INVALID ? " invalid" :
// (_getValue() == Token.LOCAL_INVALID ? "local_invalid" :
// (_getValue()==null ? " evicted" : " valid")))
// + " oldSize=" + oldSize
// + " newSize=" + this.size );
return delta;
}
// DO NOT modify this class. It was generated from LeafRegionEntry.cpp
private LRUClockNode nextLRU;
private LRUClockNode prevLRU;
//private int refCount;
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;
}
/*
public final synchronized int getRefCount() {
return this.refCount;
}
public final synchronized void incRefCount() {
this.refCount++;
// removal from the LruList is performed as part
// of the eviction process (getHeadEntry())
}
// DO NOT modify this class. It was generated from LeafRegionEntry.cpp
public final synchronized void decRefCount(NewLRUClockHand lruList) {
if (this.refCount > 0) {
this.refCount--;
if (this.refCount == 0) {
// No more transactions, place in lru list
lruList.appendEntry(this);
}
}
}
public final synchronized void resetRefCount(NewLRUClockHand lruList) {
if (this.refCount > 0) {
this.refCount = 0;
lruList.appendEntry(this);
}
}
*/
//@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;
//}
// DO NOT modify this class. It was generated from LeafRegionEntry.cpp
// key code
private Object key;
@Override
public final Object getRawKey() {
return this.key;
}
@Override
protected void _setRawKey(Object key) {
this.key = key;
}
/**
* All access done using ohAddrUpdater so it is used even though the compiler can not tell it is.
*/
@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 =
AtomicUpdaterFactory.newLongFieldUpdater(VMThinDiskLRURegionEntryOffHeap.class, "ohAddress");
// DO NOT modify this class. It was generated from LeafRegionEntry.cpp
@Override
public Token getValueAsToken() {
return OffHeapRegionEntryHelper.getValueAsToken(this);
}
@Override
@Unretained
protected Object getValueField() {
return OffHeapRegionEntryHelper._getValue(this);
}
@Override
protected void setValueField(@Unretained Object v) {
OffHeapRegionEntryHelper.setValue(this, v);
}
@Override
@Retained
public Object _getValueRetain(RegionEntryContext context, boolean decompress) {
return OffHeapRegionEntryHelper._getValueRetain(this, decompress);
}
@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);
}
// DO NOT modify this class. It was generated from LeafRegionEntry.cpp
private static RegionEntryFactory factory = new RegionEntryFactory() {
public final RegionEntry createEntry(RegionEntryContext context, Object key, Object value) {
return new VMThinDiskLRURegionEntryOffHeap(context, key, value);
}
public final Class getEntryClass() {
return VMThinDiskLRURegionEntryOffHeap.class;
}
public RegionEntryFactory makeVersioned() {
return VMThinDiskLRURegionEntryOffHeap.getEntryFactory();
}
@Override
public RegionEntryFactory makeOnHeap() {
return VMThinDiskLRURegionEntryHeap.getEntryFactory();
}
};
public static RegionEntryFactory getEntryFactory() {
return factory;
}
// DO NOT modify this class. It was generated from LeafRegionEntry.cpp
}