initial copy

.gitignore

@@ -0,0 +1,2 @@
.svn
build

build.xml

@@ -0,0 +1,22 @@
<project name="all" basedir="." default="compile">
	<macrodef name="iterate">
		<attribute name="target"/>
		<sequential>
			<subant target="@{target}">
				<fileset dir="." includes="*/build.xml"/>
			</subant>
		</sequential>
	</macrodef>

	<target name="clean">
		<iterate target="clean"/>
	</target>

	<target name="mrproper">
		<iterate target="mrproper"/>
	</target>

	<target name="compile">
		<iterate target="compile"/>
	</target>
</project>

common/build.xml

@@ -0,0 +1,5 @@
<project name="common" basedir="." default="compile">
	<import file="common.xml"/>

	<property name="classpath" value="${lib}/javasvn.jar:${lib}/lwjgl.jar:${lib}/lwjgl_util.jar:${lib}/jorbis.jar:${lib}/commons-pool-1.2.jar:${lib}/commons-dbcp-1.2.1.jar:${lib}/commons-collections-3.1.jar"/>
</project>

common/classes/com/oddlabs/event/Deterministic.java

@@ -0,0 +1,114 @@
package com.oddlabs.event;

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

public abstract strictfp class Deterministic {
	protected final static int BUFFER_SIZE = 4096;
	protected final static int DEFAULTS_SIZE = 2;
	protected final static int MIN_DEFAULTS = Short.MIN_VALUE;

	private final static long CHECKPOINT_SIGNATURE = 0xdeadbabecafebeefL;
	
	private boolean enabled = true;

	public final boolean log(boolean b) {
		return log(b, false);
	}

	private final boolean log(boolean b, boolean def) {
		assert enabled;
		return log(b ? (byte)1 : (byte)0, def ? (byte)1 : (byte)0) != 0;
	}
	
	public final byte log(byte b) {
		assert enabled;
		return log(b, (byte)0);
	}
	
	protected abstract byte log(byte b, byte def);

	public final char log(char c) {
		assert enabled;
		return log(c, (char)0);
	}
	
	protected abstract char log(char c, char def);

	public final int log(int i) {
		assert enabled;
		return log(i, 0);
	}
	
	protected abstract int log(int i, int def);

	public final long log(long l) {
		assert enabled;
		return log(l, 0);
	}

	protected abstract long log(long l, long def);

	public final float log(float f) {
		assert enabled;
		return log(f, 0f);
	}

	protected abstract float log(float f, float def);
	
	public final Object log(Object o) {
		assert enabled;
		return logObject(o);
	}

	protected abstract Object logObject(Object o);

	public final void log(ByteBuffer o) {
		assert enabled;
		logBuffer(o);
	}

	protected abstract void logBuffer(ByteBuffer o);

	public abstract void endLog();

	public abstract boolean isPlayback();

	public final void setEnabled(boolean enable) {
		this.enabled = enable;
	}

	public final void checkpoint() {
		checkpoint(CHECKPOINT_SIGNATURE);
	}
	public final void checkpoint(long value) {
		long logged_value = log(value);
		assert logged_value == value: logged_value + " != " + value;
	//	assert logged_value == value: "0x" + Long.toHexString(logged_value) + " != 0x" + Long.toHexString(value);
	}

	public final void checkpoint(boolean value) {
		boolean logged_value = log(value);
		assert logged_value == value: logged_value + " != " + value;
	//	assert logged_value == value: "0x" + Long.toHexString(logged_value) + " != 0x" + Long.toHexString(value);
	}

	public final void checkpoint(float value) {
		float logged_value = log(value);
		assert logged_value == value: logged_value + " != " + value;
	//	assert logged_value == value: "0x" + Long.toHexString(logged_value) + " != 0x" + Long.toHexString(value);
	}

	protected final static int getTraceId() {
		Throwable t = new Throwable();
		StackTraceElement[] stack_trace_elements = t.getStackTrace();
		int hash = 0;
		for (int i = 0; i < stack_trace_elements.length; i++) {
			if (stack_trace_elements[i].getClassName().startsWith(Deterministic.class.getPackage().getName()))
				continue;
			hash += stack_trace_elements[i].getMethodName().hashCode();
		}
		return hash;
	}
}

common/classes/com/oddlabs/event/LoadDeterministic.java

@@ -0,0 +1,186 @@
package com.oddlabs.event;

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.zip.*;

public final strictfp class LoadDeterministic extends Deterministic {
	private final ReadableByteChannel channel;
	private final ByteBuffer buffer;

	private final ByteBufferInputStream byte_buffer_input_stream = new ByteBufferInputStream();

	private int total_bytes_read;
	private int num_defaults = MIN_DEFAULTS;

	public LoadDeterministic(File logging_file, boolean zipped) {
		try {
			buffer = ByteBuffer.allocateDirect(BUFFER_SIZE);
			if (zipped)
				channel = Channels.newChannel(new GZIPInputStream(new FileInputStream(logging_file)));
			else
				channel = new FileInputStream(logging_file).getChannel();
			buffer.limit(0);
			System.out.println("Reading log from " + logging_file);
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
		isDefault(0);
		getDefaults();
	}

	public final boolean isPlayback() {
		return true;
	}

	public final void endLog() {
//		assert isEndOfLog();
		try {
			channel.close();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
	
	private final boolean isDefault(int num_bytes) {
		if (num_defaults > MIN_DEFAULTS) {
			num_defaults--;
			if (isEndOfLog())
				System.out.println("***** End of log ***** ");
			return true;
		} else {
			fillBuffer(num_bytes);
			return false;
		}
	}

	private final void fillBuffer(int num_bytes) {
		while (num_bytes > buffer.remaining()) {
			fillBuffer();
		}
	}

	private final void fillBuffer() {
		if (tryFillBuffer())
			throw new IllegalStateException("End of log reached, bytes read: " + total_bytes_read);
	}

	private final boolean tryFillBuffer() {
		try {
			buffer.compact();
			int bytes_read;
			int current_total = 0;
			do {
				bytes_read = channel.read(buffer);
				if (bytes_read != -1) {
					current_total += bytes_read;
				}
			} while (bytes_read != -1 && buffer.hasRemaining());
			buffer.flip();
			total_bytes_read += current_total;
			return bytes_read == -1 && current_total == 0;
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
	
	private final boolean isEndOfLog() {
		if (!buffer.hasRemaining() && num_defaults == MIN_DEFAULTS)
			return tryFillBuffer();
		else
			return false;
	}

	private final void getDefaults() {
		fillBuffer(DEFAULTS_SIZE);
		num_defaults = buffer.getShort();
		if (isEndOfLog())
			System.out.println("***** End of log *****");
	}

	protected final byte log(byte b, byte def) {
		if (isDefault(1))
			return def;
		else {
			b = buffer.get();
			getDefaults();
			return b;
		}
	}

	protected final char log(char c, char def) {
		if (isDefault(2))
			return def;
		else {
			c = buffer.getChar();
			getDefaults();
			return c;
		}
	}

	protected final int log(int i, int def) {
		if (isDefault(4))
			return def;
		else {
			i = buffer.getInt();
			getDefaults();
			return i;
		}
	}

	protected final long log(long l, long def) {
		if (isDefault(8))
			return def;
		else {
			l = buffer.getLong();
			getDefaults();
			return l;
		}
	}

	protected final float log(float f, float def) {
		if (isDefault(4))
			return def;
		else {
			f = buffer.getFloat();
			getDefaults();
			return f;
		}
	}
	
	protected final Object logObject(Object o) {
		try {
			ObjectInputStream object_input_stream = new ObjectInputStream(byte_buffer_input_stream);
			o = object_input_stream.readObject();
			object_input_stream.close();
			return o;
		} catch (IOException e) {
			throw new RuntimeException(e);
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}
	}

	protected final void logBuffer(ByteBuffer b) {
		boolean isdefault = isDefault(0);
		assert !isdefault;
		while (true) {
			int old_limit = buffer.limit();
			buffer.limit(old_limit - Math.max(0, buffer.remaining() - b.remaining()));
			b.put(buffer);
			buffer.limit(old_limit);
			if (!b.hasRemaining())
				break;
			fillBuffer();
		}
		getDefaults();
	}

	public final strictfp class ByteBufferInputStream extends InputStream {
		public final int read() throws IOException {
			byte b = log((byte)0);
			return ((int)b) & 0xFF;
		}
	}
}

common/classes/com/oddlabs/event/NotDeterministic.java

@@ -0,0 +1,42 @@
package com.oddlabs.event;

import java.io.*;
import java.nio.*;
import java.nio.channels.*;

public final strictfp class NotDeterministic extends Deterministic {
	public final boolean isPlayback() {
		return false;
	}

	public final void endLog() {
	}

	protected final byte log(byte b, byte def) {
		return b;
	}

	protected final char log(char c, char def) {
		return c;
	}

	protected final int log(int i, int def) {
		return i;
	}

	protected final long log(long l, long def) {
		return l;
	}

	protected final float log(float f, float def) {
		return f;
	}
	
	protected final Object logObject(Object o) {
		return o;
	}
	
	protected final void logBuffer(ByteBuffer b) {
		b.position(b.limit());
	}
}