Fix the strategy for determination of when the gc mark phase is finished.  In phase 2, check if the number of send-out objs and received objs have been changed compared to that in the phase 1.  Also tuned the BAMBOO_SMEM_ZERO_UNIT_SIZE.  Looks like 4KB is OK.

Change the local hashtable for recording the pointer mapping info used in the gc flush phase and make it more efficient.  Basically never release allocated memory and use mask instead of modular for hash entry computation.

Change the zero out strategy for the shared memory.  Do not zero out all the shared memory at a time.  Each core will zero out the share memory chunk allocated to it when it gets the chunk from the master core.  Therefore the zero out process is parallelized.  Also do not zero out the whole chunk, instead, zero out only 4KB at a time when necessary so that there will not be much flush of L2 cache.

public VariableNode getVariableNodeNoMutation( TempDescriptor td ) was added for client modules to access the Reachgraph after the analysis is done and no modifications are to be made by the client module.

Add a new shared memory allocation strategy: mixed mode. Comparing to the fixed mode, there are following differences: 1) the neighbours cores are extended to the cores that a core can reach in no more than 2 flips; 2) introduced a threshold--if the master core can not allocate the neighbour cores' shared memory chunks, it checks current shared memory usage rate, if greater than the threshold it will enable gc, otherwise it tries to allocate the shared memory globally for the request core.

Add a new shared memory allocation strategy: fixed mode.  In this mode, the master core first allocates the 'local' shared memory chunks to each core.  When there are no more 'local' shared memory chunks for a core, the master core tries to allocate shared memory chunks that are belonging to the core's neighbour cores.  The priority of the neighbour cores are left-right-up-below.  If the master core failed again, it enables GC.

set the shared mem as 16MB

some subtle reach state bug fixes uncovered by labyrinth benchmark, the benchmark compiles under ooojava and runs to completion now

now it is working when only one machine left

recovery done

remove unnecessary files.

bring benchmarks to OoOJava: raytracer, kmeans, power, labyrinth.

change some bugs are fixed

bug fixes and extensions

plotall2

add plotting scripts to cvs

bug fix

incorporated OoOJava into build code + fixed a couple of small bugs

Statically ping memory from the nearest memory controller on the cores

debugged the reach graph support for effect conflicts

implemented details to support effect conflict detection

bug

more changes according to new effect analysis
and set up debug features of OoOJava analysis

changes according to new forms of effect analysis

tweak to interface

reachability query interface for ooojava heap conflict analysis added

getting close to effects for new disjoint analysis

little bug fix

changes.

stall site critical regions implemented, including method calls and return values

changes for debugging

restate inaccessible vars for stall site so facts get joined properly

new test case.

more effects bug fixes

bug fixes for effects analysis

my changes

stall site taints propagate awesomely, get cleared off also

forgot to add moved files back in, injecting stall site taints now also

changed organization and brought in a few new pieces for new disjoint+ooojava

changes.

add more steps to OoO analysis

working on the remaining procedures of OoOJava analysis.

Do effects as a global space, don't even need to consider call site transform, taints propagate interprocedurally and pick everything up, whoo hoo

both reach states and taints were not propagating to caller contexts with the correct caller-context predicates.  They should get the caller context predicates from the pre-call-site state or taint that indicated they should be brought from the callee.

more changes

changes

getting effects analysis going, need a few more pieces before call site analysis will work

print more data

updates to transsim for journal submission

rblock effects dont collect over method call, but its close

analysis collects effects per method and interprocedurally

Capture the version with shared hash table for pointer mapping info required in the flush phase

bug fix, now interprocedural seems cool, unitl the next bug HA

taints tested, propagate interprocedurally

rblock in set vars get tainted on rblock enter and wiped at rblock exit, works nicely

just an interesting test case I never got around to checking in or exploring too much

changes.

add rblock relation analysis and makefile aware of new analysis files

More pieces for new version of analysis

debugging..

chang

change

get set up part of the stall site analysis

Updated taint class to allow call site plus var taints as well

taints at reach graph level implemented

got the hooks in place to get taints for rblocks

set up OoOJava analysis.

Getting taints to propagate in new analysis, no parameter taints, RBLOCK taints only

change

recovery..
still needs to fix

Capture the version with mapinfo phase

capturing partially implemented taints before altering implementation

Forgot to include the makefile from the previous update.

Adding Labyrinth3D files

in mlp, Normal_Java is a form of Labyrinth3D that can compile under normal Java.
in mlp, rBlocked is the rBlocked version that will compile with our compiler
NOTE: there seems to be a bug with make java in that the program skips right over rBlocks to print out statistics on the last part of the program EVEN THOUGH there are data dependencies. Yonghun suspects it's a bug in the compiler and will investigate over the weekend

in Original, Normal_Java is the original Labyrinth3D code with TM code removed and slightly modded to work with Normal Java.

taints working intraprocedurally, a bug in inter I'm working out now

getting parameter taints in new analysis

get partially set up new version of disjoint analysis with OoOJava analysis checked in to properly fix compiler and get yong hun in on the workspace

Jim, could you check in the rest of disjointness so that this compiles?

This is a temporary fix to make the compiler work.

Under Original/Normal_Java/ one would find the original Labyrinth project ported to Transactional Memory by Jihoon and reported to normal Java by Stephen Yang

Under mlp is the Labyrinth project modified with rblocks. Under mlp/Normal_Java is a version that can be compiled and run on the normal Java platform. Under rBlocked is the rBlocked version that SHOULD run under OoOJava compiler. Both of which are ported by Stephen Yang (from Jihoon's original port)

NOTE that at this point in time, the rBlocked version causes a NullPointerException in the OoOJava compiler but will compile and produce correct results under normal Java.

generate emails

porting effects analysis

porting effects analysis to new disjoint analysis

Can now use the rblock keyword instead of sese keyword to write OoOJava programs, but both work interchangeably so old programs are still fine

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