ScalabilityTestRun.java

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);
	}
}