// MemoryControl.java
// -------------------------------------------
// (C) 2011 by Sebastian Gaebel
// first published 22.08.2011 on http://yacy.net
//
// $LastChangedDate: 2011-08-18 00:24:17 +0200 (Do, 18. Aug 2011) $
// $LastChangedRevision: 7883 $
// $LastChangedBy: orbiter $
//
// LICENSE
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
package net.yacy.kelondro.util;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryPoolMXBean;
import java.lang.management.MemoryUsage;
import java.util.concurrent.atomic.AtomicBoolean;
public class GenerationMemoryStrategy extends MemoryStrategy {
private final static long M = 1024l*1024l;
private MemoryPoolMXBean eden, survivor, old;
private MemoryMXBean heap;
public GenerationMemoryStrategy() {
name = "Generation Memory Strategy";
error = initPoolBeans();
heap = ManagementFactory.getMemoryMXBean();
if (lastGC == 0l) gc(10000, "initial gc - to get proper results"); // this is necessary on some GCs / vm
if (error) log.warn(name + ": not a generational heap");
}
/**
* memory that is free without increasing of total memory taken from os
* @return bytes
*/
@Override
protected final long free() {
return youngAvailable();
}
/**
* memory that is available including increasing total memory up to maximum
* Smallest of both old and young
* @return bytes
*/
@Override
protected final long available() {
return available(false);
}
/**
* memory that is available including increasing total memory up to maximum
* @param force specifies whether ignoring prefered size
* @return bytes
*/
private final long available(final boolean force) {
return force & properState(force) ? Math.max(youngAvailable(), oldAvailable()) : oldAvailable();
}
/**
* memory that is currently bound in objects
* @return used bytes
*/
@Override
protected final long used() {
return heap.getHeapMemoryUsage().getUsed();
}
/**
* currently allocated memory in the Java virtual machine; may vary over time
* @return bytes
*/
@Override
protected final long total() {
return heap.getHeapMemoryUsage().getCommitted();
}
/**
* maximum memory the Java virtual will allocate machine; may vary over time in some cases
* @return bytes
*/
@Override
protected final long maxMemory() {
return heap.getHeapMemoryUsage().getMax();
}
/**
* get the memory that needs to be available for properState
*/
protected final long minMemory()
{
return getUsage(eden, true).getUsed();
}
/**
* checks if a specified amount of bytes are available
* after the jvm recycled unused objects
*
* @param size the requested amount of free memory in bytes
* @param force specifies whether ignoring preferred size
* @return whether enough memory could be freed (or is free) or not
*/
@Override
protected final boolean request(final long size, final boolean force, AtomicBoolean shortStatus) {
if (size == 0l) return true; // does not make sense to check - returning true without setting shortStatus (which also doesn't make sense to me)
final boolean unknown = size < 0l; // size < 0 indicate an unknown size - maybe from gziped streams
final boolean r = unknown ? properState(force) : size < available(force);
shortStatus.set(!r);
return r;
}
/**
* use this to check for temporary space
* @return bytes available to allocate in Eden Space (Young Generation)
*/
private final long youngAvailable() {
final MemoryUsage usage = getUsage(eden, true);
return usage.getCommitted() - usage.getUsed();
}
/**
* @return bytes available to allocate in Tenured Space (Old Generation)
*/
private final long oldAvailable() {
final MemoryUsage usage = getUsage(old, true);
return Math.max(usage.getMax(), usage.getCommitted()) - usage.getUsed();
}
/**
* alive objects get 'moved' on gc from eden space to survior and from survior to old gen
* in a worse case (all objects of survivor alive) all objects get 'moved' from suvivor to old gen
* this method checks if there is is space left in old gen for that
*
* @return Memory is in proper state
*/
@Override
protected boolean properState() {
return properState(false);
}
/**
* @param force whether using used or committed survivor usage
* @return if survivor fits into old space
*/
private boolean properState(final boolean force) {
final long surv = force? M + getUsage(survivor, false).getUsed() : getUsage(survivor, false).getCommitted();
return surv < oldAvailable();
}
/**
* based on my research for a proper running jvm, this gives a guidance value for the heap size
*
* @return bytes recommend for heap size
*/
protected long recommendHeapSize() {
// the heap/old-ration is jvm-specific and can be changed by parameter - using this + 20% buffer
final double factor = 1.2 * heap.getHeapMemoryUsage().getMax() / getUsage(old, false).getMax();
// current needed space in old gen
final long neededOld = getUsage(old, true).getUsed() + getUsage(survivor, false).getMax();
return (long) (neededOld * factor);
}
/**
* @param collected specifies whether trying to get the memory usage after the jvm recycled unused objects
* @return MemoryUsage of given MemoryPoolMXBean
*/
private MemoryUsage getUsage(final MemoryPoolMXBean bean, final boolean collected) {
if (collected) {
try {
final MemoryUsage usage = bean.getCollectionUsage();
if (usage != null) return usage;
} catch (final IllegalArgumentException e) {
log.warn(name + ": ", e);
}
error = true;
log.warn(name + ": no colletion usage available at " + bean.getName());
}
return bean.getUsage();
}
private boolean initPoolBeans() {
for (final MemoryPoolMXBean bean : ManagementFactory.getMemoryPoolMXBeans()) {
if (bean.getName().startsWith("G1")) break; //this strategy will not run on G1
if (bean.getName().contains("Eden")) {
eden = bean;
} else if (bean.getName().contains("Survivor")) {
survivor = bean;
} else if (bean.getName().contains("Old") || bean.getName().contains("Tenured")) {
old = bean;
}
}
return eden == null || survivor == null || old == null;
}
}