/*
* Copyright (c) 2007, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package nsk.share.gc.gp;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.invoke.*;
import java.util.*;
import nsk.share.gc.gp.array.*;
import nsk.share.gc.gp.string.*;
import nsk.share.gc.gp.list.*;
import nsk.share.gc.gp.tree.*;
import nsk.share.gc.gp.misc.*;
import nsk.share.gc.gp.classload.*;
import nsk.share.gc.Memory;
import nsk.share.TestBug;
import nsk.share.test.*;
/**
* Utility methods for garbage producers.
*/
public final class GarbageUtils {
private static final int ALLOCATION_LIMIT = 50000000; //50 Mb
private static GarbageProducers garbageProducers;
private static List<GarbageProducer> primitiveArrayProducers;
private static List<GarbageProducer> arrayProducers;
private static final GarbageProducer byteArrayProducer = new ByteArrayProducer();
public static enum OOM_TYPE {
ANY (),
HEAP("Java heap space"),
METASPACE("Metaspace", "Compressed class space");
private final String[] expectedStrings;
OOM_TYPE(String... expectedStrings) {
this.expectedStrings = expectedStrings;
}
/**
* Returns true if the given error message matches
* one of expected strings.
*/
public boolean accept(String errorMessage) {
if (expectedStrings == null || expectedStrings.length == 0 || errorMessage == null) {
return true;
}
for (String s: expectedStrings) {
if (errorMessage.indexOf(s) != -1) {
return true;
}
}
return false;
}
};
// Force loading of OOM_TYPE and calling of enum constructors when loading GarbageUtils class.
public static final Object[] thisIsGarbageArray_theOnlyPurposeForCreatingItAndDeclaringItPublicIsToInitializeIntancesOfOOMEnumberation = new Object[] { OOM_TYPE.ANY, OOM_TYPE.HEAP, OOM_TYPE.METASPACE };
// Force early loading of classes that might otherwise unexpectedly fail
// class loading during testing due to high memory pressure.
public static final StringWriter preloadStringWriter = new StringWriter(1);
public static final PrintWriter preloadPrintWriter = new PrintWriter(preloadStringWriter);
public static final Throwable preloadThrowable = new Throwable("preload");
private GarbageUtils() {
}
/**
* Eat memory using execution controller that waits for 2 minutes.
* @return number of OOME occured
*/
public static int eatMemory() {
return eatMemory(2 * 60 * 1000);
}
/**
* Eat memory using execution controller that waits for timeout.
* @return number of OOME occured
*/
public static int eatMemory(final long timeout) {
return eatMemory(new ExecutionController() {
final long initialTime = System.currentTimeMillis();
@Override
public void start(long stdIterations) {}
@Override
public boolean iteration() {return false;}
@Override
public boolean continueExecution() {
return System.currentTimeMillis() - initialTime < timeout;
}
@Override
public long getIteration() {return 0;}
@Override
public void finish() {}
});
}
/**
* Eat memory using given execution controller and garbage producer.
*
* @param stresser execution controller
* @param gp garbage producer
* @return number of OOME occured
*/
public static int eatMemory(ExecutionController stresser) {
return eatMemory(stresser, byteArrayProducer, 50, 100, 2, OOM_TYPE.ANY);
}
/**
* Eat memory using given execution controller and garbage producer.
*
* @param stresser execution controller
* @param gp garbage producer
* @return number of OOME occured
*/
public static int eatMemory(ExecutionController stresser, GarbageProducer gp) {
return eatMemory(stresser, gp, 50, 100, 2, OOM_TYPE.ANY);
}
/**
* Eat memory using given garbage producer and given factor.
*
* @param gp garbage producer
* @param factor factor to divide the array size by
* @return number of OOME occured
*/
public static int eatMemory(ExecutionController stresser, GarbageProducer gp, long factor) {
return eatMemory(stresser, gp, 50, 100, factor, OOM_TYPE.ANY);
}
/**
* Eat memory using default(byte[]) garbage producer.
*
* 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.
*
* @param stresser stresser
* @param initialFactor determines which portion of initial memory initial chunk will be
* @param minMemoryChunk determines when to stop
* @param factor factor to divide the array size by
* @return number of OOME occured
*/
public static int eatMemory(ExecutionController stresser,long initialFactor, long minMemoryChunk, long factor) {
return eatMemory(stresser, byteArrayProducer, initialFactor, minMemoryChunk, factor, OOM_TYPE.ANY);
}
/**
* Eat memory using given garbage producer.
*
* 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.
*
* @param stresser stresser to use
* @param gp garbage producer
* @param initialFactor determines which portion of initial memory initial chunk will be
* @param minMemoryChunk determines when to stop
* @param factor factor to divide the array size by. A value of 0 means that method returns after first OOME
* @param type of OutOfMemory Exception: Java heap space or Metadata space
* @return number of OOME occured
*/
public static int eatMemory(ExecutionController stresser, GarbageProducer gp, long initialFactor, long minMemoryChunk, long factor) {
return eatMemory(stresser, gp, initialFactor, minMemoryChunk, factor, OOM_TYPE.ANY);
}
static int numberOfOOMEs = 0;
/**
* Minimal wrapper of the main implementation. Catches any OOM
* that might be thrown when rematerializing Objects when deoptimizing.
*
* It is Important that the impl is not inlined.
*/
public static int eatMemory(ExecutionController stresser, GarbageProducer gp, long initialFactor, long minMemoryChunk, long factor, OOM_TYPE type) {
try {
// Using a methodhandle invoke of eatMemoryImpl to prevent inlining of it
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodType mt = MethodType.methodType(
int.class,
ExecutionController.class,
GarbageProducer.class,
long.class,
long.class,
long.class,
OOM_TYPE.class);
MethodHandle eat = lookup.findStatic(GarbageUtils.class, "eatMemoryImpl", mt);
return (int) eat.invoke(stresser, gp, initialFactor, minMemoryChunk, factor, type);
} catch (OutOfMemoryError e) {
return numberOfOOMEs++;
} catch (Throwable t) {
throw new RuntimeException(t);
}
}
/**
* Eat memory using given garbage producer.
*
* 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.
*
* @param stresser stresser to use
* @param gp garbage producer
* @param initialFactor determines which portion of initial memory initial chunk will be
* @param minMemoryChunk determines when to stop
* @param factor factor to divide the array size by. A value of 0 means that method returns after first OOME
* @param type of OutOfMemory Exception: Java heap space or Metadata space
* @return number of OOME occured
*/
public static int eatMemoryImpl(ExecutionController stresser, GarbageProducer gp, long initialFactor, long minMemoryChunk, long factor, OOM_TYPE type) {
numberOfOOMEs = 0;
try {
byte[] someMemory = new byte[200000]; //200 Kb
try {
Runtime runtime = Runtime.getRuntime();
long maxMemory = runtime.maxMemory();
long maxMemoryChunk = maxMemory / initialFactor;
long chunk = maxMemoryChunk;
chunk = chunk > ALLOCATION_LIMIT ? ALLOCATION_LIMIT : chunk;
int allocations = 0;
List<Object> storage = new ArrayList<Object>();
while (chunk > minMemoryChunk && stresser.continueExecution()) {
try {
storage.add(gp.create(chunk));
if (Thread.currentThread().isInterrupted()) {
return numberOfOOMEs;
}
// if we are able to eat chunk*factor let
// try to increase size of chunk
if (chunk * factor < maxMemoryChunk
&& factor != 0 && allocations++ == factor + 1) {
chunk = chunk * factor;
allocations = 0;
}
} catch (OutOfMemoryError e) {
someMemory = null;
if (type != OOM_TYPE.ANY) {
if (type.accept(e.toString())) {
numberOfOOMEs++;
} else {
// Trying to catch situation when Java generates OOM different type that test trying to catch
throw new TestBug("Test throw OOM of unexpected type." + e.toString());
}
} else {
numberOfOOMEs++;
}
allocations = 0;
if (factor == 0) {
return numberOfOOMEs;
} else {
chunk = chunk / factor;
}
}
}
} catch (OutOfMemoryError e) {
someMemory = null;
if (type != OOM_TYPE.ANY) {
if (type.accept(e.toString())) {
numberOfOOMEs++;
} else {
// Trying to catch situation when Java generates OOM different type that test trying to catch
throw new TestBug("Test throw OOM of unexpected type." + e.toString());
}
} else {
numberOfOOMEs++;
}
// all memory is eaten now even before we start, just return
}
} catch (OutOfMemoryError e) {
numberOfOOMEs++;
}
return numberOfOOMEs;
}
/**
* Get all primitive array producers.
*/
public static List<GarbageProducer> getPrimitiveArrayProducers() {
return getGarbageProducers().getPrimitiveArrayProducers();
}
/**
* Get all array producers.
*/
public static List<GarbageProducer> getArrayProducers() {
return getGarbageProducers().getArrayProducers();
}
/**
* Determine size of each object in array which will occupy given
* memory with distribution determined by given memory strategy.
*/
public static long getArraySize(long memory, MemoryStrategy memoryStrategy) {
return memoryStrategy.getSize(memory - Memory.getArrayExtraSize(), Memory.getReferenceSize());
}
/**
* Determine object count in array which will occupy given
* memory with distribution determined by given memory strategy.
*/
public static int getArrayCount(long memory, MemoryStrategy memoryStrategy) {
return memoryStrategy.getCount(memory - Memory.getArrayExtraSize(), Memory.getReferenceSize());
}
/**
* Get garbage producer by identifier.
*
* @param id identifier
* @return garbage producer for this identifier
*/
public static GarbageProducer getGarbageProducer(String id) {
if (id == null || id.equals("byteArr"))
return new ByteArrayProducer();
else if (id.equals("booleanArr"))
return new BooleanArrayProducer();
else if (id.equals("shortArr"))
return new ShortArrayProducer();
else if (id.equals("charArr"))
return new CharArrayProducer();
else if (id.equals("intArr"))
return new IntArrayProducer();
else if (id.equals("longArr"))
return new LongArrayProducer();
else if (id.equals("floatArr"))
return new FloatArrayProducer();
else if (id.equals("doubleArr"))
return new DoubleArrayProducer();
else if (id.equals("objectArr"))
return new ObjectArrayProducer();
else if (id.equals("randomString"))
return new RandomStringProducer();
else if (id.equals("simpleString"))
return new SimpleStringProducer();
else if (id.startsWith("interned("))
return new InternedStringProducer(getGarbageProducer(getInBrackets(id)));
else if (id.startsWith("linearList("))
return new LinearListProducer(MemoryStrategy.fromString(getInBrackets(id)));
else if (id.startsWith("circularList("))
return new CircularListProducer(MemoryStrategy.fromString(getInBrackets(id)));
else if (id.startsWith("nonbranchyTree("))
return new NonbranchyTreeProducer(MemoryStrategy.fromString(getInBrackets(id)));
else if (id.equals("class"))
return new GeneratedClassProducer();
else if (id.startsWith("hashed("))
return new HashedGarbageProducer(getGarbageProducer(getInBrackets(id)));
else if (id.startsWith("random("))
return new RandomProducer(getGarbageProducerList(getInBrackets(id)));
else if (id.startsWith("twofields("))
return new TwoFieldsObjectProducer(getGarbageProducer(getInBrackets(id)));
else if (id.startsWith("arrayof("))
return new ArrayOfProducer(getGarbageProducer(getInBrackets(id)));
else if (id.startsWith("trace("))
return new TraceProducer(getGarbageProducer(getInBrackets(id)));
else
throw new TestBug("Invalid garbage producer identifier: " + id);
}
private static String getInBrackets(String s) {
int n1 = s.indexOf('(');
if (n1 == -1)
throw new TestBug("Opening bracket not found: " + s);
int n2 = s.lastIndexOf(')');
if (n2 == -1)
throw new TestBug("Closing bracket not found: " + s);
return s.substring(n1 + 1, n2);
}
private static List<GarbageProducer> getGarbageProducerList(String s) {
if (s.equals("primitiveArrays"))
return getPrimitiveArrayProducers();
else if (s.equals("arrays"))
return getArrayProducers();
else {
String[] ids = s.split(",");
List<GarbageProducer> garbageProducers = new ArrayList<GarbageProducer>(ids.length);
for (int i = 0; i < ids.length; ++i)
garbageProducers.add(getGarbageProducer(ids[i]));
return garbageProducers;
//throw new TestBug("Invalid id for list of garbage producers: " + id);
}
}
public static GarbageProducers getGarbageProducers() {
if (garbageProducers == null)
garbageProducers = new GarbageProducers();
return garbageProducers;
}
}