A nice example of using OoOJava to parallelize an algorithm that is much clearer than existing parallel implementations

changes

real fix for the bug...not just the symptom

bug fix

byte info

simultaneous failure

single failure

fix: make OID only available for MLP.

changes

more changes to compile recovery benchmarks

add missing files

commiting all latest changes to recovery folder

optimized picking of read-set during pile creation

changes to Spider benchmark

changes

throw error instead of exit so caller code can report location of array initializers

chnges to Game benchmark

 add hashmap

Added the this() explicit constructor invocation which is very similar to super() already part of the compiler.  This helps when porting benchmarks that use this invocation

changes for the case that an SESE enqueues more than one request into the same queue.

changes

changes for using unique ID instead of obj address for the memory queue

adding new changes to FileSystem benchmark

bring a snapshot before further changes of memory queue(OID and multiple enqueue case).

test file for using FileOutputStream

changes to file system to simulate behaviour of adding data into file and reading it

polling thread ping only leader machine when a machine failure is detected

new recovery protocol

 changes to efficiently generate more reads than creates in the filesystem

changes to generate web pages of increased sizes

 changes to webpage generator

generate our own web files for web crawler

bug fix in that return value assignment edges were not being handled like other edges, so instead of doing them as a special case they are now integrated into the single callee-to-caller edge code

reporting on new analysis doing good job with benchmarks now

improving debugging of call site contributions to initial contexts

changes

my changes

Add stephen to the CVS.  Note that anyone can change these...

 print stats in matrix multiply

print recovery stats

changes to Game benchmark

small change

grab locks on sockpool for all communications involving cache and prefetch

disable Timer interrupt and some bug fixing

bug fix, some callees were not being rescheduled because code to do it was conditional on caller having a new result since last visit

changes to the recovery script : enable killing of one machine using USR signal

fixed

fixed a bug where retrieving the context contribution of a call site returns an empty graph instead of null, which erroneously matches a new context calculation that happens to be an empty graph--this doesn't fully solve the known bug though

missed a line of code

 comment debugs, add code for timing thr execution, machine id changes in main()

comment debug statements and add code for timing runs

nothing.

new matrix multiply

input file with all the benchmark arguments for the script

 changes to enable n iterations of each launch

small change

changes for single threaded Java version of Spider

my changes

changes

changes for running recovery version

annoying bug fixed; works well with current recovery system

translists

adjustments to stack-based method scheduling, debug controls, a micro benchmark, and interestingly with updated scheduling more benchmarks consistently exhibit the map reduce problem

Core of Sudoku Puzzler is ported without input error detection (no try/catch statements). The result writer (to file) is embedded in Test.java

Lessons Learned
1)  There are fewer implicit type casts with our compiler.
2)  Error Handling
2a) Functions that could throw an error but does not return anything can return a boolean to check for errors.
2b) Functions that do return something can return either a null (if returning an object) or an invalid value to check for errors.

Added input file support; user must put the file location as first argument when calling ./test.bin

Modified my core code to be able to compile under "make single"

Notes:
-Compiler does not do as many int/Integer impicit-casts as the Java compiler; result is much time spent following compiler errors to fix casting ambiguities

-ArrayList.java is ported from the Java library with Exceptions removed and only retains roughly half the built-in functions.

Future Plans:
-Impelment parsing and writing files to gain farmiliarity with using I/O.

Ported over commonly used operations in ArrayList.java from the Java library --Stephen

fix some bugs in Bamboo

fix in generating dynamic variable type.

trying to isolate a bug from MapReduceTag in a miniature version here

an example program using StringTokenizer

fixes in handling unresolved pointer.

set temp descriptor for a waiting element.

transaction clearing done.

need to test with more benchmarks

new getstatus method

new files

rewrite

deterministic mode works

added compiler option to desire determinism, it currently has little effect on determinism, though, so will get back to other bugs for now

one sharing discrepancy resolved

just improved some output

two phase recovery

First test case

changes to automate old and new analysis benchmark suites, want tabular output to match for easily comparisons

results show all visit methods roughly equal now, still sharing difference for MapReduce, both versions

raw results from overnight test

bug fixes for handling unresolved pointer.

bug fix.

changes for handling unresolved in-var pointer.

recoveryflag is modified

objects with bamboo-parameter flags got dropped from analysis by accident

implemented stack method visit but with callees on top, something crazy is happening to sharing for ALL visit methods...

Moved Prime Program into its own folder

Moved Primes into its own folder

Updated Test.java; it now achieves a speed-up of 8x on dc-11

bring last changes for proper handling 64bit before more changes are made.

Updated Test.java to working condition (parallelized)

backed up working serial program and original program (that did not compile)

paxos in separate file.

still problem in transaction clearing

Renamed test.java to Test.java and updated makefile accordingly. Done to keep javac from complaining