json.put("Maximum Elements on Disk", config.getMaxBytesLocalDisk()); json.put("Memory Store Eviction Policy", config.getMemoryStoreEvictionPolicy().toString()); json.put("Clean or Flush", config.isClearOnFlush());
private void init() { if (cacheConfiguration == null) { return; } addAttribute(new SimpleNodeAttribute("name", cacheConfiguration.getName()).optional(false)); addCommonAttributesWithDefaultCache(this, configuration, cacheConfiguration); addAttribute(new SimpleNodeAttribute("logging", cacheConfiguration.getLogging()).optional(true).defaultValue( CacheConfiguration.DEFAULT_LOGGING)); addCommonChildElementsWithDefaultCache(this, cacheConfiguration); if (cacheConfiguration.getMaxBytesLocalHeap() > 0 || cacheConfiguration.isMaxBytesLocalHeapPercentageSet()) { addAttribute(new SimpleNodeAttribute("maxBytesLocalHeap", cacheConfiguration.getMaxBytesLocalHeapAsString()) .optional(true).defaultValue(String.valueOf(CacheConfiguration.DEFAULT_MAX_BYTES_ON_HEAP))); } if (cacheConfiguration.getMaxBytesLocalOffHeap() > 0 || cacheConfiguration.isMaxBytesLocalOffHeapPercentageSet()) { addAttribute(new SimpleNodeAttribute("maxBytesLocalOffHeap", cacheConfiguration.getMaxBytesLocalOffHeapAsString()) .optional(true).defaultValue(String.valueOf(CacheConfiguration.DEFAULT_MAX_BYTES_OFF_HEAP))); } if (!cacheConfiguration.isTerracottaClustered() && (cacheConfiguration.getMaxBytesLocalDisk() > 0 || cacheConfiguration.isMaxBytesLocalDiskPercentageSet())) { addAttribute(new SimpleNodeAttribute("maxBytesLocalDisk", cacheConfiguration.getMaxBytesLocalDiskAsString()) .optional(true).defaultValue(String.valueOf(CacheConfiguration.DEFAULT_MAX_BYTES_ON_DISK))); } }
/** * Maximum number of bytes that may be stored in the local disk store. */ public long getMaxBytesLocalDisk() { return cacheConfiguration.getMaxBytesLocalDisk(); }
/** * The string form of the maximum amount of bytes the cache should occupy on disk * @return value as string in bytes */ public String getMaxBytesLocalDiskAsString() { return maxBytesLocalDiskInput != null ? maxBytesLocalDiskInput : Long.toString(getMaxBytesLocalDisk()); }
/** * {@inheritDoc} */ @Override public long getMaxBytesLocalDisk() { return cache.getCacheConfiguration().getMaxBytesLocalDisk(); }
private void verifyLocalDisk(final long managerMaxBytesLocalDisk, final List<ConfigError> configErrors, final long totalOnDiskAssignedMemory) { if ((isMaxBytesLocalDiskPercentageSet() || getMaxBytesLocalDisk() > 0) && managerMaxBytesLocalDisk > 0 && managerMaxBytesLocalDisk - totalOnDiskAssignedMemory < 0) { configErrors.add(new ConfigError("Cache '" + getName() + "' over-allocates CacheManager's localOnDisk limit!")); } }
/** * Returns a {@link String} representation of {@link Cache}. */ @Override public String toString() { StringBuilder dump = new StringBuilder(); dump.append("[") .append(" name = ").append(configuration.getName()) .append(" status = ").append(cacheStatus.getStatus()) .append(" eternal = ").append(configuration.isEternal()) .append(" overflowToDisk = ").append(configuration.isOverflowToDisk()) .append(" maxEntriesLocalHeap = ").append(configuration.getMaxEntriesLocalHeap()) .append(" maxEntriesLocalDisk = ").append(configuration.getMaxEntriesLocalDisk()) .append(" memoryStoreEvictionPolicy = ").append(configuration.getMemoryStoreEvictionPolicy()) .append(" timeToLiveSeconds = ").append(configuration.getTimeToLiveSeconds()) .append(" timeToIdleSeconds = ").append(configuration.getTimeToIdleSeconds()) .append(" persistence = ").append(configuration.getPersistenceConfiguration() == null ? "none" : configuration.getPersistenceConfiguration().getStrategy()) .append(" diskExpiryThreadIntervalSeconds = ").append(configuration.getDiskExpiryThreadIntervalSeconds()) .append(registeredEventListeners) .append(" maxBytesLocalHeap = ").append(configuration.getMaxBytesLocalHeap()) .append(" overflowToOffHeap = ").append(configuration.isOverflowToOffHeap()) .append(" maxBytesLocalOffHeap = ").append(configuration.getMaxBytesLocalOffHeap()) .append(" maxBytesLocalDisk = ").append(configuration.getMaxBytesLocalDisk()) .append(" pinned = ") .append(configuration.getPinningConfiguration() != null ? configuration.getPinningConfiguration().getStore().name() : "false") .append(" ]"); return dump.toString(); }
private void warnTieredSizing() { if (isOverflowToOffHeap()) { if (getMaxBytesLocalHeap() >= getMaxBytesLocalOffHeap() && getMaxBytesLocalOffHeap() != 0) { LOG.warn("Configuration problem for cache " + getName() + ": MaxBytesLocalHeap equal or greater than MaxBytesLocalOffHeap. " + "This will result in useless off heap storage."); } if (isOverflowToDisk()) { if (getMaxBytesLocalOffHeap() >= getMaxBytesLocalDisk() && getMaxBytesLocalDisk() != 0) { LOG.warn("Configuration problem for cache " + getName() + ": MaxBytesLocalOffHeap equal or greater than MaxBytesLocalDisk. " + "This will result in useless disk storage."); } } } if (isOverflowToDisk()) { if (getMaxEntriesLocalHeap() >= getMaxEntriesLocalDisk() && getMaxEntriesLocalDisk() != 0) { LOG.warn("Configuration problem for cache " + getName() + ": MaxEntriesLocalHeap equal or greater than MaxEntriesLocalDisk. " + "This will result in useless disk storage."); } } }
@Override void applyChange(final PropertyChangeEvent evt, final RuntimeCfg config) { Long newValue = (Long) evt.getNewValue(); Long oldValue = (Long) evt.getOldValue(); if (oldValue > newValue) { // Double check for over-allocation again validateOverAllocation(config, newValue); } long diskAllocated = 0; //Recalculating final free space available at global level for (Cache cache : getAllActiveCaches(config.cacheManager)) { cache.getCacheConfiguration().configCachePools(config.getConfiguration()); long bytesOnDiskPool = cache.getCacheConfiguration().getMaxBytesLocalDisk(); diskAllocated += bytesOnDiskPool; } config.cacheManager.getOnDiskPool().setMaxSize(newValue - diskAllocated); } };
totalOnHeapAssignedMemory += config.getMaxBytesLocalHeap(); totalOffHeapAssignedMemory += config.getMaxBytesLocalOffHeap(); totalOnDiskAssignedMemory += config.getMaxBytesLocalDisk(); totalOnHeapAssignedMemory += getMaxBytesLocalHeap(); totalOffHeapAssignedMemory += getMaxBytesLocalOffHeap(); totalOnDiskAssignedMemory += getMaxBytesLocalDisk();
@Override public void maxBytesLocalDiskChanged(final long oldValue, final long newValue) { if (getMaxBytesLocalDisk() > 0 && cacheManager.getConfiguration().getCacheConfigurations().keySet().contains(getName()) && cacheManager.getConfiguration().isMaxBytesLocalDiskSet()) { long previous = cacheManager.getOnDiskPool().getMaxSize(); long newPoolFreeSize = previous + oldValue - newValue; //handle case of overallocation of cache //Only resize the cache manager pool cache pool resizing will be handled by cache if (newPoolFreeSize >= 0) { cacheManager.getOnDiskPool().setMaxSize(newPoolFreeSize); } else { LOG.warn("Cannot allocate local disk size more than cache disk size, " + "setting maxBytesLocalDisk {} to old value {}", maxBytesLocalDisk, oldValue); maxBytesLocalDisk = oldValue; throw new InvalidConfigurationException("Cannot allocate disk size more than " + "the cache pool size reverting to previous size " + maxBytesLocalHeap); } } } }
/** * Maximum number of bytes that may be stored in the local disk store. */ public long getMaxBytesLocalDisk() { return cacheConfiguration.getMaxBytesLocalDisk(); }
/** * Removes a cache from the known list * @param cacheConfiguration the cacheConfiguration to be removed */ public void removeCache(final CacheConfiguration cacheConfiguration) { if (cacheManager.getOnHeapPool() != null) { cacheManager.getOnHeapPool().setMaxSize(cacheManager.getOnHeapPool() .getMaxSize() + cacheConfiguration.getMaxBytesLocalHeap()); } if (cacheManager.getOnDiskPool() != null) { cacheManager.getOnDiskPool().setMaxSize(cacheManager.getOnDiskPool() .getMaxSize() + cacheConfiguration.getMaxBytesLocalDisk()); } getConfiguration().getCacheConfigurations().remove(cacheConfiguration.getName()); }
private boolean skipUpdateAccessStatistics(Element element) { if (configuration.isFrozen()) { boolean forLifetime = element.isEternal(); boolean forHeap = configuration.getMaxEntriesLocalHeap() > 0 || configuration.getMaxBytesLocalHeap() > 0 || getCacheManager().getConfiguration().isMaxBytesLocalHeapSet(); boolean forDisk = configuration.isOverflowToDisk() && (configuration.getMaxEntriesLocalDisk() > 0 || configuration.getMaxBytesLocalDisk() > 0 || getCacheManager().getConfiguration().isMaxBytesLocalDiskSet()); return !(forLifetime || forHeap || forDisk); } else { return false; } }
private void updateCacheManagerPoolSizes(final CacheManager cacheManager) { if (cacheManager.getOnHeapPool() != null) { cacheManager.getOnHeapPool().setMaxSize(cacheManager.getOnHeapPool().getMaxSize() - getMaxBytesLocalHeap()); } if (cacheManager.getOnDiskPool() != null) { cacheManager.getOnDiskPool().setMaxSize(cacheManager.getOnDiskPool().getMaxSize() - getMaxBytesLocalDisk()); } }
/** * The string form of the maximum amount of bytes the cache should occupy on disk * @return value as string in bytes */ public String getMaxBytesLocalDiskAsString() { return maxBytesLocalDiskInput != null ? maxBytesLocalDiskInput : Long.toString(getMaxBytesLocalDisk()); }
private void freezePoolUsages(final CacheManager cacheManager) { if (getMaxBytesLocalHeap() > 0) { onHeapPoolUsage = CacheConfiguration.PoolUsage.Cache; } else if (cacheManager.getConfiguration().isMaxBytesLocalHeapSet()) { onHeapPoolUsage = CacheConfiguration.PoolUsage.CacheManager; } else { onHeapPoolUsage = CacheConfiguration.PoolUsage.None; } if (getMaxBytesLocalOffHeap() > 0) { offHeapPoolUsage = CacheConfiguration.PoolUsage.Cache; } else if (cacheManager.getConfiguration().isMaxBytesLocalOffHeapSet()) { offHeapPoolUsage = CacheConfiguration.PoolUsage.CacheManager; } else { offHeapPoolUsage = CacheConfiguration.PoolUsage.None; } if (isTerracottaClustered()) { onDiskPoolUsage = CacheConfiguration.PoolUsage.None; } else { if (getMaxBytesLocalDisk() > 0) { onDiskPoolUsage = CacheConfiguration.PoolUsage.Cache; } else if (cacheManager.getConfiguration().isMaxBytesLocalDiskSet()) { onDiskPoolUsage = CacheConfiguration.PoolUsage.CacheManager; } else { onDiskPoolUsage = CacheConfiguration.PoolUsage.None; } } }
overflowToDisk = true; if (overflowToDisk == null && cacheManager.getConfiguration().isMaxBytesLocalDiskSet() || getMaxBytesLocalDisk() > 0) { if (persistenceConfiguration != null && Strategy.LOCALRESTARTABLE.equals(persistenceConfiguration.getStrategy())) { throw new InvalidConfigurationException("Cannot use localRestartable persistence and disk overflow in the same cache");
if (configuration.getMaxBytesLocalDisk() > 0) { PoolEvictor evictor = new FromLargestCachePoolEvictor(); onDiskPool = new BoundedPool(configuration.getMaxBytesLocalDisk(), evictor, null); } else if (getCacheManager() != null && getCacheManager().getConfiguration().isMaxBytesLocalDiskSet()) { onDiskPool = getCacheManager().getOnDiskPool();
private void updateCacheManagerPoolSizes(final CacheManager cacheManager) { if (cacheManager.getOnHeapPool() != null) { cacheManager.getOnHeapPool().setMaxSize(cacheManager.getOnHeapPool().getMaxSize() - getMaxBytesLocalHeap()); } if (cacheManager.getOnDiskPool() != null) { cacheManager.getOnDiskPool().setMaxSize(cacheManager.getOnDiskPool().getMaxSize() - getMaxBytesLocalDisk()); } }