new files

use sese pretty id and id to generate method names, param struct and local struct that is unique--keep a mapping of seses to the bogus flat method for retrieval in order to reproduce those names at call sites.  Also some bug fixes

Lots of changes that aren't working yet, so new methods are commented and existing code altered for new stuff is checked in.  Won't affect other compiler modes, and checks in stuff to reduce conflicts while getting the sese's working.

changes

more efficiency hacks...we're looking fields for values we already know, and doing arithmetic just to undo it..

more changes...fix soft abort case...it needs to let other transactions through...

change

 Add new files

slightly better locks for stm...

Updates to support multicore version runtime of Tilera. Also fix a bug in BuildCodeMulticore.java: it faulty omitted codes which repeatedly transfer objects to the same core. In current scheduling, to send 4 objs to 2 cores, it could be specified as an array [0,0,1,1] indicating the target cores for each object. Originaly the array was generated as [0,0,1,null] which caused missing of objects.

make atomic work in normal java mode...it just uses coarse locks

changes

various bug fixes

 add new files

changes to compile

try to simplify garbage collector lock

changes to build slightly more optimal code

changes:
1) bug fix
2) support for fast memcpy...contact me for objects

small changes
plus bugfixes...one race condition on riskyflag vs lock fixed

bug fix: acquire lock before copying the object into cache

bug fix: changes to make things safe for the GC

Good cut of variable analysis

When we stall for some specific SESE, make other variables that come from that SESE available as well

Change isAvailable to notAvailable, updated computations for that analysis, use those results to prune waitSet for stalls--looks good\!

compute when to write dynamic address of variables

small changes

Add new benchmark:....some prelimnary files

updates on Math operations for multicore version

small changes

throw out commented code

race condition fixed: race due to thread rec becoming NULL before accessing its field/element

commented out all functions by mistake

Curious.  Found a bug in liveness where liveIn set becomes empty erroneously.  While tracing bug back the output started producing the correct liveIn set, but the code diff confirms to me that I haven't made a functional change to the system.  I've been trying to understand what happened, but for now I'll check in this working, stable capture and keep an eye on liveness results in case the bug is just latent now.

updates for multicore version runtime, temporarily disable math operations in multicore version

add frame for another pass to compute whether variables are available, then use to do computation for stalls

locking technique for risky objects enabled

Add CodePlan object for injecting code before or after a FlatNode

Several bug fixes.  Now that tokens have a mutable element, reference var sets, they must be deep copied when merging table to avoid altering two tables with one operation.  A bug in removal by temp prevented sese-var mapping from being updated also.  A change in table implementation makes a difference between public and private ops like add and remove.  Any public op calls the private version and then asserts consistency.  Private versions can be called in more complex operatios and don't necessarily have to leave the table consistent until the bigger op is finished.  Much easier to find source of bugs this way.

This is BANANAS.  How can a table that calls assertConsistency all right before being put in a hashtable come out and fail the call?  Anyway, this is a stable compile but still a crash, but I fixed a get operation that was actually modifying the table while retrieving data.

Why did last checkin of VarSrcTokTable add carot-M to every line end but the whole file didn't show up in the cvs diff--anyway, looks like everything is touched but actually just taking that line character out and adding section to assertConsistency that makes sure reference var sets are consistent as well.

 do a make tabbing
 protect stats insde bounds
 add function to stm for instrumentation ---- still working on locks

convert token tables into triples that sets of reference temps map to, instead of quadruples that duplicate data.  Moved table consistency checks from analysis level to the exit of table-modification methods.  Note: this capture compiles but fails consistency checks\!

preliminary stall computation working

fixed liveness to calculate live-out set, and a couple other bugs

stable, something still wrong with calculating out-sets

stable capture, bug fixes--a problem: using an SESEs liveIn set liberally, some cases call for using an SESEs liveOut instead, I think, which is at least part of why no stalls are reported

Reinitialize liveness for the second pass, uses virtual reads to compute new answer.  The combination of liveness results and variable analysis still generates no stalls

Updating CVS with partially ported benchmark.  Sequencer.java's run() function is the last function to be ported, then compilation and testing.

Something is wrong with liveness results that want to prune away everything during stall computations, this stable capture shows all vars needed without liveness

added another liveness pass that picks up on virtual reads from stall pass, nasty bug fix in token table merge that left tables inconsistent

change makefile and add instructions to compile and run LeeRouter

Lots of bug fixes with regard to token table--table is consistent after every operation now, and an assertion method to verify consistency has been added for debugging

 generate stats in runtime. Use -stmstats option for compiling

variable analysis reports no stalls, stable

add Tilera version stuff in buildscript and removes some redundant codes to avoid compilation warnings

bug fixes and implementation adjustments: matches analysis up through IV

quick capture

change

change parsing

variable analysis stable, reports stalls all over--buggy

add a convenient method to retreive FlatMethod from task or method

optimizations for readLine(), this makes executions considerably faster

typos

optimization (or bug fix) depending on how you view it

Tests read from a  file that uses buffering directly, thereby eliminating the read method calls
to read number of rows from an input txt file

reorganize multicore version runtime codes for easy support of new platforms

variable analysis added

Root SESE ironed out, some reorganization for variable analysis.  Fixed-point variable analysis modeled after other fixed point stuff, but strangely exits early.  Build is stable though.

verified functionality and correctness with C versions

remove shortcircuits

make method static

print better error messages

barrier bug

small changes and support for printing doubles in String class

Add runtime support for STM Barrier class

 new Barrier Class

add new Barrier...the code still breaks on compiling.
enable printing double values

integrate typeanalysis

computes which types can actually refer to the same objects as other types

New locking strategy...  We no longer read lock objects...  Instead:
We first acquire all write locks.
We next for read object, we check that (1) it isn't locked and the version number matches.
The serialization point for the transaction occurs between the two checks...

initial checkin

variable source tokens have a temp for the live variable name and a temp for the source variable

reduce frequency of polling about GC

updates

test file for Double to String change

liveness analysis simplified to ignore SESE's, analyzes each SESE in isolation.  Results look correct, even for loops

reorganizing mlp analysis passes

changes

optimizations

another forward pass for mlp analysis

bug fixes for compilation...study functioning

changes to make compiler work without STM flag with atomic statements/etc

bug fix

changes

bug fixes

bug fixes.

debug support

finally fix bug...after a full day on this one.

Add new Barrier ...will need to change it to a better implementation

fixed liveness analysis