package org.prevayler.demos.scalability;
import org.prevayler.foundation.Cool;
import org.prevayler.foundation.StopWatch;
import java.text.DecimalFormat;
import java.util.LinkedList;
import java.util.List;
/**
* Represents a single run of a scalability test. To understand the implementation of this class, you must be familiar with Prevayler's Scalability Test (run org.prevayler.test.scalability.ScalabilityTest).
*/
abstract class ScalabilityTestRun {
static private final long ROUND_DURATION_MILLIS = 1000 * 20;
private final ScalabilityTestSubject subject;
protected final int numberOfObjects;
private double bestRoundOperationsPerSecond;
private int bestRoundThreads;
private final List connectionCache = new LinkedList();
private long operationCount = 0;
private long lastOperation = 0;
private boolean isRoundFinished;
private int activeRoundThreads = 0;
/**
* @return Example: "123.12 operations/second (12 threads)".
*/
public String getResult() {
return toResultString(bestRoundOperationsPerSecond, bestRoundThreads);
}
public double getOperationsPerSecond() {
return bestRoundOperationsPerSecond;
}
protected ScalabilityTestRun(ScalabilityTestSubject subject, int numberOfObjects, int minThreads, int maxThreads) {
if (minThreads > maxThreads)
throw new IllegalArgumentException("The minimum number of threads cannot be greater than the maximum number.");
if (minThreads < 1) throw new IllegalArgumentException("The minimum number of threads cannot be smaller than one.");
this.subject = subject;
this.numberOfObjects = numberOfObjects;
out("\n\n========= Running " + name() + " (" + (maxThreads - minThreads + 1) + " rounds). Subject: " + subject.name() + "...");
prepare();
out("Each round will take approx. " + ROUND_DURATION_MILLIS / 1000 + " seconds to run...");
performTest(minThreads, maxThreads);
out("\n----------- BEST ROUND: " + getResult());
}
protected void prepare() {
subject.replaceAllRecords(numberOfObjects);
System.gc();
}
/**
* @return The name of the test to be executed. Example: "Prevayler Query Test".
*/
protected abstract String name();
private void performTest(int minThreads, int maxThreads) {
int threads = minThreads;
while (threads <= maxThreads) {
double operationsPerSecond = performRound(threads);
if (operationsPerSecond > bestRoundOperationsPerSecond) {
bestRoundOperationsPerSecond = operationsPerSecond;
bestRoundThreads = threads;
}
threads++;
}
}
/**
* @return The number of operations the test managed to execute per second with the given number of threads.
*/
private double performRound(int threads) {
long initialOperationCount = operationCount;
StopWatch stopWatch = StopWatch.start();
startThreads(threads);
sleep();
stopThreads();
double secondsEllapsed = stopWatch.secondsEllapsed();
double operationsPerSecond = (operationCount - initialOperationCount) / secondsEllapsed;
out("\nMemory used: " + Runtime.getRuntime().totalMemory());
subject.reportResourcesUsed(System.out);
out("Seconds ellapsed: " + secondsEllapsed);
out("--------- Round Result: " + toResultString(operationsPerSecond, threads));
return operationsPerSecond;
}
private void startThreads(int threads) {
isRoundFinished = false;
int i = 1;
while (i <= threads) {
startThread(lastOperation + i, threads);
i++;
}
}
private void startThread(final long startingOperation, final int operationIncrement) {
(new Thread() {
public void run() {
try {
Object connection = acquireConnection();
long operation = startingOperation;
while (!isRoundFinished) {
executeOperation(connection, operation);
operation += operationIncrement;
}
synchronized (connectionCache) {
connectionCache.add(connection);
operationCount += (operation - startingOperation) / operationIncrement;
if (lastOperation < operation) lastOperation = operation;
activeRoundThreads--;
}
} catch (OutOfMemoryError err) {
outOfMemory();
}
}
}).start();
activeRoundThreads++;
}
protected abstract void executeOperation(Object connection, long operation);
private Object acquireConnection() {
synchronized (connectionCache) {
return connectionCache.isEmpty()
? subject.createTestConnection()
: connectionCache.remove(0);
}
}
private void stopThreads() {
isRoundFinished = true;
while (activeRoundThreads != 0) {
Thread.yield();
}
}
static private String toResultString(double operationsPerSecond, int threads) {
String operations = new DecimalFormat("0.00").format(operationsPerSecond);
return "" + operations + " operations/second (" + threads + " threads)";
}
static void outOfMemory() {
System.gc();
out(
"\n\nOutOfMemoryError.\n" +
"===========================================================\n" +
"The VM must be started with a sufficient maximum heap size.\n" +
"Example for Linux and Windows: java -Xmx512000000 ...\n\n"
);
}
static private void sleep() {
Cool.sleep(ROUND_DURATION_MILLIS);
}
static private void out(Object obj) {
System.out.println(obj);
}
}