public void setEvictionAttributes(AttributesFactory afact) throws StandardException { EvictionAttributes evictAttr; ObjectSizer osizer = Misc.getMemStore().getObjectSizer(); if (this.evictAction == null) { this.evictAction = EvictionAction.DEFAULT_EVICTION_ACTION; } switch (this.lruType) { case EvictionTableAttribute.ID_MEMSIZE: evictAttr = EvictionAttributes.createLRUMemoryAttributes(this.count, osizer, this.evictAction); break; case EvictionTableAttribute.ID_HEAPPERCENT: evictAttr = EvictionAttributes.createLRUHeapAttributes(osizer, this.evictAction); break; case EvictionTableAttribute.ID_COUNT: evictAttr = EvictionAttributes.createLRUEntryAttributes(this.count, this.evictAction); break; default: throw StandardException.newException(SQLState.PROPERTY_SYNTAX_INVALID + ": unknown eviction type " + this.lruType); } afact.setEvictionAttributes(evictAttr); } }
@Override public String toString() { final StringBuilder buffer = new StringBuilder(128); buffer.append(" algorithm=").append(this.getAlgorithm()); if (!this.getAlgorithm().isNone()) { buffer.append("; action=").append(this.getAction()); if (!getAlgorithm().isLRUHeap()) { buffer.append("; maximum=").append(this.getMaximum()); } if (this.getObjectSizer() != null) { buffer.append("; sizer=").append(this.getObjectSizer()); } } return buffer.toString(); }
public EvictionAttributesInfo(EvictionAttributes ea) { EvictionAction evictAction = ea.getAction(); if (evictAction != null) { evictionAction = evictAction.toString(); } EvictionAlgorithm evictionAlgo = ea.getAlgorithm(); if (evictionAlgo != null){ evictionAlgorithm = evictionAlgo.toString(); } evictionMaxValue = ea.getMaximum(); }
@Override public final int hashCode() { if (getAlgorithm().isLRUHeap()) { return getAlgorithm().hashCode(); } else { return this.getAlgorithm().hashCode() ^ this.getMaximum(); } }
/** * Create an <code>lru-heap-percentage</code> eviction controller, assigning * it to the enclosed <code>region-attributes</code> * @param atts */ private void startLRUHeapPercentage(Attributes atts) { final String lruAction = atts.getValue(ACTION); EvictionAction action = EvictionAction.DEFAULT_EVICTION_ACTION; if (lruAction != null) { action = EvictionAction.parseAction(lruAction); } // Store for later addition of ObjectSizer, if any stack.push(EvictionAttributes.createLRUHeapAttributes(null, action)); }
public void run() { Cache cache = getCache(); RegionFactory rf = cache.createRegionFactory(RegionShortcut.REPLICATE); rf.setEvictionAttributes(EvictionAttributes.createLRUEntryAttributes(count, EvictionAction.OVERFLOW_TO_DISK)); rf.create("region"); } });
private boolean isEvictionActionLocalDestroy() { PartitionedRegion pr = owner.getPartitionedRegion(); if (pr.getEvictionAttributes() != null) { return pr.getEvictionAttributes().getAction() == EvictionAction.LOCAL_DESTROY; } return false; }
/** * Start the configuration of a <code>lru-memory-size</code> eviction controller. Allow * for any of the attributes to be missing. Store the attributes on the stack * anticipating the declaration of an {@link ObjectSizer}. * @param atts */ private void startLRUMemorySize(Attributes atts) { String lruAction = atts.getValue(ACTION); EvictionAction action = EvictionAction.DEFAULT_EVICTION_ACTION; if(lruAction != null){ action = EvictionAction.parseAction(lruAction); } String maximum = atts.getValue(MAXIMUM); int max = MemLRUCapacityController.DEFAULT_MAXIMUM_MEGABYTES; if (maximum != null) { max = parseInt(maximum); } // Store for later addition of ObjectSizer, if any (the cast is for clarity sake) stack.push(EvictionAttributes.createLRUMemoryAttributes(max, null, action)); }
protected boolean includeLocalRegion(LocalRegion region) { return (region.getEvictionAttributes().getAlgorithm().isLRUHeap() && region.getAttributes().getOffHeap()); }
public void run() { final AttributesFactory factory = new AttributesFactory(); factory.setEnableOffHeapMemory(isOffHeap()); factory.setPartitionAttributes(new PartitionAttributesFactory() .setRedundantCopies(redundantCopies).create()); final EvictionAttributes ea = EvictionAttributes.createLRUEntryAttributes(firstEvictionAttributes.getMaximum()+10, firstEvictionAttributes.getAction()); factory.setEvictionAttributes(ea); final Region pr = createRootRegion(name, factory.create()); assertNotNull(pr); } };
public int getSizeForEviction() { EvictionAttributes ea = this.getAttributes().getEvictionAttributes(); if (ea == null) return 0; EvictionAlgorithm algo = ea.getAlgorithm(); if (!algo.isLRUHeap()) return 0; EvictionAction action = ea.getAction(); int size = action.isLocalDestroy() ? this.getRegionMap().sizeInVM() : (int)this .getNumEntriesInVM(); return size; } @Override
maximum = Integer.valueOf(EvictionAttributes.createLRUMemoryAttributes().getMaximum()); sizer = EvictionAttributes.createLRUMemoryAttributes().getObjectSizer(); return EvictionAttributes.createLRUMemoryAttributes(maximum.intValue(), sizer, action); } else if (sizer != null) { return EvictionAttributes.createLRUMemoryAttributes(maximum.intValue(), sizer); } else if (maximum != null) { return EvictionAttributes.createLRUMemoryAttributes(maximum.intValue()); } else { return EvictionAttributes.createLRUMemoryAttributes();
public void testHeapLRUEviction() throws Exception { final String name = getUniqueName(); beginCacheXml(); AttributesFactory factory = new AttributesFactory(); factory.setScope(Scope.LOCAL); EvictionAttributes ev = EvictionAttributes.createLRUHeapAttributes(null, EvictionAction.OVERFLOW_TO_DISK); factory.setEvictionAttributes(ev); // RegionAttributes atts = factory.create(); createRegion(name, factory.create()); finishCacheXml(getUniqueName(), getGemFireVersion()); Region r = getRootRegion().getSubregion(name); EvictionAttributes hlea = r.getAttributes().getEvictionAttributes(); assertEquals(EvictionAction.OVERFLOW_TO_DISK, hlea.getAction()); }
public String toString() { StringBuffer aStr = new StringBuffer(); aStr.append(super.toString() + "\n"); aStr.append(" entry evictor settings:\n"); aStr.append(" maximumEntries (in test instance): " + maximumEntries + "\n"); aStr.append(" maximumEntries (in evictor attr) : " + (CacheUtil.getRegion(REGION_NAME).getAttributes().getEvictionAttributes().getMaximum()) + "\n"); aStr.append(" Region limits:\n"); aStr.append(" lowestAllowableEntries: " + lowestAllowableEntries + "\n"); aStr.append(" highestAllowableEntries: " + highestAllowableEntries + "\n"); return aStr.toString(); }
protected static String getObjectSizer(EvictionAttributes ea) { Object o = ea.getObjectSizer(); if (o == null) { return "none"; } else { return o.getClass().getName(); } } }
public EvictionAttributesInfo(EvictionAttributes ea) { EvictionAction evictAction = ea.getAction(); if (evictAction != null) { evictionAction = evictAction.toString(); } EvictionAlgorithm evictionAlgo = ea.getAlgorithm(); if (evictionAlgo != null){ evictionAlgorithm = evictionAlgo.toString(); } evictionMaxValue = ea.getMaximum(); }
/** * Create an <code>lru-heap-percentage</code> eviction controller, assigning * it to the enclosed <code>region-attributes</code> * @param atts */ private void startLRUHeapPercentage(Attributes atts) { final String lruAction = atts.getValue(ACTION); EvictionAction action = EvictionAction.DEFAULT_EVICTION_ACTION; if (lruAction != null) { action = EvictionAction.parseAction(lruAction); } // Store for later addition of ObjectSizer, if any stack.push(EvictionAttributes.createLRUHeapAttributes(null, action)); }
public void testSetEvictionAttributes() throws CacheException, IOException { Cache c = createCache(); Region r1 = null; try { RegionFactory factory = c.createRegionFactory(LOCAL); r1 = factory.setEvictionAttributes(EvictionAttributes.createLRUEntryAttributes(77)).create(this.r1Name); RegionAttributes ra = r1.getAttributes(); assertEquals(EvictionAttributes.createLRUEntryAttributes(77), ra.getEvictionAttributes()); } finally { cleanUpRegion(r1); } }
private boolean isEvictionActionLocalDestroy() { PartitionedRegion pr = owner.getPartitionedRegion(); if (pr.getEvictionAttributes() != null) { return pr.getEvictionAttributes().getAction() == EvictionAction.LOCAL_DESTROY; } return false; }
/** * Start the configuration of a <code>lru-memory-size</code> eviction controller. Allow * for any of the attributes to be missing. Store the attributes on the stack * anticipating the declaration of an {@link ObjectSizer}. * @param atts */ private void startLRUMemorySize(Attributes atts) { String lruAction = atts.getValue(ACTION); EvictionAction action = EvictionAction.DEFAULT_EVICTION_ACTION; if(lruAction != null){ action = EvictionAction.parseAction(lruAction); } String maximum = atts.getValue(MAXIMUM); int max = MemLRUCapacityController.DEFAULT_MAXIMUM_MEGABYTES; if (maximum != null) { max = parseInt(maximum); } // Store for later addition of ObjectSizer, if any (the cast is for clarity sake) stack.push(EvictionAttributes.createLRUMemoryAttributes(max, null, action)); }