support for optimizations later, leaf tasks need less data

bug fix in gc cache adaption

bug fix

Added getter method to get all effects (needed for RuntimeConflictResolver.java)

This version prints out correct C code in terms of where things should be but is only tested on the simplest case. Will try more cases later.

Note: BuildCode.java was also modified to make this work but is not committed since it's only half changed (no stallsite code).

fix bugs

optimiz

turn off coreprof by default

fix performance bug

my changes

an appropriate test to simulate SOR for new pool allocation

disable coreprof by default

help user by showing human-readable task identifier

changes

Bug fix in gc cache adaption version

Remove the boundary of cache access sampling. Add output of the changed cache policy of the shared pages. Also fix some bugs.

Initial version of cache adaption for mutator

modularize core prof correctly, starting mem pool strat for task records

mini test to mimic SOR for mem pool testing

temporarily disabling this coreprof event, it appears to have a significant impact compared to system overhead, only put back in when we really need it

Make the statistic data for cache adaption irrelavent with the timer counter. Use smaller page for cache adaption version. Also make the cache policy decision modular

Add code for change the cache policy for the mutator.  In each round of gc, decide the new policy for each page according to the gathered statistic data and adapt the new policies right before finishing gc.

this micro benchmark does not accurately imitate OOOjava, just checking in current code for possible reuse later

a self-contained test of the mempool strategy, doesnt seem promising yet

Work In Progress Commit.
Added logic that will print out when traverser needs to look in waitingQueue/HashStructure. Separated enumeration of heaproots and printing of C methods (for the very end). Added TEMP functions that will create an array of HashStructures to simulate threadlocal variables (so that it's easier to debug)

Next Steps: Modify and Complete C-side. Test/Debug C-side. Connected both sides. Test/Debug both sides together.

Next Next Step: Work with Jim/YongHun to integrate RCR into main project.

change parser to match runtime changes, still some kooky issue where child events appear to take infinity perfent of parent sometimes, strange

task execute, dispatch, reture and work grabbing events debugged

Work In Progress Commit.
Added supporting data structures and logic for keeping track of what needs to be entered into a waitingQueue upon 'stopping' the traverser. Need to write code that spits out the correct C-code with waitingQueue stuff (halfway done)

Next steps: Do the above, separate the enumeration of heaproots and printing of C-methods until the very end, and modify/write C-side stuff to correctly respond to the generated calls.

Added logic for determining weakly connected groups of Heaproots and changed traverser invocation/generation method header to support resuming traversal from predefined points (incomplete, still need to modify addChecker to take advantage of the new header).

Changed parsing of coreprof data to keep parent/child event relationships, breaks parent into percentage spent in each child

Jim told me to change the int hashCodeSpecific() function to return id.hashCode() instead of id itself.

Changed coreprof macros to match coreprof.h, altered output to print self-time as a percentage of total time.

Several changes:

-Can control space allocated for coreprof events with a buildscript option.

-Attempted to exit ooojava worker threads gracefully with pthread_cleanup_XXX
and pthread_cancel in asynchronous mode.  Cleanup doesn't trigger from asynch
cancel, so this doesn't do the trick.  The reason this is nice is that COREPROF_EXIT
is never called by worker threads, so the timestamp of the MAIN duration is being
fudged by using the last timestamp of a sub event.  If we wanted to add more
interesting functionality to COREPROF_EXIT we can't use the workaround and we'll
have to revisit this--left the commented pthread code as a starting point for later.

-Adjusted event IDs and the baseshift so same number of bits are used, but
it is easier to look at the coreprof output file in a hex editor to visually
inspect the raw data, for debugging.

a test case for shutting down ooojava work threads gracefully

Added some extra logic for rehashing all effects by allocsite and (incomplete) logic to assing heap region #'s for weakly connected groups.

remove unnecessary dtlb flush

Fix the 'markbit' bug of cache-adapt multicoregc version.  In the compact phase, some cores might need to move some local objects to some other remote cores.  There could be cache incoherent problem caused by the mark bit.  To fix it, in the mark phase, whenever the mark bit is changed, flush it to the main memory and after the mark phase is finished add a 'barrier' before starting the compact phase

Clean multicore version code

Quick Change: Moved some misplaced comments.

Contains first sketch of waiting queue logic. The WaitingQueue struct will be removed in the future and the array be integrated into the Hashtable.

Add code for GC_CACHE_ADAPT version.  Now the 61-1gc version works for RayTracer.  Currently only change to use local caching for gc.  Will work on cache adaption for mutator's execution based on sampling statistics

Very, very rough draft of the hash structure to be used in the upcomming version of RuntimeConflictResolver. Only includes add logic that has not been finalized yet.

convenient run script

a makefile if desired

Fix a performance bug in the multicore gc version.  In hvc files, should not reserve more than 16M for a core's stack+heap.  Otherwise the performance would be greatly affected.  It is because that all the reserved memory in hvc files will take *wired* DTLB entries.  The more these entries are reserved, the less entries the program can use for other memory and thus the more DTLB miss would happen during execution.  Also fixed some small bugs that break non-gc version and add codes for DTLB flushing

Split debug flag for Java/C sides. Added logic to prevent duplicate traverse invocations to be processed/generated. Added support for StallSite invocations. Fixed logic for case: generation for c-side. Fixed logic for propogating conflict flags in the event of a revisited node. Updated method for generating csideinvocations.

Added StallSite RuntimeConflictResolver invocations. Placed RCR c-side init code in correct position. Added Guards to .dot debug printouts for RCR.

Changed variable type to make more compatible with RCR

fix wrong condition.
If one is coarse and others are fine item from same sese, just enqueue scc instead.

Changed the way conflict flags are propagated (fixed infinite loops, for reals this time). Removed extraneous code. Added tentative stallsite code.

Fixed bug of ignoring multiple effects for same alloc/field effect. Removed ! before checking hash in C.

Recent code changes: remove redundant code/comment and format the code a little bit

back out change to separate event type and timestamp streams, one stream supports future variable-length event data easily

checking bug fix for memory queue, the jury is still out on the formal verification of this fix

change garbage.c initial heap size to a macro, configurable with a new buildscript option

Changes. Contains bug where not all effects are saved into datastructure; checkin to create checkpoint to restore to if bugfix fails.

changes. add coarse case into our previous changes that we did for SOR benchmarks.

Temporarily integrates Runtime Conflict Resolution into buildCode and runtime with -rcr flag

fixed some include bugs

Added Changes requested by Jim. Fixed problem of infinite loop when reachGraph contains cycles. Fixed counter for parents with conflicts. Attempted to make methods with no traveral simply put a return (failed, will try again tomorrow). Builds Headerfile with guard. Correctly finds supplementry header files.

Generates syntatically correct code but appears to have problems with nesting multiple if statements (pushing processing into parent). Works fine if only pushing only 1 child into parent.

fix sese garbage collection bug calculating offsets to dependent sese pointers

Some tests that are helping with SESE garbage collection, incidentally the mlp regression test defeats our current ooo java runtime as well, gotta track that down some day

Mostly works, but has bug of not checking primative types for conflicts

did something I shouldnt have, mixed changes for two different projects at once, hard to back out now so heres a commit and ill physically check with everyone for immediate broken environemnts.  change 1, updating the coreprof system, in progress but stable for anyone not using coreprof and change 2, add an allocsite field to Objects in generated c code that is populated at allocation, stephen can use it, and maybe future ooojava subsystems, to tell what site an object was allocated at

fix to handle stall site properly for generating conflicts effect set.

interface to grab the conflict effect set for Stephen,

changes to have proper path of coreprof.h

introduces new flag for runtime conflict resolver.

Completed version before tying in with system and debug

fixes on FlatWriteDynamicVarNode to handle properly branch node.

fixes on tracking benchmark.

Fix bug in multicore gc: the master core should send msgs to all the other cores and tell them to stop for gc as soon as it finds that there is no more shared memory

fix some bug found by Yonghun

Changes.

document OOOJava and Disjoint options

polish source code + last changes.

polish source code and add test data

last changes to power benchmark

do subtraction

bug fixes for coreprof

fix bugs

accidental update

change

error in buildscript

more changes

changes

checking outstanding changes in my CVS
starting coreprof extension

changes.

changes.

changes.

changes.

check in bug fixes...yong-hun, these are already in your directory

small change to clean up allocation

new benchmark

changes.

add tracking benchmark

changes.

just java version

faithful c-port of crypt