* In absence of synchronization (such as memory barriers and so on), typical modern CPUs
* (Intel x86 32/64, SPARC in TSO mode) put stores into buffer instead of immediately writing them to memory.
*
* So the following program:
*
* write A
* read B
*
* can actually be transformed to and seen by other processors as:
*
* read B
* write A
*
*
* DekkerTest runs two threads, A and B, which perform operations on a shared array of Actors concurrently. * Reordering mentioned above is detected by the test and reported as failure * (unless mayFail option is specified in the constructor or command-line option). * *
* The tests should subclass Actor with test-specific data and code. * The Actor subclass requirements: * *
* A
* B
*
* of the same type, which are able hold one of two values.
* Let's call these values TRUE and FALSE (these can be any two values, say 0 and 1).
*
*
* A = TRUE
* optional MEMBAR #StoreLoad
* return (B == TRUE)
*
*
*
* {
* B = TRUE
* optional MEMBAR #StoreLoad
* return (A == TRUE)
* }
*
*
*
* {
* A = FALSE
* B = FALSE
* }
*
*
* The use of memory barriers in actorX() methods is up to the implementor -- depending on the goal of testing.
*
*/
public class DekkerTest extends MlvmTest {
@Option(name = "actorClass", default_value = "", description = "Name of actor class (see test comments)")
private String actorClassNameOpt = "";
@Option(name = "mayFail", default_value = "false", description = "Don't report test failure (use it just a stress test)")
private boolean mayFailOpt;
@Option(name = "iterations", default_value = "1000000", description = "Number of iterations in each Actor thread (i.e., shared array size)")
private int iterationsOpt = 1000000;
/**
* Actor interface, which should be implemented for using with DekkerTest.
* The requirements for Actor implementation are outlined in {@link DekkerTest} class documentation.
*/
public interface Actor {
/**
* Sets fields A and B to false
*/
void reset();
/**
* Sets field A to true, and returns field B contents
* @return field B contents
* @throws Throwable in case of error
*/
boolean actorA() throws Throwable;
/**
* Sets field B to true, and returns field A contents
* @return field A contents
* @throws Throwable in case of error
*/
boolean actorB() throws Throwable;
}
private static final class ResultData {
public boolean a;
public boolean b;
public ResultData() {
}
public void reset() {
a = false;
b = false;
}
}
private static class RaceStatistics {
public int syncErrors;
public int runSideBySide;
public int A_outruns_B;
public int B_outruns_A;
public void reset() {
syncErrors = 0;
runSideBySide = 0;
A_outruns_B = 0;
B_outruns_A = 0;
}
}
private Class actorClass;
private final CyclicBarrier startBarrier = new CyclicBarrier(2); // We have two actors
private Actor[] testData;
private ResultData[] results;
private final RaceStatistics raceStatistics = new RaceStatistics();
public DekkerTest() {
}
/**
* Sets actor class.
* @param ac Actor class, which implements DekkerTest.Actor interface
*/
public void setActorClass(Class ac) {
actorClass = ac;
}
/**
* Sets mayFail option. When set to true, synchronization failure is not reported as test failure (DekkerTest is used as a stress test).
* @param mayFail if true, don't report sync failure as test failure, false otherwise
*/
public void setMayFailOpt(boolean mayFail) {
mayFailOpt = mayFail;
}
/**
* Initializes test data, parses command-line options and checks Actor class
*/
@Override
public void initializeTest() {
// Override values set by setActorClass() by command-line option, if any
try {
if (!actorClassNameOpt.isEmpty()) {
actorClass = Class.forName(actorClassNameOpt).asSubclass(Actor.class);
} else {
if (actorClass == null) {
throw new RuntimeException("Test error: the actor class should be specified via command-line options or in the constructor");
}
}
} catch (ClassNotFoundException e) {
throw new RuntimeException("Actor class '" + actorClassNameOpt + "' not found", e);
} catch (ClassCastException e) {
throw new RuntimeException("Test error: the actor class " + actorClass.getName() + " should implement " + Actor.class.getName() + " interface", e);
}
// Generate data
int iterations = iterationsOpt * getStressOptions().getIterationsFactor();
if (iterations <= 0) {
throw new RuntimeException("Invalid number of iterations specified in -iterations and -stressIterationsFactor options: " + iterations);
}
results = new ResultData[iterations];
for (int i = 0; i < results.length; ++i) {
results[i] = new ResultData();
}
testData = new Actor[results.length];
try {
for (int i = 0; i < testData.length; ++i) {
testData[i] = actorClass.newInstance();
}
} catch (ReflectiveOperationException e) {
throw new RuntimeException("Test error: can't instantiate class " + actorClass.getName(), e);
}
}
/**
* Resets the test data between test runs
*/
@Override
public void resetTest() {
for (Actor a : testData) {
a.reset();
}
for (ResultData d : results) {
d.reset();
}
}
private class RunnerA extends Thread {
@Override
public void run() {
try {
startBarrier.await();
for (int i = 0; i < results.length; ++i) {
results[i].a = testData[i].actorA();
}
} catch (Throwable t) {
markTestFailed("Exception in RunnerA", t);
}
}
}
private class RunnerB extends Thread {
@Override
public void run() {
try {
startBarrier.await();
for (int i = 0; i < results.length; ++i) {
results[i].b = testData[i].actorB();
}
} catch (Throwable t) {
markTestFailed("Exception in RunnerB", t);
}
}
}
@Override
public boolean run() throws Throwable {
RunnerA threadA = new RunnerA();
threadA.start();
RunnerB threadB = new RunnerB();
threadB.start();
threadA.join();
threadB.join();
if (isMarkedFailed())
return false;
analyzeResults();
printResults();
if (mayFailOpt) {
return true;
}
return (raceStatistics.syncErrors == 0);
}
private void analyzeResults() {
raceStatistics.reset();
for (int i = 0; i < results.length; ++i) {
boolean resultA = results[i].a;
boolean resultB = results[i].b;
if (resultA && resultB) {
++raceStatistics.runSideBySide;
} else if (resultA && !resultB) {
++raceStatistics.A_outruns_B;
} else if (!resultA && resultB) {
++raceStatistics.B_outruns_A;
} else if (!resultA && !resultB) {
++raceStatistics.syncErrors;
} else {
throw new RuntimeException("Should not reach here");
}
}
}
private void printResults() {
int logLevel = (raceStatistics.syncErrors != 0) ? TraceLevel.TRACE_IMPORTANT : TraceLevel.TRACE_NORMAL;
Env.getLog().trace(logLevel, "\n"
+ "Late stores (sync. errors): " + raceStatistics.syncErrors + "\n"
+ "B outruns A : " + raceStatistics.B_outruns_A + "\n"
+ "A outruns B : " + raceStatistics.A_outruns_B + "\n"
+ "A and B run side by side : " + raceStatistics.runSideBySide);
}
public static void main(String[] args) {
MlvmTest.launch(args);
}
}