*
* Note that this method can throw Failure if any exception
* is thrown while eating memory. To avoid OOM while allocating
* exception we preallocate it before the lunch starts. It means
* that exception stack trace does not correspond to the place
* where exception is thrown, but points at start of the method.
*
* This method uses nsk.share.test.Stresser class to control
* it's execution. Consumed number of iterations depends on
* available memory.
*
* @throws nsk.share.Failure if any unexpected exception is
* thrown during allocating of the objects.
*
* @see nsk.share.test.Stresser
*/
public static void eatMemory(ExecutionController stresser) {
GarbageUtils.eatMemory(stresser, 50, MIN_MEMORY_CHUNK, 2);
}
/**
* Calculates and returns recomended number of threads to start in the
* particular machine (with particular amount of memory and number of CPUs).
* The returned value is minimum of two values:
* {@link #THREADS_MANAGED_BY_ONE_CPU} * (number of processors) and
* {@link #THREADS_MANAGED_BY_ONE_BLOCK} * (number of blocks of the memory).
*
* @return recomended number of threads to start.
*
*/
public static int getThreadsCount() {
Runtime runtime = Runtime.getRuntime();
int processors = runtime.availableProcessors();
long maxMemory = runtime.maxMemory();
long blocks = Math.round((double) maxMemory / BLOCK_SIZE);
return (int) Math.min(THREADS_MANAGED_BY_ONE_CPU * processors,
THREADS_MANAGED_BY_ONE_BLOCK * blocks);
}
/**
* Returns the number of processors available to the Java virtual machine.
*
* @return number of processors available to the Java virtual machine.
*
* @see Runtime#availableProcessors
*
*/
public static int availableProcessors() {
Runtime runtime = Runtime.getRuntime();
return runtime.availableProcessors();
}
/**
* Makes a few attempts to print the string into specified PrintStream.
* If PrintStream.println(String) throws OutOfMemoryError,
* the method waits for a few milliseconds and repeats the attempt.
*
* @param out PrintStream to print the string.
* @param s the string to print.
*/
public static void tryToPrintln(PrintStream out, String s) {
for (int i = 0; i < ATTEMPTS_TO_PRINT; i++) {
try {
out.println(s);
// The string is printed into the PrintStream
return;
} catch (OutOfMemoryError e) {
// Catch the error and wait for a while
synchronized(object) {
try {
object.wait(500);
} catch (InterruptedException ie) {
// Ignore the exception
}
} // synchronized
}
}
} // tryToPrintln()
/**
* Makes a few attempts to print each stack trace of Throwable
* into specified PrintStream. If PrintStream.println(String)
* throws OutOfMemoryError, the method waits for a few milliseconds and
* repeats the attempt.
*
* @param out PrintStream to print the string.
* @param t the throwable to print.
*
* @see #tryToPrintln
*/
public static void tryToPrintStack(PrintStream out, Throwable t) {
StackTraceElement[] trace = t.getStackTrace();
for (int i = 0; i < trace.length; i++) {
for (int j = 0; j < ATTEMPTS_TO_PRINT; j++) {
try {
out.println(trace[i].toString());
// The string is printed into the PrintStream
return;
} catch (OutOfMemoryError e) {
// Catch the error and wait for a while
synchronized(object) {
try {
object.wait(500);
} catch (InterruptedException ie) {
// Ignore the exception
}
} // synchronized
} // try
} // for j
} // for i
} // tryToPrintStack()
/**
* Returns recommended size for an array. Default implemetation returns
* minimum between size and
* {@link #MAX_ARRAY_SIZE MAX_ARRAY_SIZE}.
*
* @return recommended size for an array.
*
*/
public static int getArraySize(long size) {
long min = Math.min(MAX_ARRAY_SIZE, size);
return (int) min;
} // getArraySize()
} // class Algorithms