includes the missing header file.

Enable interface for mgc version.

fix sloppy code and use a more recognizable invalid pointer for mem pool

make sure mistakes are obvious with identifiable values

changes: to prevent unnecessary LOCKXCHG when the unresolved queue is empty.

really bad bug

single ended queue work stealing scheduler

couple of minor bug fixes

change calloc to RUNMALLOC, added some optional debug deque bits

optimize dispatch a little more

Changes...  small fix to jim's bugfix...touching our record after we free it is also bad...

poolalloc the rentry's...avoid running out of memory...looks like speed gains for micro also...

eliminate parentsemaphore...just use the thread local semaphore...needed to simplify freeing rentry records

fixed nasty bug, decrementing parents num running children used to be last, but new code has creeped up afte rit, move this down to the very last thing done before exiting

Fixed issue where multi-dimentional primative arrays were treated as primitives. Now labyrinth benchmark works

bug fix: RCR sets its proper conflict type.

make sure that every benchmark of oooJava takes the largest input size by default

correct input data for barneshut

OOO and RCR are speparate targets in the master makefile, added runp scripts for all benchmarks, time command included in runp's

fix bug w/ recycling + RCR

support for RCR and task record pool allocation

this is a BUG, don't dereference the object pointer, blargh

Hack the compiler to support 'abstract' keyword for mgc version. Abstract classes/methods can be compiled but fully semantic check is not supported. Now we generate an empty method for each declared abstract method and do not check if the subclasses have implemented their inheried abstract methods.

Added necessary variable initializations

changes: handle correctly the case when a coarse grain conflict is associated with effects on different allocation sites.

make the traversers do something

Changing OoOJava work scheduler to true work stealing, garbage collection can walk the deques used, changes to build code and workschedule are awesome because work stealing threads exit gracefully when system is out of work

added a debug option for deque

bug fix in identifying leaf tasks

Changed method for marking possible resume cases. Now it only considers read conflicts.

Improved heuristics for marking where resume cases are possible. Instead marking every conflict as a possible resume case, it now only marks cases where there is a read conflict (which implies that there is a write somewhere else) or where there is an ancestor read conflict and a current conflict.

changes

cleaned up some old code and comments

bug fixes

changes...handle races between coarse and fine grained conflict resolution

+Made arrays inlineable
+Fields with multiple allocation sites are now handled with a switch statement.

Fixed bug (for reals this time) where there will be multiple traversals on the same field. Turns out the .equals for ConcreteRuntimeObjNode was done incorrectly.

Working on next task:
+using switch statements for checking fields.
+Treating arrays the same as any field (inlinable)

Fixed bug where one edge is traversed multiple times even if it's the same allocsite. Turns out, the .equals in allocsite did not compare their ID's.

Changes:

fixes to case in Test/rcr. Now the program seems to get stuck at sched_yield() which I believe is not a component of RCR

another bad case

changes

another bug fix

changes

Disable static related code generation for Java version

bug

changes

more core...fix traversers...

still some bugs...but stall site code generation is in

changes towards rcr working...
comment out jin's checkin...it breaks code generation in x86...

Add Class object so that we can implement getClass() and can have class lock for synchronized blocks

implemented deque for work stealing

Small bug fix for multicore gc w/o tasks

more changes....much is still missing

changes

changes

simple changes:
if there are more than one coarse conflicts for the same queue and the same sese, one coarse waiting element, which is actually enqueued into the memory queue, maintains a set of tempDesc containing all of the coarse tempDescriptors.

have not yet modified BuildCode.

Implement a more sorphisticated execution strategy for static blocks. Tested with very simple example code.  Static field initialization is not implemented yet.

changes

changes. assign tempDescriptor to coarse waiting element

changes

more changes for RCR

remove unnecessary conflict type and assign coarse conflict by default.

Added allocsite check for array elements before inserting into visitedhash.

change

more changes...RCR wasn't usable until it was too late...

more changes

more work towards working version

changes

Added support for adding array elements into the hash/queue. Appears to support multidimensional arrays as well.

let the prefetch go through a register instead...

changes

switch to a thread local stall sem for parent to give to children, tinker with prefetch in pool alloc, tinker with safe and fast garbage collection at scheduler level

Add support for 'static' fields in multicore gc version w/o tasks. Now we can have static fields and access static fields/methods with Class name. Static blocks are also supported but with very simple invocation solution. All the static blocks are executed right before executing the main method and are executed in random order. The initialization for the static field is not supported yet.

Added support for tracking which ConcreteRuntimeObjNodes can be Arrays and which can be array elements. Array elements get their own case statement since if we add the entire array into the queue, then it's probably better to let the switch statement handle what to do with objects from a specific allocation site.

I had more code written, but apparently my workspace was not up to date. The changes I made need changes, so I omitted them. It's okay since I need to ask Yonghun/Jim about arrays on the C-side anyway.

more changes towards oooJava version 2

changes to buildscript

more changes towards new version of oooJava

changes

compute average processor ticks per event in parsed output

Tweaks to microbenchmarks, one stall semaphore per thread changes have been backed out while exploring micro benchmark issues

Add process of global thread queue in gc, not tested yet

micro benchmarks for OoOJava task dispatch improvement, but behavior or ooo version just looks wrong...

Add test for reentrant feature of the synchronized blocks

Add Test for multicore gc version w/o tasks

Synchronized block is now working.  A simple test is passed.

name pool alloc, useful for seeing its effective reduction of mallocs

coreprof updates, nothing huge

hash of OIDs should not bit shift

Fix bug in termination of the multicore gc version w/o tasks

Add the runtime for multicore gc version w/o tasks. Now can start multiple threads on Tilera. But still have some problem with the termination schem. Syncronized block is not test yet.

bug fixes for oooJava, some debug events for coreprof for exploring things not worth keeping

just a convenient script to repeat the official problem size

added prefetch when grabbing a record for next one, and fixed a malloc to RUNMALLOC

updates for some convenient debug events and a covnert to txt mode

changes...plus a little optimization

a new buildscript option to save teh source code in tmp.c after preprocessor is done iwht it

changes

Changes to accommodate the runtime for multicore gc w/o tasks

more code towards working...it actually compiles now...doesn't work of course yet

add test script for raytracer

ok, this is a wacky commit, purposefully leaving a half-implemented forward Q change in, but benign, because pool allocation by itslef might have fixed ray tracer up very nicely, but gotta check it out first

more changes