/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
// Run on host with:
// javac ThreadTest.java && java ThreadStress && rm *.class
// Through run-test:
// test/run-test {run-test-args} 004-ThreadStress [Main {ThreadStress-args}]
// (It is important to pass Main if you want to give parameters...)
//
// ThreadStress command line parameters:
// -n X ............ number of threads
// -d X ............ number of daemon threads
// -o X ............ number of overall operations
// -t X ............ number of operations per thread
// --dumpmap ....... print the frequency map
// -oom:X .......... frequency of OOM (double)
// -alloc:X ........ frequency of Alloc
// -stacktrace:X ... frequency of StackTrace
// -exit:X ......... frequency of Exit
// -sleep:X ........ frequency of Sleep
// -wait:X ......... frequency of Wait
// -timedwait:X .... frequency of TimedWait
public class Main implements Runnable {
public static final boolean DEBUG = false;
private static abstract class Operation {
/**
* Perform the action represented by this operation. Returns true if the thread should
* continue.
*/
public abstract boolean perform();
}
private final static class OOM extends Operation {
private final static int ALLOC_SIZE = 1024;
@Override
public boolean perform() {
try {
List<byte[]> l = new ArrayList<byte[]>();
while (true) {
l.add(new byte[ALLOC_SIZE]);
}
} catch (OutOfMemoryError e) {
}
return true;
}
}
private final static class SigQuit extends Operation {
private final static int sigquit;
private final static Method kill;
private final static int pid;
static {
int pidTemp = -1;
int sigquitTemp = -1;
Method killTemp = null;
try {
Class<?> osClass = Class.forName("android.system.Os");
Method getpid = osClass.getDeclaredMethod("getpid");
pidTemp = (Integer)getpid.invoke(null);
Class<?> osConstants = Class.forName("android.system.OsConstants");
Field sigquitField = osConstants.getDeclaredField("SIGQUIT");
sigquitTemp = (Integer)sigquitField.get(null);
killTemp = osClass.getDeclaredMethod("kill", int.class, int.class);
} catch (Exception e) {
Main.printThrowable(e);
}
pid = pidTemp;
sigquit = sigquitTemp;
kill = killTemp;
}
@Override
public boolean perform() {
try {
kill.invoke(null, pid, sigquit);
} catch (OutOfMemoryError e) {
} catch (Exception e) {
if (!e.getClass().getName().equals(Main.errnoExceptionName)) {
Main.printThrowable(e);
}
}
return true;
}
}
private final static class Alloc extends Operation {
private final static int ALLOC_SIZE = 1024; // Needs to be small enough to not be in LOS.
private final static int ALLOC_COUNT = 1024;
@Override
public boolean perform() {
try {
List<byte[]> l = new ArrayList<byte[]>();
for (int i = 0; i < ALLOC_COUNT; i++) {
l.add(new byte[ALLOC_SIZE]);
}
} catch (OutOfMemoryError e) {
}
return true;
}
}
private final static class LargeAlloc extends Operation {
private final static int PAGE_SIZE = 4096;
private final static int PAGE_SIZE_MODIFIER = 10; // Needs to be large enough for LOS.
private final static int ALLOC_COUNT = 100;
@Override
public boolean perform() {
try {
List<byte[]> l = new ArrayList<byte[]>();
for (int i = 0; i < ALLOC_COUNT; i++) {
l.add(new byte[PAGE_SIZE_MODIFIER * PAGE_SIZE]);
}
} catch (OutOfMemoryError e) {
}
return true;
}
}
private final static class StackTrace extends Operation {
@Override
public boolean perform() {
try {
Thread.currentThread().getStackTrace();
} catch (OutOfMemoryError e) {
}
return true;
}
}
private final static class Exit extends Operation {
@Override
public boolean perform() {
return false;
}
}
private final static class Sleep extends Operation {
private final static int SLEEP_TIME = 100;
@Override
public boolean perform() {
try {
Thread.sleep(SLEEP_TIME);
} catch (InterruptedException ignored) {
}
return true;
}
}
private final static class TimedWait extends Operation {
private final static int SLEEP_TIME = 100;
private final Object lock;
public TimedWait(Object lock) {
this.lock = lock;
}
@Override
public boolean perform() {
synchronized (lock) {
try {
lock.wait(SLEEP_TIME, 0);
} catch (InterruptedException ignored) {
}
}
return true;
}
}
private final static class Wait extends Operation {
private final Object lock;
public Wait(Object lock) {
this.lock = lock;
}
@Override
public boolean perform() {
synchronized (lock) {
try {
lock.wait();
} catch (InterruptedException ignored) {
}
}
return true;
}
}
private final static class SyncAndWork extends Operation {
private final Object lock;
public SyncAndWork(Object lock) {
this.lock = lock;
}
@Override
public boolean perform() {
synchronized (lock) {
try {
Thread.sleep((int)(Math.random()*10));
} catch (InterruptedException ignored) {
}
}
return true;
}
}
private final static Map<Operation, Double> createDefaultFrequencyMap(Object lock) {
Map<Operation, Double> frequencyMap = new HashMap<Operation, Double>();
frequencyMap.put(new OOM(), 0.005); // 1/200
frequencyMap.put(new SigQuit(), 0.095); // 19/200
frequencyMap.put(new Alloc(), 0.25); // 50/200
frequencyMap.put(new LargeAlloc(), 0.05); // 10/200
frequencyMap.put(new StackTrace(), 0.1); // 20/200
frequencyMap.put(new Exit(), 0.25); // 50/200
frequencyMap.put(new Sleep(), 0.125); // 25/200
frequencyMap.put(new TimedWait(lock), 0.05); // 10/200
frequencyMap.put(new Wait(lock), 0.075); // 15/200
return frequencyMap;
}
private final static Map<Operation, Double> createLockFrequencyMap(Object lock) {
Map<Operation, Double> frequencyMap = new HashMap<Operation, Double>();
frequencyMap.put(new Sleep(), 0.2);
frequencyMap.put(new TimedWait(lock), 0.2);
frequencyMap.put(new Wait(lock), 0.2);
frequencyMap.put(new SyncAndWork(lock), 0.4);
return frequencyMap;
}
public static void main(String[] args) throws Exception {
System.loadLibrary(args[0]);
parseAndRun(args);
}
private static Map<Operation, Double> updateFrequencyMap(Map<Operation, Double> in,
Object lock, String arg) {
String split[] = arg.split(":");
if (split.length != 2) {
throw new IllegalArgumentException("Can't split argument " + arg);
}
double d;
try {
d = Double.parseDouble(split[1]);
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
if (d < 0) {
throw new IllegalArgumentException(arg + ": value must be >= 0.");
}
Operation op = null;
if (split[0].equals("-oom")) {
op = new OOM();
} else if (split[0].equals("-sigquit")) {
op = new SigQuit();
} else if (split[0].equals("-alloc")) {
op = new Alloc();
} else if (split[0].equals("-largealloc")) {
op = new LargeAlloc();
} else if (split[0].equals("-stacktrace")) {
op = new StackTrace();
} else if (split[0].equals("-exit")) {
op = new Exit();
} else if (split[0].equals("-sleep")) {
op = new Sleep();
} else if (split[0].equals("-wait")) {
op = new Wait(lock);
} else if (split[0].equals("-timedwait")) {
op = new TimedWait(lock);
} else {
throw new IllegalArgumentException("Unknown arg " + arg);
}
if (in == null) {
in = new HashMap<Operation, Double>();
}
in.put(op, d);
return in;
}
private static void normalize(Map<Operation, Double> map) {
double sum = 0;
for (Double d : map.values()) {
sum += d;
}
if (sum == 0) {
throw new RuntimeException("No elements!");
}
if (sum != 1.0) {
// Avoid ConcurrentModificationException.
Set<Operation> tmp = new HashSet<>(map.keySet());
for (Operation op : tmp) {
map.put(op, map.get(op) / sum);
}
}
}
public static void parseAndRun(String[] args) throws Exception {
int numberOfThreads = -1;
int numberOfDaemons = -1;
int totalOperations = -1;
int operationsPerThread = -1;
Object lock = new Object();
Map<Operation, Double> frequencyMap = null;
boolean dumpMap = false;
if (args != null) {
// args[0] is libarttest
for (int i = 1; i < args.length; i++) {
if (args[i].equals("-n")) {
i++;
numberOfThreads = Integer.parseInt(args[i]);
} else if (args[i].equals("-d")) {
i++;
numberOfDaemons = Integer.parseInt(args[i]);
} else if (args[i].equals("-o")) {
i++;
totalOperations = Integer.parseInt(args[i]);
} else if (args[i].equals("-t")) {
i++;
operationsPerThread = Integer.parseInt(args[i]);
} else if (args[i].equals("--locks-only")) {
lock = new Object();
frequencyMap = createLockFrequencyMap(lock);
} else if (args[i].equals("--dumpmap")) {
dumpMap = true;
} else {
frequencyMap = updateFrequencyMap(frequencyMap, lock, args[i]);
}
}
}
if (totalOperations != -1 && operationsPerThread != -1) {
throw new IllegalArgumentException(
"Specified both totalOperations and operationsPerThread");
}
if (numberOfThreads == -1) {
numberOfThreads = 5;
}
if (numberOfDaemons == -1) {
numberOfDaemons = 3;
}
if (totalOperations == -1) {
totalOperations = 1000;
}
if (operationsPerThread == -1) {
operationsPerThread = totalOperations/numberOfThreads;
}
if (frequencyMap == null) {
frequencyMap = createDefaultFrequencyMap(lock);
}
normalize(frequencyMap);
if (dumpMap) {
System.out.println(frequencyMap);
}
try {
runTest(numberOfThreads, numberOfDaemons, operationsPerThread, lock, frequencyMap);
} catch (Throwable t) {
// In this case, the output should not contain all the required
// "Finishing worker" lines.
Main.printThrowable(t);
}
}
public static void runTest(final int numberOfThreads, final int numberOfDaemons,
final int operationsPerThread, final Object lock,
Map<Operation, Double> frequencyMap) throws Exception {
final Thread mainThread = Thread.currentThread();
final Barrier startBarrier = new Barrier(numberOfThreads + numberOfDaemons + 1);
// Each normal thread is going to do operationsPerThread
// operations. Each daemon thread will loop over all
// the operations and will not stop.
// The distribution of operations is determined by
// the Operation.frequency values. We fill out an Operation[]
// for each thread with the operations it is to perform. The
// Operation[] is shuffled so that there is more random
// interactions between the threads.
// Fill in the Operation[] array for each thread by laying
// down references to operation according to their desired
// frequency.
// The first numberOfThreads elements are normal threads, the last
// numberOfDaemons elements are daemon threads.
final Main[] threadStresses = new Main[numberOfThreads + numberOfDaemons];
for (int t = 0; t < threadStresses.length; t++) {
Operation[] operations = new Operation[operationsPerThread];
int o = 0;
LOOP:
while (true) {
for (Operation op : frequencyMap.keySet()) {
int freq = (int)(frequencyMap.get(op) * operationsPerThread);
for (int f = 0; f < freq; f++) {
if (o == operations.length) {
break LOOP;
}
operations[o] = op;
o++;
}
}
}
// Randomize the operation order
Collections.shuffle(Arrays.asList(operations));
threadStresses[t] = (t < numberOfThreads)
? new Main(lock, t, operations)
: new Daemon(lock, t, operations, mainThread, startBarrier);
}
// Enable to dump operation counts per thread to make sure its
// sane compared to Operation.frequency
if (DEBUG) {
for (int t = 0; t < threadStresses.length; t++) {
Operation[] operations = threadStresses[t].operations;
Map<Operation, Integer> distribution = new HashMap<Operation, Integer>();
for (Operation operation : operations) {
Integer ops = distribution.get(operation);
if (ops == null) {
ops = 1;
} else {
ops++;
}
distribution.put(operation, ops);
}
System.out.println("Distribution for " + t);
for (Operation op : frequencyMap.keySet()) {
System.out.println(op + " = " + distribution.get(op));
}
}
}
// Create the runners for each thread. The runner Thread
// ensures that thread that exit due to Operation.EXIT will be
// restarted until they reach their desired
// operationsPerThread.
Thread[] runners = new Thread[numberOfThreads];
for (int r = 0; r < runners.length; r++) {
final Main ts = threadStresses[r];
runners[r] = new Thread("Runner thread " + r) {
final Main threadStress = ts;
public void run() {
try {
int id = threadStress.id;
// No memory hungry task are running yet, so println() should succeed.
System.out.println("Starting worker for " + id);
// Wait until all runners and daemons reach the starting point.
startBarrier.await();
// Run the stress tasks.
while (threadStress.nextOperation < operationsPerThread) {
try {
Thread thread = new Thread(ts, "Worker thread " + id);
thread.start();
thread.join();
if (DEBUG) {
System.out.println(
"Thread exited for " + id + " with " +
(operationsPerThread - threadStress.nextOperation) +
" operations remaining.");
}
} catch (OutOfMemoryError e) {
// Ignore OOME since we need to print "Finishing worker"
// for the test to pass. This OOM can come from creating
// the Thread or from the DEBUG output.
// Note that the Thread creation may fail repeatedly,
// preventing the runner from making any progress,
// especially if the number of daemons is too high.
}
}
// Print "Finishing worker" through JNI to avoid OOME.
Main.printString(Main.finishingWorkerMessage);
} catch (Throwable t) {
Main.printThrowable(t);
// Interrupt the main thread, so that it can orderly shut down
// instead of waiting indefinitely for some Barrier.
mainThread.interrupt();
}
}
};
}
// The notifier thread is a daemon just loops forever to wake
// up threads in Operation.WAIT
if (lock != null) {
Thread notifier = new Thread("Notifier") {
public void run() {
while (true) {
synchronized (lock) {
lock.notifyAll();
}
}
}
};
notifier.setDaemon(true);
notifier.start();
}
// Create and start the daemon threads.
for (int r = 0; r < numberOfDaemons; r++) {
Main daemon = threadStresses[numberOfThreads + r];
Thread t = new Thread(daemon, "Daemon thread " + daemon.id);
t.setDaemon(true);
t.start();
}
for (int r = 0; r < runners.length; r++) {
runners[r].start();
}
// Wait for all threads to reach the starting point.
startBarrier.await();
// Wait for runners to finish.
for (int r = 0; r < runners.length; r++) {
runners[r].join();
}
}
protected final Operation[] operations;
private final Object lock;
protected final int id;
private int nextOperation;
private Main(Object lock, int id, Operation[] operations) {
this.lock = lock;
this.id = id;
this.operations = operations;
}
public void run() {
try {
if (DEBUG) {
System.out.println("Starting ThreadStress " + id);
}
while (nextOperation < operations.length) {
Operation operation = operations[nextOperation];
if (DEBUG) {
System.out.println("ThreadStress " + id
+ " operation " + nextOperation
+ " is " + operation);
}
nextOperation++;
if (!operation.perform()) {
return;
}
}
} finally {
if (DEBUG) {
System.out.println("Finishing ThreadStress for " + id);
}
}
}
private static class Daemon extends Main {
private Daemon(Object lock,
int id,
Operation[] operations,
Thread mainThread,
Barrier startBarrier) {
super(lock, id, operations);
this.mainThread = mainThread;
this.startBarrier = startBarrier;
}
public void run() {
try {
if (DEBUG) {
System.out.println("Starting ThreadStress Daemon " + id);
}
startBarrier.await();
try {
int i = 0;
while (true) {
Operation operation = operations[i];
if (DEBUG) {
System.out.println("ThreadStress Daemon " + id
+ " operation " + i
+ " is " + operation);
}
operation.perform();
i = (i + 1) % operations.length;
}
} catch (OutOfMemoryError e) {
// Catch OutOfMemoryErrors since these can cause the test to fail it they print
// the stack trace after "Finishing worker". Note that operations should catch
// their own OOME, this guards only agains OOME in the DEBUG output.
}
if (DEBUG) {
System.out.println("Finishing ThreadStress Daemon for " + id);
}
} catch (Throwable t) {
Main.printThrowable(t);
// Interrupt the main thread, so that it can orderly shut down
// instead of waiting indefinitely for some Barrier.
mainThread.interrupt();
}
}
final Thread mainThread;
final Barrier startBarrier;
}
// Note: java.util.concurrent.CyclicBarrier.await() allocates memory and may throw OOM.
// That is highly undesirable in this test, so we use our own simple barrier class.
// The only memory allocation that can happen here is the lock inflation which uses
// a native allocation. As such, it should succeed even if the Java heap is full.
// If the native allocation surprisingly fails, the program shall abort().
private static class Barrier {
public Barrier(int initialCount) {
count = initialCount;
}
public synchronized void await() throws InterruptedException {
--count;
if (count != 0) {
do {
wait();
} while (count != 0); // Check for spurious wakeup.
} else {
notifyAll();
}
}
private int count;
}
// Printing a String/Throwable through JNI requires only native memory and space
// in the local reference table, so it should succeed even if the Java heap is full.
private static native void printString(String s);
private static native void printThrowable(Throwable t);
static final String finishingWorkerMessage;
static final String errnoExceptionName;
static {
// We pre-allocate the strings in class initializer to avoid const-string
// instructions in code using these strings later as they may throw OOME.
finishingWorkerMessage = "Finishing worker\n";
errnoExceptionName = "ErrnoException";
}
}