Tries to free a specified amount of bytes.
*
* If the currently available memory is enough, the method returns true without
* performing additional steps. If not, the behaviour depends on the parameter force.
* If false, a Full GC is only performed if former GCs indicated that a GC should
* provide enough free memory. If former GCs didn't but force is set to true
* a Full GC is performed nevertheless.
*
*
* Setting the force parameter to false doesn't necessarily mean, that no GC may be
* performed by this method, if the currently available memory doesn't suffice!
*
* Be careful with this method as GCs should always be the last measure to take
*
* @param size the requested amount of free memory in bytes
* @param force specifies whether a GC should be run even in case former GCs didn't provide enough memory
* @return whether enough memory could be freed (or is free) or not
*/
public static boolean request(final long size, final boolean force) {
long avail = available();
if (avail >= size) return true;
if (log.isFine()) {
String t = new Throwable("Stack trace").getStackTrace()[1].toString();
log.logFine(t + " requested " + (size >> 10) + " KB, got " + (avail >> 10) + " KB");
}
final long avg = getAverageGCFree();
if (force || avg == 0 || avg + avail >= size) {
// this is only called if we expect that an allocation of bytes would cause the jvm to call the GC anyway
final long freed = runGC(!force);
avail = available();
log.logInfo("performed " + ((force) ? "explicit" : "necessary") + " GC, freed " + (freed >> 10)
+ " KB (requested/available/average: "
+ (size >> 10) + " / " + (avail >> 10) + " / " + (avg >> 10) + " KB)");
return avail >= size;
} else {
log.logInfo("former GCs indicate to not be able to free enough memory (requested/available/average: "
+ (size >> 10) + " / " + (avail >> 10) + " / " + (avg >> 10) + " KB)");
return false;
}
}
/**
* memory that is currently bound in objects
* @return used bytes
*/
public static long used() {
return total() - free();
}
/**
* Formats a number if it are bytes to greatest unit (1024 based)
* @param byteCount
* @return formatted String with unit
*/
public static String bytesToString(long byteCount) {
try {
final StringBuffer byteString = new StringBuffer();
if (byteCount > 1073741824) {
byteString.append(yFormatter.number((double)byteCount / (double)1073741824 ))
.append(" GB");
} else if (byteCount > 1048576) {
byteString.append(yFormatter.number((double)byteCount / (double)1048576))
.append(" MB");
} else if (byteCount > 1024) {
byteString.append(yFormatter.number((double)byteCount / (double)1024))
.append(" KB");
} else {
byteString.append(Long.toString(byteCount))
.append(" Bytes");
}
return byteString.toString();
} catch (Exception e) {
return "unknown";
}
}
/**
* main
* @param args
*/
public static void main(String[] args) {
// try this with a jvm 1.4.2 and with a jvm 1.5 and compare results
int mb = 1024 * 1024;
System.out.println("vm: " + System.getProperty("java.vm.version"));
System.out.println("computed max = " + (max() / mb) + " mb");
int alloc = 10000;
byte[][] x = new byte[100000][];
for (int i = 0; i < 100000; i++) {
x[i] = new byte[alloc];
if (i % 100 == 0) System.out.println("used = " + (i * alloc / mb) +
", total = " + (total() / mb) +
", free = " + (free() / mb) +
", max = " + (max() / mb) +
", avail = " + (available() / mb));
}
}
}