PrintWriter outtaskdefs=null;
PrintWriter outoptionalarrays=null;
PrintWriter optionalheaders=null;
+ PrintWriter outglobaldefs=null;
try {
if (state.SANDBOX) {
outstructs=new PrintWriter(new FileOutputStream(PREFIX+"structdefs.h"), true);
outmethodheader=new PrintWriter(new FileOutputStream(PREFIX+"methodheaders.h"), true);
outclassdefs=new PrintWriter(new FileOutputStream(PREFIX+"classdefs.h"), true);
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ outglobaldefs=new PrintWriter(new FileOutputStream(PREFIX+"globaldefs.h"), true);
+ }
outmethod=new PrintWriter(new FileOutputStream(PREFIX+"methods.c"), true);
outvirtual=new PrintWriter(new FileOutputStream(PREFIX+"virtualtable.h"), true);
if (state.TASK) {
/* Build the virtual dispatch tables */
buildVirtualTables(outvirtual);
+ /* Tag the methods that are invoked by static blocks */
+ tagMethodInvokedByStaticBlock();
+
/* Output includes */
outmethodheader.println("#ifndef METHODHEADERS_H");
outmethodheader.println("#define METHODHEADERS_H");
outmethodheader.println("#include \"psemaphore.h\"");
outmethodheader.println("#include \"memPool.h\"");
+ if (state.RCR) {
+ outmethodheader.println("#include \"rcr_runtime.h\"");
+ }
+
// spit out a global to inform all worker threads with
// the maximum size is for any task record
outmethodheader.println("extern int "+maxTaskRecSizeStr+";");
// Output the C class declarations
// These could mutually reference each other
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ outglobaldefs.println("#ifndef __GLOBALDEF_H_");
+ outglobaldefs.println("#define __GLOBALDEF_H_");
+ outglobaldefs.println("");
+ outglobaldefs.println("struct global_defs_t {");
+ }
outclassdefs.println("#ifndef __CLASSDEF_H_");
outclassdefs.println("#define __CLASSDEF_H_");
- outputClassDeclarations(outclassdefs);
+ outputClassDeclarations(outclassdefs, outglobaldefs);
// Output function prototypes and structures for parameters
Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
while(it.hasNext()) {
ClassDescriptor cn=(ClassDescriptor)it.next();
- generateCallStructs(cn, outclassdefs, outstructs, outmethodheader);
+ generateCallStructs(cn, outclassdefs, outstructs, outmethodheader, outglobaldefs);
}
outclassdefs.println("#endif");
outclassdefs.close();
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ outglobaldefs.println("};");
+ outglobaldefs.println("");
+ outglobaldefs.println("extern struct global_defs_t * global_defs_p;");
+ outglobaldefs.println("#endif");
+ outglobaldefs.flush();
+ outglobaldefs.close();
+ }
if (state.TASK) {
/* Map flags to integers */
//TODO signal the object that will report errors
if(state.RCR) {
try {
- rcr = new RuntimeConflictResolver(PREFIX);
+ rcr = new RuntimeConflictResolver(PREFIX, oooa);
rcr.setGlobalEffects(oooa.getDisjointAnalysis().getEffectsAnalysis().getAllEffects());
} catch (FileNotFoundException e) {
System.out.println("Runtime Conflict Resolver could not create output file.");
}
+ rcr.init();
}
while(seseit.hasNext()){
FlatSESEEnterNode fsen = seseit.next();
initializeSESE( fsen );
-
- //this code will culminate all conflicts into one master hashtable.
- if(state.RCR && rcr != null) {
- Analysis.OoOJava.ConflictGraph conflictGraph;
- Hashtable<Taint, Set<Effect>> conflicts;
-
- System.out.println("-------");
- System.out.println(fsen);
- System.out.println(fsen.getIsCallerSESEplaceholder());
- System.out.println(fsen.getParent());
-
- if (fsen.getParent()!=null) {
- conflictGraph = oooa.getConflictGraph(fsen.getParent());
- System.out.println("CG="+conflictGraph);
- if (conflictGraph!=null)
- System.out.println("Conflicts="+conflictGraph.getConflictEffectSet(fsen));
- }
-
- if(!fsen.getIsCallerSESEplaceholder() && fsen.getParent()!=null &&
- (conflictGraph = oooa.getConflictGraph(fsen.getParent())) != null &&
- (conflicts = conflictGraph.getConflictEffectSet(fsen)) != null) {
- FlatMethod fm=fsen.getfmEnclosing();
- ReachGraph rg=oooa.getDisjointAnalysis().getReachGraph(fm.getMethod());
- if(rcr.cSideDebug)
- rg.writeGraph("RCR_RG_SESE_DEBUG");
-
- rcr.addToTraverseToDoList(fsen, rg, conflicts);
- }
- }
}
}
if(rcr != null) {
rcr.close();
System.out.println("Runtime Conflict Resolver Done.");
- }
+ }
+ }
+
+ /* This method goes though the call graph and tag those methods that are
+ * invoked inside static blocks
+ */
+ protected void tagMethodInvokedByStaticBlock() {
+ if(state.MGC) {
+ Iterator it_sclasses = this.state.getSClassSymbolTable().getDescriptorsIterator();
+ MethodDescriptor current_md=null;
+ HashSet tovisit=new HashSet();
+ HashSet visited=new HashSet();
+
+ while(it_sclasses.hasNext()) {
+ ClassDescriptor cd = (ClassDescriptor)it_sclasses.next();
+ MethodDescriptor md = (MethodDescriptor)cd.getMethodTable().get("staticblocks");
+ if(md != null) {
+ tovisit.add(md);
+ }
+ }
+
+ while(!tovisit.isEmpty()) {
+ current_md=(MethodDescriptor)tovisit.iterator().next();
+ tovisit.remove(current_md);
+ visited.add(current_md);
+ Iterator it_callee = this.callgraph.getCalleeSet(current_md).iterator();
+ while(it_callee.hasNext()) {
+ Descriptor d = (Descriptor)it_callee.next();
+ if(d instanceof MethodDescriptor) {
+ if(!visited.contains(d)) {
+ ((MethodDescriptor)d).setIsInvokedByStatic(true);
+ tovisit.add(d);
+ }
+ }
+ }
+ }
+ } // TODO for normal Java version
+ }
+
+ /* This code generates code for each static block and static field
+ * initialization.*/
+ protected void outputStaticBlocks(PrintWriter outmethod) {
+ // execute all the static blocks and all the static field initializations
+ // TODO
}
+ /* This code generates code to create a Class object for each class for
+ * getClass() method.
+ * */
+ protected void outputClassObjects(PrintWriter outmethod) {
+ // for each class, initialize its Class object
+ if(state.MGC) {
+ SymbolTable ctbl = this.state.getClassSymbolTable();
+ Iterator it_classes = ctbl.getDescriptorsIterator();
+ while(it_classes.hasNext()) {
+ ClassDescriptor t_cd = (ClassDescriptor)it_classes.next();
+ outmethod.println(" {");
+ outmethod.println(" global_defs_p->"+t_cd.getSafeSymbol()+"classobj.type="+t_cd.getId()+";");
+ outmethod.println(" initlock((struct ___Object___ *)(&(global_defs_p->"+t_cd.getSafeSymbol()+"classobj)));");
+ outmethod.println(" }");
+ }
+ } // else TODO normal java version
+ }
/* This code just generates the main C method for java programs.
* The main C method packs up the arguments into a string array
* and passes it to the java main method. */
- private void outputMainMethod(PrintWriter outmethod) {
+ protected void outputMainMethod(PrintWriter outmethod) {
outmethod.println("int main(int argc, const char *argv[]) {");
outmethod.println(" int i;");
+
+ outputStaticBlocks(outmethod);
+ outputClassObjects(outmethod);
if (state.MLP || state.OOOJAVA) {
//initializes data structures needed for the RCR traverser
if(state.RCR && rcr != null) {
outmethod.println(" initializeStructsRCR();");
+ outmethod.println(" createAndFillMasterHashStructureArray();");
}
}
outmethod.println("#include \"localobjects.h\"");
}
if(state.MULTICORE) {
- outmethod.println("#include \"task.h\"");
+ if(state.TASK) {
+ outmethod.println("#include \"task.h\"");
+ }
outmethod.println("#include \"multicoreruntime.h\"");
outmethod.println("#include \"runtime_arch.h\"");
}
- if (state.THREAD||state.DSM||state.SINGLETM)
+ if (state.THREAD||state.DSM||state.SINGLETM) {
outmethod.println("#include <thread.h>");
+ }
+ if(state.MGC) {
+ outmethod.println("#include \"thread.h\"");
+ }
if (state.main!=null) {
outmethod.println("#include <string.h>");
}
outmethod.println("#include \"mlp_runtime.h\"");
outmethod.println("#include \"psemaphore.h\"");
- if( state.RCR && rcr != null) {
+ if( state.RCR ) {
+ outmethod.println("#include \"trqueue.h\"");
outmethod.println("#include \"RuntimeConflictResolver.h\"");
+ outmethod.println("#include \"rcr_runtime.h\"");
+ outmethod.println("#include \"hashStructure.h\"");
}
}
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ outmethod.println("struct global_defs_t * global_defs_p;");
+ }
//Store the sizes of classes & array elements
generateSizeArray(outmethod);
outstructs.println("#include \"mlp_runtime.h\"");
outstructs.println("#include \"psemaphore.h\"");
}
+ if (state.RCR) {
+ outstructs.println("#include \"rcr_runtime.h\"");
+ }
+
/* Output #defines that the runtime uses to determine type
* numbers for various objects it needs */
}
}
- protected void outputClassDeclarations(PrintWriter outclassdefs) {
+ protected void outputClassDeclarations(PrintWriter outclassdefs, PrintWriter outglobaldefs) {
if (state.THREAD||state.DSM||state.SINGLETM)
outclassdefs.println("#include <pthread.h>");
outclassdefs.println("#ifndef INTPTR");
while(it.hasNext()) {
ClassDescriptor cn=(ClassDescriptor)it.next();
outclassdefs.println("struct "+cn.getSafeSymbol()+";");
+
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
+ // this class has static fields/blocks, need to add a global flag to
+ // indicate if its static fields have been initialized and/or if its
+ // static blocks have been executed
+ outglobaldefs.println(" int "+cn.getSafeSymbol()+"static_block_exe_flag;");
+ }
+
+ // for each class, create a global object
+ outglobaldefs.println(" struct Class "+cn.getSafeSymbol()+"classobj;");
+ }
}
outclassdefs.println("");
//Print out definition for array type
outclassdefs.println(" void * lockentry;");
outclassdefs.println(" int lockcount;");
}
+ if(state.MGC) {
+ outclassdefs.println(" int mutex;");
+ outclassdefs.println(" int objlock;");
+ if(state.MULTICOREGC) {
+ outclassdefs.println(" int marked;");
+ }
+ }
if (state.TASK) {
outclassdefs.println(" int flag;");
if(!state.MULTICORE) {
outclassdefs.println(" int * fses;");
}
}
- printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs);
+ printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs, outglobaldefs);
if (state.STMARRAY) {
outclassdefs.println(" int lowindex;");
outclassdefs.println(" int ___length___;");
outclassdefs.println("};\n");
+
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ outclassdefs.println("");
+ //Print out definition for Class type
+ outclassdefs.println("struct Class {");
+ outclassdefs.println(" int type;");
+ if(state.MLP || state.OOOJAVA ){
+ outclassdefs.println(" int oid;");
+ outclassdefs.println(" int allocsite;");
+ }
+ if (state.EVENTMONITOR) {
+ outclassdefs.println(" int objuid;");
+ }
+ if (state.THREAD) {
+ outclassdefs.println(" pthread_t tid;");
+ outclassdefs.println(" void * lockentry;");
+ outclassdefs.println(" int lockcount;");
+ }
+ if(state.MGC) {
+ outclassdefs.println(" int mutex;");
+ outclassdefs.println(" int objlock;");
+ if(state.MULTICOREGC) {
+ outclassdefs.println(" int marked;");
+ }
+ }
+ if (state.TASK) {
+ outclassdefs.println(" int flag;");
+ if(!state.MULTICORE) {
+ outclassdefs.println(" void * flagptr;");
+ } else {
+ outclassdefs.println(" int version;");
+ outclassdefs.println(" int * lock;"); // lock entry for this obj
+ outclassdefs.println(" int mutex;");
+ outclassdefs.println(" int lockcount;");
+ if(state.MULTICOREGC) {
+ outclassdefs.println(" int marked;");
+ }
+ }
+ if(state.OPTIONAL) {
+ outclassdefs.println(" int numfses;");
+ outclassdefs.println(" int * fses;");
+ }
+ }
+ printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs, outglobaldefs);
+ outclassdefs.println("};\n");
+ }
+
+ outclassdefs.println("");
outclassdefs.println("extern int classsize[];");
outclassdefs.println("extern int hasflags[];");
outclassdefs.println("extern unsigned INTPTR * pointerarray[];");
outclassdefs.println("extern int supertypes[];");
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ outclassdefs.println("#include \"globaldefs.h\"");
+ }
+ outclassdefs.println("");
}
/** Prints out definitions for generic task structures */
classit=state.getClassSymbolTable().getDescriptorsIterator();
while(classit.hasNext()) {
ClassDescriptor cd=(ClassDescriptor)classit.next();
+ if(cd.isInterface()) {
+ continue;
+ }
if (state.DSM||state.SINGLETM)
fillinRow(cd, lbvirtualtable, cd.getId());
else
/* Get inherited methods */
if (cd.getSuperDesc()!=null)
fillinRow(cd.getSuperDesc(), virtualtable, rownum);
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ Iterator it_sifs = cd.getSuperInterfaces();
+ while(it_sifs.hasNext()) {
+ ClassDescriptor superif = (ClassDescriptor)it_sifs.next();
+ fillinRow(superif, virtualtable, rownum);
+ }
+ }
/* Override them with our methods */
for(Iterator it=cd.getMethods(); it.hasNext();) {
MethodDescriptor md=(MethodDescriptor)it.next();
outclassdefs.print("int numprefetchsites = " + pa.prefetchsiteid + ";\n");
if(this.state.MLP || state.OOOJAVA ){
outclassdefs.print("extern __thread int oid;\n");
- outclassdefs.print("extern int numWorkers;\n");
+ outclassdefs.print("extern int numWorkSchedWorkers;\n");
}
Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
cdarray[0] = null;
while(it.hasNext()) {
ClassDescriptor cd=(ClassDescriptor)it.next();
- cdarray[cd.getId()]=cd;
+ if(!cd.isInterface()) {
+ cdarray[cd.getId()]=cd;
+ }
}
arraytable=new TypeDescriptor[state.numArrays()];
/** Force consistent field ordering between inherited classes. */
- private void printClassStruct(ClassDescriptor cn, PrintWriter classdefout) {
+ private void printClassStruct(ClassDescriptor cn, PrintWriter classdefout, PrintWriter globaldefout) {
ClassDescriptor sp=cn.getSuperDesc();
if (sp!=null)
- printClassStruct(sp, classdefout);
+ printClassStruct(sp, classdefout, globaldefout);
if (!fieldorder.containsKey(cn)) {
Vector fields=new Vector();
FieldDescriptor fd=(FieldDescriptor)fields.get(i);
if (fd.getType().isClass()||fd.getType().isArray())
classdefout.println(" struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
- else
+ else if ((state.MGC) && (fd.isStatic())) {
+ // TODO add version for normal Java later
+ // static field
+ if(fd.isVolatile()) {
+ globaldefout.println(" volatile "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
+ } else {
+ globaldefout.println(" "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
+ }
+ classdefout.println(" "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
+ } else if ((state.MGC) && (fd.isVolatile())) {
+ // TODO add version for normal Java later
+ // static field
+ globaldefout.println(" volatile "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
+ classdefout.println(" "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
+ } else
classdefout.println(" "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
}
}
* passed in (when PRECISE GC is enabled) and (2) function
* prototypes for the methods */
- protected void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout) {
+ protected void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout, PrintWriter globaldefout) {
/* Output class structure */
classdefout.println("struct "+cn.getSafeSymbol()+" {");
classdefout.println(" int type;");
classdefout.println(" void * lockentry;");
classdefout.println(" int lockcount;");
}
-
+ if(state.MGC) {
+ classdefout.println(" int mutex;");
+ classdefout.println(" int objlock;");
+ if(state.MULTICOREGC) {
+ classdefout.println(" int marked;");
+ }
+ }
if (state.TASK) {
classdefout.println(" int flag;");
if((!state.MULTICORE) || (cn.getSymbol().equals("TagDescriptor"))) {
classdefout.println(" int * fses;");
}
}
- printClassStruct(cn, classdefout);
+ printClassStruct(cn, classdefout, globaldefout);
classdefout.println("};\n");
if (state.DSM||state.SINGLETM) {
Iterator<SESEandAgePair> pItr = callerSESEplaceholder.getNeededStaticNames().iterator();
while( pItr.hasNext() ) {
SESEandAgePair pair = pItr.next();
- output.println(" void* "+pair+";");
+ output.println(" void* "+pair+" = NULL;");
}
// declare variables for tracking dynamic sources
}
}
- }
+ }
/* Check to see if we need to do a GC if this is a
}
}
}
+
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ if(fm.getMethod().isStaticBlock()) {
+ // a static block, check if it has been executed
+ output.println(" if(global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag != 0) {");
+ output.println(" return;");
+ output.println(" }");
+ output.println("");
+ }
+ if((!fm.getMethod().isStaticBlock()) && (fm.getMethod().getReturnType() == null) && (cn != null)){
+ // is a constructor, check and output initialization of the static fields
+ // here does not initialize the static fields of the class, instead it
+ // redirect the corresponding fields in the object to the global_defs_p
+ Vector fields=(Vector)fieldorder.get(cn);
+
+ for(int i=0; i<fields.size(); i++) {
+ FieldDescriptor fd=(FieldDescriptor)fields.get(i);
+ if(fd.isStatic()) {
+ // static field
+ output.println(generateTemp(fm,fm.getParameter(0),lb)+"->"+fd.getSafeSymbol()+"=&(global_defs_p->"+cn.getSafeSymbol()+fd.getSafeSymbol()+");");
+ }
+ }
+ }
+ }
generateCode(fm.getNext(0), fm, lb, null, output, true);
// used in the following code, but let's just leave the working
// implementation unless there is actually a problem...
- Vector<TempDescriptor> inset=fsen.getInVarVector();
- int incount=0;
-
+ Vector<TempDescriptor> inset=fsen.getInVarsForDynamicCoarseConflictResolution();
for(int i=0; i<inset.size();i++) {
TempDescriptor temp=inset.get(i);
- TypeDescriptor type=temp.getType();
- if(type.isPtr()) {
- incount++;
- if (temp.getType().isNull())
- outputStructs.println(" void * "+temp.getSafeSymbol()+
- "; /* in-or-out-set obj in gl */");
- else
- outputStructs.println(" struct "+temp.getType().getSafeSymbol()+" * "+
- temp.getSafeSymbol()+"; /* in-or-out-set obj in gl */");
- }
+ if (temp.getType().isNull())
+ outputStructs.println(" void * "+temp.getSafeSymbol()+
+ "; /* in-or-out-set obj in gl */");
+ else
+ outputStructs.println(" struct "+temp.getType().getSafeSymbol()+" * "+
+ temp.getSafeSymbol()+"; /* in-or-out-set obj in gl */");
}
for(int i=0; i<objectparams.numPointers(); i++) {
}
if (state.RCR) {
- outputStructs.println("struct rcrRecord rcrRecords["+incount+"]");
+ if (inset.size()!=0)
+ outputStructs.println("struct rcrRecord rcrRecords["+inset.size()+"];");
}
if( fsen.getFirstDepRecField() != null ) {
// initialize thread-local var to a the task's record, which is fused
// with the param list
output.println(" ");
- output.println(" /* code of this task's body should use this to access the running task record */");
+ output.println(" // code of this task's body should use this to access the running task record");
output.println(" runningSESE = &(___params___->common);");
+ output.println(" childSESE = 0;");
output.println(" ");
// setup memory queue
output.println( "#ifndef OOO_DISABLE_TASKMEMPOOL" );
if( !fsen.getIsLeafSESE() ) {
output.println(" runningSESE->taskRecordMemPool = poolcreate( "+
- maxTaskRecSizeStr+" );");
+ maxTaskRecSizeStr+", freshTaskRecordInitializer );");
+ if (state.RCR && !rcr.hasEmptyTraversers(fsen)) {
+ output.println(" createTR();");
+ output.println(" runningSESE->allHashStructures=TRqueue->allHashStructures;");
+ }
} else {
// make it clear we purposefully did not initialize this
- output.println(" runningSESE->taskRecordMemPool = (MemPool*)0x1;");
+ output.println(" runningSESE->taskRecordMemPool = (MemPool*)0x7;");
}
output.println( "#endif // OOO_DISABLE_TASKMEMPOOL" );
outmethod.println( " char errmsg[128];");
// generate a case for each SESE class that can be invoked
- outmethod.println( " switch( *((int*)seseRecord) ) {");
+ outmethod.println( " switch( ((SESEcommon*)seseRecord)->classID ) {");
outmethod.println( " ");
Iterator<FlatSESEEnterNode> seseit;
if(state.MLP){
if( (state.MLP && fsen.equals( mlpa.getMainSESE() )) ||
(state.OOOJAVA && fsen.equals( oooa.getMainSESE() ))
) {
- outmethod.println( " /* work scheduler works forever, explicitly exit */");
- outmethod.println( " CP_EXIT();");
- outmethod.println( " CP_DUMP();");
outmethod.println( " workScheduleExit();");
- outmethod.println( " exit( 0 );");
}
outmethod.println( " break;");
protected void generateCode(FlatNode first,
FlatMethod fm,
LocalityBinding lb,
- Set<FlatNode> stopset,
- PrintWriter output, boolean firstpass) {
+ Set<FlatNode> stopset,
+ PrintWriter output,
+ boolean firstpass) {
/* Assign labels to FlatNode's if necessary.*/
assert fsxn.getFlatEnter().equals( fsen );
}
if (current_node.kind()!=FKind.FlatReturnNode) {
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
+ // a static block, check if it has been executed
+ output.println(" global_defs_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
+ output.println("");
+ }
+ }
output.println(" return;");
}
current_node=null;
throw new Error();
}
+
+ void stallMEMRCR(FlatMethod fm, FlatNode fn, Set<Analysis.OoOJava.WaitingElement> waitingElementSet, PrintWriter output) {
+ output.println("// stall on parent's stall sites ");
+ output.println(" {");
+ output.println(" REntry* rentry;");
+ output.println(" // stallrecord sometimes is used as a task record for instance ");
+ output.println(" // when you call RELEASE_REFERENCE_TO on a stall record.");
+ output.println(" // so the parent field must be initialized.");
+ output.println(" SESEstall * stallrecord=(SESEstall *) poolalloc(runningSESE->taskRecordMemPool);");
+ output.println(" stallrecord->common.parent=runningSESE;");
+ output.println(" stallrecord->common.unresolvedDependencies=10000;");
+ output.println(" stallrecord->common.rcrstatus=1;");
+ output.println(" stallrecord->common.offsetToParamRecords=(INTPTR) & (((SESEstall *)0)->rcrRecords);");
+ output.println(" stallrecord->common.refCount = 10003;");
+ output.println(" int localCount=10000;");
+ output.println(" stallrecord->rcrRecords[0].index=0;");
+ output.println(" stallrecord->rcrRecords[0].flag=0;");
+ output.println(" stallrecord->rcrRecords[0].next=NULL;");
+ output.println(" stallrecord->common.parentsStallSem=&runningSESEstallSem;");
+ output.println(" psem_reset( &runningSESEstallSem);");
+ output.println(" stallrecord->tag=runningSESEstallSem.tag;");
+
+ TempDescriptor stalltd=null;
+ for (Iterator iterator = waitingElementSet.iterator(); iterator.hasNext();) {
+ Analysis.OoOJava.WaitingElement waitingElement =(Analysis.OoOJava.WaitingElement) iterator.next();
+ if (waitingElement.getStatus() >= ConflictNode.COARSE) {
+ output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "]," + waitingElement.getStatus()
+ + ", (SESEcommon *) stallrecord, 1LL);");
+ } else {
+ throw new Error("Fine-grained conflict: This should not happen in RCR");
+ }
+ output.println(" rentry->queue=runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "];");
+ output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "],rentry)==NOTREADY) {");
+ output.println(" localCount--;");
+ output.println(" }");
+ output.println("#if defined(RCR)&&!defined(OOO_DISABLE_TASKMEMPOOL)");
+ output.println(" else poolfreeinto(runningSESE->memoryQueueArray["+waitingElement.getQueueID()+"]->rentrypool, rentry);");
+ output.println("#endif");
+ if (stalltd==null) {
+ stalltd=waitingElement.getTempDesc();
+ } else if (stalltd!=waitingElement.getTempDesc()) {
+ throw new Error("Multiple temp descriptors at stall site"+stalltd+"!="+waitingElement.getTempDesc());
+ }
+ }
+
+ //did all of the course grained stuff
+ output.println(" if(!atomic_sub_and_test(localCount, &(stallrecord->common.unresolvedDependencies))) {");
+ //have to do fine-grained work also
+ output.println(" stallrecord->___obj___=(struct ___Object___ *)"
+ + generateTemp(fm, stalltd, null) + ";");
+ output.println(" stallrecord->common.classID=-"
+ + rcr.getTraverserID(stalltd, fn) + ";");
+
+ output.println(" enqueueTR(TRqueue, (void *)stallrecord);");
+
+ if (state.COREPROF) {
+ output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
+ output
+ .println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_BEGIN );");
+ output.println("#endif");
+ }
+
+ output.println(" psem_take( &runningSESEstallSem, (struct garbagelist *)&___locals___ );");
+
+ if (state.COREPROF) {
+ output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
+ output
+ .println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_END );");
+ output.println("#endif");
+ }
+
+ output.println(" } else {");//exit if condition
+ //release traversers reference if we didn't use traverser
+ output.println("#ifndef OOO_DISABLE_TASKMEMPOOL");
+ output.println(" RELEASE_REFERENCE_TO((SESEcommon *)stallrecord);");
+ output.println("#endif");
+ output.println(" }");
+ //release our reference to stall record
+ output.println("#ifndef OOO_DISABLE_TASKMEMPOOL");
+ output.println(" RELEASE_REFERENCE_TO((SESEcommon *)stallrecord);");
+ output.println("#endif");
+ output.println(" }");//exit block
+ }
+
protected void generateFlatNode(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output) {
// insert pre-node actions from the code plan
output.println(" "+pair.getSESE().getSESErecordName()+"* child = ("+
pair.getSESE().getSESErecordName()+"*) "+pair+";");
- output.println(" SESEcommon* common = (SESEcommon*) "+pair+";");
+ output.println(" SESEcommon* childCom = (SESEcommon*) "+pair+";");
+
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKSTALLVAR");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLVAR, CP_EVENTTYPE_BEGIN );");
output.println("#endif");
}
- output.println(" pthread_mutex_lock( &(common->lock) );");
- output.println(" if( common->doneExecuting == FALSE ) {");
- output.println(" stopforgc((struct garbagelist *)&___locals___);");
- output.println(" do {");
- output.println(" pthread_cond_wait( &(common->doneCond), &(common->lock) );");
- output.println(" } while( common->doneExecuting == FALSE );");
- output.println(" restartaftergc();");
- output.println(" }");
- output.println(" pthread_mutex_unlock( &(common->lock) );");
+
+ output.println(" pthread_mutex_lock( &(childCom->lock) );");
+ output.println(" if( childCom->doneExecuting == FALSE ) {");
+ output.println(" psem_reset( &runningSESEstallSem );");
+ output.println(" childCom->parentsStallSem = &runningSESEstallSem;");
+ output.println(" pthread_mutex_unlock( &(childCom->lock) );");
+ output.println(" psem_take( &runningSESEstallSem, (struct garbagelist *)&___locals___ );");
+ output.println(" } else {");
+ output.println(" pthread_mutex_unlock( &(childCom->lock) );");
+ output.println(" }");
// copy things we might have stalled for
Iterator<TempDescriptor> tdItr = cp.getCopySet( vst ).iterator();
output.println(" "+generateTemp( fmContext, td, null )+
" = child->"+vst.getAddrVar().getSafeSymbol()+";");
}
+
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKSTALLVAR");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLVAR, CP_EVENTTYPE_END );");
output.println("#endif");
}
+
output.println(" }");
}
// otherwise the dynamic write nodes will have the local var up-to-date
output.println(" {");
output.println(" if( "+dynVar+"_srcSESE != NULL ) {");
- output.println(" SESEcommon* common = (SESEcommon*) "+dynVar+"_srcSESE;");
+
+ output.println(" SESEcommon* childCom = (SESEcommon*) "+dynVar+"_srcSESE;");
+
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKSTALLVAR");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLVAR, CP_EVENTTYPE_BEGIN );");
output.println("#endif");
}
- output.println(" psem_take( &(common->stallSem) );");
+
+ output.println(" pthread_mutex_lock( &(childCom->lock) );");
+ output.println(" if( childCom->doneExecuting == FALSE ) {");
+ output.println(" psem_reset( &runningSESEstallSem );");
+ output.println(" childCom->parentsStallSem = &runningSESEstallSem;");
+ output.println(" pthread_mutex_unlock( &(childCom->lock) );");
+ output.println(" psem_take( &runningSESEstallSem, (struct garbagelist *)&___locals___ );");
+ output.println(" } else {");
+ output.println(" pthread_mutex_unlock( &(childCom->lock) );");
+ output.println(" }");
FlatMethod fmContext;
if( currentSESE.getIsCallerSESEplaceholder() ) {
fmContext = currentSESE.getfmBogus();
}
- TypeDescriptor type=dynVar.getType();
+ TypeDescriptor type = dynVar.getType();
String typeStr;
if( type.isNull() ) {
typeStr = "void*";
output.println(" "+generateTemp( fmContext, dynVar, null )+
" = *(("+typeStr+"*) ((void*)"+
dynVar+"_srcSESE + "+dynVar+"_srcOffset));");
+
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKSTALLVAR");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLVAR, CP_EVENTTYPE_END );");
output.println("#endif");
}
+
output.println(" }");
output.println(" }");
}
// eom
// handling stall site
if (state.OOOJAVA) {
- Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(currentSESE);
+ // NEED TO FIX IT
+ // assumes that there is only one parent, but it is possible that
+ // currentSESE has more than one so we need to generate
+ // conditional case for each parent case
+ Analysis.OoOJava.ConflictGraph graph = null;
+ if(currentSESE.getSESEParent().size()>0){
+ graph = oooa.getConflictGraph(currentSESE.getSESEParent().iterator().next());
+ }
+// Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(currentSESE);
if(graph!=null){
Set<Analysis.OoOJava.SESELock> seseLockSet = oooa.getLockMappings(graph);
- Set<Analysis.OoOJava.WaitingElement> waitingElementSet =
- graph.getStallSiteWaitingElementSet(fn, seseLockSet);
+ Set<Analysis.OoOJava.WaitingElement> waitingElementSet = graph.getStallSiteWaitingElementSet(fn, seseLockSet);
- if(waitingElementSet.size()>0){
- output.println("// stall on parent's stall sites ");
- output.println(" {");
- output.println(" REntry* rentry;");
-
- for (Iterator iterator = waitingElementSet.iterator(); iterator.hasNext();) {
- Analysis.OoOJava.WaitingElement waitingElement = (Analysis.OoOJava.WaitingElement) iterator.next();
-
- if(state.RCR && rcr != null){
- Analysis.OoOJava.ConflictGraph conflictGraph = graph;
- Hashtable<Taint, Set<Effect>> conflicts;
- ReachGraph rg = oooa.getDisjointAnalysis().getReachGraph(currentSESE.getmdEnclosing());
- if(rcr.cSideDebug) {
- rg.writeGraph("RCR_RG_STALLSITE_DEBUG");
- }
- if((conflictGraph != null) &&
- (conflicts = graph.getConflictEffectSet(fn)) != null &&
- (rg != null)){
- rcr.addToTraverseToDoList(fn, waitingElement.getTempDesc(), rg, conflicts);
- }
- }
-
- if( waitingElement.getStatus() >= ConflictNode.COARSE ){
- output.println(" rentry=mlpCreateREntry("+ waitingElement.getStatus()+ ", runningSESE);");
- }else{
- output.println(" rentry=mlpCreateFineREntry("+ waitingElement.getStatus()+ ", runningSESE, (void*)&" +generateTemp(fm,waitingElement.getTempDesc(),lb)+ ");");
- }
- output.println(" psem_init( &(rentry->parentStallSem) );");
- output.println(" rentry->queue=runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "];");
- output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()
- + "],rentry)==NOTREADY){");
- if( state.COREPROF ) {
- output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
- output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_BEGIN );");
- output.println("#endif");
- }
- output.println(" psem_take( &(rentry->parentStallSem) );");
- if( state.COREPROF ) {
- output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
- output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_END );");
- output.println("#endif");
- }
- output.println(" } ");
-
- if(state.RCR && rcr != null) {
- output.println(" "+rcr.getTraverserInvocation(waitingElement.getTempDesc(),
- generateTemp(fm, waitingElement.getTempDesc(), null), fn));
- }
- }
- output.println(" }");
- }
- }
- }else{
+ if (waitingElementSet.size() > 0) {
+ if (state.RCR) {
+ stallMEMRCR(fm, fn, waitingElementSet, output);
+ } else {
+ output.println("// stall on parent's stall sites ");
+ output.println(" {");
+ output.println(" REntry* rentry;");
+
+ for (Iterator iterator = waitingElementSet.iterator(); iterator.hasNext();) {
+ Analysis.OoOJava.WaitingElement waitingElement =
+ (Analysis.OoOJava.WaitingElement) iterator.next();
+ if (waitingElement.getStatus() >= ConflictNode.COARSE) {
+ output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "]," + waitingElement.getStatus()
+ + ", runningSESE);");
+ } else {
+ output.println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "]," + waitingElement.getStatus()
+ + ", runningSESE, (void*)&"
+ + generateTemp(fm, waitingElement.getTempDesc(), lb) + ");");
+ }
+ output.println(" rentry->parentStallSem=&runningSESEstallSem;");
+ output.println(" psem_reset( &runningSESEstallSem);");
+ output.println(" rentry->tag=runningSESEstallSem.tag;");
+ output.println(" rentry->queue=runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "];");
+ output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "],rentry)==NOTREADY){");
+ if (state.COREPROF) {
+ output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
+ output
+ .println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_BEGIN );");
+ output.println("#endif");
+ }
+
+ output.println(" psem_take( &runningSESEstallSem, (struct garbagelist *)&___locals___ );");
+
+ if (state.COREPROF) {
+ output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
+ output
+ .println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_END );");
+ output.println("#endif");
+ }
+ output.println(" } ");
+ }
+ output.println(" }");
+ }
+ }
+ }
+ } else{
ParentChildConflictsMap conflictsMap = mlpa.getConflictsResults().get(fn);
if (conflictsMap != null) {
Set<Long> allocSet = conflictsMap.getAllocationSiteIDSetofStallSite();
if( waitingElement.getStatus() >= ConflictNode.COARSE ){
// HERE! a parent might conflict with a child
- output.println(" rentry=mlpCreateREntry("+ waitingElement.getStatus()+ ", runningSESE);");
- }else{
- output.println(" rentry=mlpCreateFineREntry("+ waitingElement.getStatus()+ ", runningSESE, (void*)&___locals___."+ waitingElement.getDynID() + ");");
+ output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "],"+ waitingElement.getStatus()+ ", runningSESE);");
+ } else {
+ output.println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "],"+ waitingElement.getStatus()+ ", runningSESE, (void*)&___locals___."+ waitingElement.getDynID() + ");");
}
- output.println(" psem_init( &(rentry->parentStallSem) );");
+ output.println(" rentry->parentStallSem=&runningSESEstallSem;");
+ output.println(" psem_reset( &runningSESEstallSem);");
+ output.println(" rentry->tag=runningSESEstallSem.tag;");
output.println(" rentry->queue=runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "];");
- output
- .println(" if(ADDRENTRY(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()
- + "],rentry)==NOTREADY){");
+ output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+"],rentry)==NOTREADY) {");
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_BEGIN );");
output.println("#endif");
}
- output.println(" psem_take( &(rentry->parentStallSem) );");
+ output.println(" psem_take( &runningSESEstallSem, (struct garbagelist *)&___locals___ );");
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_END );");
public void generateFlatSESEEnterNode( FlatMethod fm,
LocalityBinding lb,
FlatSESEEnterNode fsen,
- PrintWriter output
- ) {
+ PrintWriter output) {
// if MLP flag is off, okay that SESE nodes are in IR graph,
// just skip over them and code generates exactly the same
if( !(state.MLP || state.OOOJAVA) ) {
output.println(" CP_LOGEVENT( CP_EVENTID_TASKDISPATCH, CP_EVENTTYPE_BEGIN );");
output.println("#endif");
}
-
+
+
// before doing anything, lock your own record and increment the running children
if( (state.MLP && fsen != mlpa.getMainSESE()) ||
(state.OOOJAVA && fsen != oooa.getMainSESE())
- ) {
- output.println(" atomic_inc(&(runningSESE->numRunningChildren));");
+ ) {
+ output.println(" childSESE++;");
}
// allocate the space for this record
output.println( "#ifndef OOO_DISABLE_TASKMEMPOOL" );
+
+ output.println( "#ifdef CP_EVENTID_POOLALLOC");
+ output.println( " CP_LOGEVENT( CP_EVENTID_POOLALLOC, CP_EVENTTYPE_BEGIN );");
+ output.println( "#endif");
if( (state.MLP && fsen != mlpa.getMainSESE()) ||
(state.OOOJAVA && fsen != oooa.getMainSESE())
) {
output.println(" "+
fsen.getSESErecordName()+"* seseToIssue = ("+
fsen.getSESErecordName()+"*) poolalloc( runningSESE->taskRecordMemPool );");
+ output.println(" CHECK_RECORD( seseToIssue );");
} else {
output.println(" "+
fsen.getSESErecordName()+"* seseToIssue = ("+
fsen.getSESErecordName()+"*) mlpAllocSESErecord( sizeof( "+
fsen.getSESErecordName()+" ) );");
}
+ output.println( "#ifdef CP_EVENTID_POOLALLOC");
+ output.println( " CP_LOGEVENT( CP_EVENTID_POOLALLOC, CP_EVENTTYPE_END );");
+ output.println( "#endif");
+
output.println( "#else // OOO_DISABLE_TASKMEMPOOL" );
output.println(" "+
fsen.getSESErecordName()+"* seseToIssue = ("+
output.println(" struct garbagelist * gl= (struct garbagelist *)&(((SESEcommon*)(seseToIssue))[1]);");
output.println(" gl->size="+calculateSizeOfSESEParamList(fsen)+";");
output.println(" gl->next = NULL;");
+ output.println(" seseToIssue->common.rentryIdx=0;");
+
+ if(state.RCR) {
+ //flag the SESE status as 1...it will be reset
+ output.println(" seseToIssue->common.rcrstatus=1;");
+ }
// there are pointers to SESE records the newly-issued SESE
// will use to get values it depends on them for--how many
);
}
- if (state.RCR) {
- output.println(" seseToIssumer->common.offsetToParamRecords=(INTPTR)sizeof("+fsen.getSESErecordName()+") - (INTPTR) & ((("+fsen.getSESErecordName()+"*)0)->rcrRecords);");
+ if (state.RCR&&fsen.getInVarsForDynamicCoarseConflictResolution().size()>0) {
+ output.println(" seseToIssue->common.offsetToParamRecords=(INTPTR) & ((("+fsen.getSESErecordName()+"*)0)->rcrRecords);");
}
// fill in common data
output.println(" int localCount=0;");
output.println(" seseToIssue->common.classID = "+fsen.getIdentifier()+";");
- output.println(" psem_init( &(seseToIssue->common.stallSem) );");
- output.println(" seseToIssue->common.forwardList = createQueue();");
output.println(" seseToIssue->common.unresolvedDependencies = 10000;");
- output.println(" pthread_cond_init( &(seseToIssue->common.doneCond), NULL );");
+ output.println(" seseToIssue->common.parentsStallSem = NULL;");
+ output.println(" initQueue(&seseToIssue->common.forwardList);");
output.println(" seseToIssue->common.doneExecuting = FALSE;");
- output.println(" pthread_cond_init( &(seseToIssue->common.runningChildrenCond), NULL );");
output.println(" seseToIssue->common.numRunningChildren = 0;");
+ output.println( "#ifdef OOO_DISABLE_TASKMEMPOOL" );
+ output.println(" pthread_cond_init( &(seseToIssue->common.runningChildrenCond), NULL );");
+ output.println("#endif");
output.println(" seseToIssue->common.parent = runningSESE;");
// start with refCount = 2, one being the count that the child itself
// will decrement when it retires, to say it is done using its own
// record, and the other count is for the parent that will remember
// the static name of this new child below
- output.println(" seseToIssue->common.refCount = 2;");
+ if( state.RCR ) {
+ // if we're using RCR, ref count is 3 because the traverser has
+ // a reference, too
+ if( fsen != oooa.getMainSESE() && fsen.getInVarsForDynamicCoarseConflictResolution().size()>0){
+ output.println(" seseToIssue->common.refCount = 10003;");
+ } else {
+ output.println(" seseToIssue->common.refCount = 10002;");
+ }
+ output.println(" int refCount=10000;");
+ } else {
+ output.println(" seseToIssue->common.refCount = 2;");
+ }
// all READY in-vars should be copied now and be done with it
Iterator<TempDescriptor> tempItr = fsen.getReadyInVarSet().iterator();
// before potentially adding this SESE to other forwarding lists,
// create it's lock
+ output.println( "#ifdef OOO_DISABLE_TASKMEMPOOL" );
output.println(" pthread_mutex_init( &(seseToIssue->common.lock), NULL );");
+ output.println("#endif");
if( (state.MLP && fsen != mlpa.getMainSESE()) ||
(state.OOOJAVA && fsen != oooa.getMainSESE())
output.println(" pthread_mutex_lock( &(src->lock) );");
// FORWARD TODO
output.println(" if( !src->doneExecuting ) {");
- output.println(" addNewItem( src->forwardList, seseToIssue );");
+ output.println(" addNewItem( &src->forwardList, seseToIssue );");
output.println(" ++(localCount);");
output.println(" }");
output.println("#ifndef OOO_DISABLE_TASKMEMPOOL" );
// FORWARD TODO
- output.println(" if( isEmpty( src->forwardList ) ||");
- output.println(" seseToIssue != peekItem( src->forwardList ) ) {");
+ output.println(" if( isEmpty( &src->forwardList ) ||");
+ output.println(" seseToIssue != peekItem( &src->forwardList ) ) {");
output.println(" if( !src->doneExecuting ) {");
- output.println(" addNewItem( src->forwardList, seseToIssue );");
+ output.println(" addNewItem( &src->forwardList, seseToIssue );");
output.println(" ++(localCount);");
output.println(" }");
output.println(" }");
}
+
+
// maintain pointers for finding dynamic SESE
// instances from static names
SESEandAgePair pairNewest = new SESEandAgePair( fsen, 0 );
if( fsen.getParent() != null &&
fsen.getParent().getNeededStaticNames().contains( pairNewest )
) {
+ output.println(" {");
+ output.println("#ifndef OOO_DISABLE_TASKMEMPOOL" );
+ output.println(" SESEcommon* oldest = "+pairOldest+";");
+ output.println("#endif // OOO_DISABLE_TASKMEMPOOL" );
for( int i = fsen.getOldestAgeToTrack(); i > 0; --i ) {
SESEandAgePair pair1 = new SESEandAgePair( fsen, i );
SESEandAgePair pair2 = new SESEandAgePair( fsen, i-1 );
- output.println(" "+pair1+" = "+pair2+";");
+ output.println(" "+pair1+" = "+pair2+";");
}
- output.println(" "+pairNewest+" = &(seseToIssue->common);");
+ output.println(" "+pairNewest+" = &(seseToIssue->common);");
// no need to add a reference to whatever is the newest record, because
// we initialized seseToIssue->refCount to *2*
// but release a reference to whatever was the oldest BEFORE the shift
output.println("#ifndef OOO_DISABLE_TASKMEMPOOL" );
- output.println(" if( "+pairOldest+" != NULL ) {");
- output.println(" RELEASE_REFERENCE_TO( "+pairOldest+" );");
- output.println(" }");
+ output.println(" if( oldest != NULL ) {");
+ output.println(" RELEASE_REFERENCE_TO( oldest );");
+ output.println(" }");
output.println("#endif // OOO_DISABLE_TASKMEMPOOL" );
+ output.println(" }");
}
- if (state.RCR) {
-
-
- }
-
- if(state.RCR) {
- //TODO BCD
- //clear out the parameter records
-
+ if( state.COREPROF ) {
+ output.println("#ifdef CP_EVENTID_PREPAREMEMQ");
+ output.println(" CP_LOGEVENT( CP_EVENTID_PREPAREMEMQ, CP_EVENTTYPE_BEGIN );");
+ output.println("#endif");
}
////////////////
// count up memory conflict dependencies,
- // eom
- if(state.OOOJAVA){
- FlatSESEEnterNode parent = fsen.getParent();
- Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(parent);
+ if(state.RCR) {
+ dispatchMEMRC(fm, lb, fsen, output);
+ } else if(state.OOOJAVA){
+ // NEED TO FIX IT
+ // assumes that there is only one parent, but it is possible that
+ // currentSESE has more than one so we need to generate
+ // conditional case for each parent case
+ assert fsen.getSESEParent().size()>0;
+ FlatSESEEnterNode parent = fsen.getSESEParent().iterator().next();
+ Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(parent);
if (graph != null && graph.hasConflictEdge()) {
Set<Analysis.OoOJava.SESELock> seseLockSet = oooa.getLockMappings(graph);
output.println();
Analysis.OoOJava.WaitingElement waitingElement
= (Analysis.OoOJava.WaitingElement) iterator2.next();
if (waitingElement.getStatus() >= ConflictNode.COARSE) {
- output.println(" rentry=mlpCreateREntry("
+ output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["+ queueID+ "],"
+ waitingElement.getStatus()
+ ", &(seseToIssue->common));");
} else {
+ "_srcSESE+seseToIssue->"
+ waitingElement.getDynID()
+ "_srcOffset;");
- output.println(" rentry=mlpCreateFineREntry("
+ output.println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["+ queueID+ "],"
+ waitingElement.getStatus()
+ ", &(seseToIssue->common), pointer );");
} else if (fsen.getStaticInVarSet().contains(td)) {
+ waitingElement
.getDynID()
+ ";");
- output.println(" rentry=mlpCreateFineREntry("
+ output.println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["+ queueID+ "],"
+ waitingElement.getStatus()
+ ", &(seseToIssue->common), pointer );");
}
} else {
- output.println(" rentry=mlpCreateFineREntry("
+ output.println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["+ queueID+ "],"
+ waitingElement.getStatus()
+ ", &(seseToIssue->common), (void*)&seseToIssue->"
+ waitingElement.getDynID()
+ "],rentry)==NOTREADY) {");
output.println(" localCount++;");
output.println(" }");
-
- // Trying to execute the dynamic coarse grain conflict strategy...
- if(state.RCR && rcr != null) {
- boolean useParentContext = false;
-
- if( (state.MLP &&fsen != mlpa.getMainSESE()) ||
- (state.OOOJAVA &&fsen != oooa.getMainSESE())) {
- assert fsen.getParent() != null;
- if( !fsen.getParent().getIsCallerSESEplaceholder() ) {
- useParentContext = true;
- }
- }
-
- for (TempDescriptor invar : fsen.getInVarsForDynamicCoarseConflictResolution()) {
- String varString;
- if( useParentContext ) {
- varString = generateTemp( fsen.getParent().getfmBogus(), invar, null );
- } else {
- varString = generateTemp( fsen.getfmEnclosing(), invar, null );
- }
- output.println(" "+rcr.getTraverserInvocation(invar, varString, fsen));
- }
- }
- }else{
+ } else {
output.println(" ADDRENTRYTOBUF(runningSESE->memoryQueueArray[" + waitingElement.getQueueID() + "],rentry);");
}
}
WaitingElement waitingElement = (WaitingElement) iterator2
.next();
if (waitingElement.getStatus() >= ConflictNode.COARSE) {
- output.println(" rentry=mlpCreateREntry("
+ output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["+ queueID+ "],"
+ waitingElement.getStatus()
+ ", &(seseToIssue->common));");
} else {
+ waitingElement.getDynID()
+ "_srcOffset;");
output
- .println(" rentry=mlpCreateFineREntry("
+ .println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["+ queueID+ "],"
+ waitingElement
.getStatus()
+ ", &(seseToIssue->common), pointer );");
.getDynID()
+ ";");
output
- .println(" rentry=mlpCreateFineREntry("
+ .println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["+ queueID+ "],"
+ waitingElement
.getStatus()
+ ", &(seseToIssue->common), pointer );");
}
} else {
output
- .println(" rentry=mlpCreateFineREntry("
+ .println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["+ queueID+ "],"
+ waitingElement
.getStatus()
+ ", &(seseToIssue->common), (void*)&seseToIssue->"
}
}
+ if( state.COREPROF ) {
+ output.println("#ifdef CP_EVENTID_PREPAREMEMQ");
+ output.println(" CP_LOGEVENT( CP_EVENTID_PREPAREMEMQ, CP_EVENTTYPE_END );");
+ output.println("#endif");
+ }
+
// Enqueue Task Record
if (state.RCR) {
- output.println(" enqueueTR((void *)seseToIssue);");
+ if( fsen != oooa.getMainSESE() && fsen.getInVarsForDynamicCoarseConflictResolution().size()>0){
+ output.println(" enqueueTR(TRqueue, (void *)seseToIssue);");
+ }
}
// if there were no outstanding dependencies, issue here
output.println(" workScheduleSubmit( (void*)seseToIssue );");
output.println(" }");
+
+
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKDISPATCH");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKDISPATCH, CP_EVENTTYPE_END );");
}
- public void generateFlatSESEExitNode( FlatMethod fm,
- LocalityBinding lb,
- FlatSESEExitNode fsexn,
- PrintWriter output
- ) {
+ void dispatchMEMRC(FlatMethod fm, LocalityBinding lb, FlatSESEEnterNode fsen, PrintWriter output) {
+ // NEED TO FIX IT
+ // assumes that there is only one parent, but it is possible that
+ // currentSESE has more than one so we need to generate
+ // conditional case for each parent case
+ assert fsen.getSESEParent().size()>0;
+ FlatSESEEnterNode parent = fsen.getSESEParent().iterator().next();
+ Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(parent);
+ if (graph != null && graph.hasConflictEdge()) {
+ Set<Analysis.OoOJava.SESELock> seseLockSet = oooa.getLockMappings(graph);
+ Analysis.OoOJava.SESEWaitingQueue seseWaitingQueue=graph.getWaitingElementSetBySESEID(fsen.getIdentifier(), seseLockSet);
+ if(seseWaitingQueue.getWaitingElementSize()>0) {
+ output.println(" {");
+ output.println(" REntry* rentry=NULL;");
+ output.println(" INTPTR* pointer=NULL;");
+ output.println(" seseToIssue->common.rentryIdx=0;");
+ Vector<TempDescriptor> invars=fsen.getInVarsForDynamicCoarseConflictResolution();
+ System.out.println(fm.getMethod()+"["+invars+"]");
+
+ Vector<Long> queuetovar=new Vector<Long>();
+
+ for(int i=0;i<invars.size();i++) {
+ TempDescriptor td=invars.get(i);
+ Set<Analysis.OoOJava.WaitingElement> weset=seseWaitingQueue.getWaitingElementSet(td);
+ int numqueues=0;
+ Set<Integer> queueSet=new HashSet<Integer>();
+ for (Iterator iterator = weset.iterator(); iterator.hasNext();) {
+ Analysis.OoOJava.WaitingElement we = (Analysis.OoOJava.WaitingElement) iterator.next();
+ Integer queueID=new Integer( we.getQueueID());
+ if(!queueSet.contains(queueID)){
+ numqueues++;
+ queueSet.add(queueID);
+ }
+ }
+ output.println(" seseToIssue->rcrRecords["+i+"].flag="+numqueues+";");
+ output.println(" seseToIssue->rcrRecords["+i+"].index=0;");
+ output.println(" seseToIssue->rcrRecords["+i+"].next=NULL;");
+ output.println(" int dispCount"+i+"=0;");
+
+ for (Iterator<Analysis.OoOJava.WaitingElement> wtit = weset.iterator(); wtit.hasNext();) {
+ Analysis.OoOJava.WaitingElement waitingElement = wtit.next();
+ int queueID = waitingElement.getQueueID();
+ if (queueID >= queuetovar.size())
+ queuetovar.setSize(queueID + 1);
+ Long l = queuetovar.get(queueID);
+ long val = (l != null) ? l.longValue() : 0;
+ val = val | (1 << i);
+ queuetovar.set(queueID, new Long(val));
+ }
+ }
+
+ HashSet generatedqueueentry=new HashSet();
+ for(int i=0;i<invars.size();i++) {
+ TempDescriptor td=invars.get(i);
+ Set<Analysis.OoOJava.WaitingElement> weset=seseWaitingQueue.getWaitingElementSet(td);
+ for(Iterator<Analysis.OoOJava.WaitingElement> wtit=weset.iterator();wtit.hasNext();) {
+ Analysis.OoOJava.WaitingElement waitingElement=wtit.next();
+ int queueID=waitingElement.getQueueID();
+
+ if(waitingElement.isBogus()){
+ continue;
+ }
+
+ if (generatedqueueentry.contains(queueID))
+ continue;
+ else
+ generatedqueueentry.add(queueID);
+
+ assert(waitingElement.getStatus()>=ConflictNode.COARSE);
+ long mask=queuetovar.get(queueID);
+ output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "]," + waitingElement.getStatus() + ", &(seseToIssue->common), "+mask+"LL);");
+ output.println(" rentry->count=2;");
+ output.println(" seseToIssue->common.rentryArray[seseToIssue->common.rentryIdx++]=rentry;");
+ output.println(" rentry->queue=runningSESE->memoryQueueArray[" + waitingElement.getQueueID()+"];");
+
+ output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "],rentry)==READY) {");
+ for(int j=0;mask!=0;j++) {
+ if ((mask&1)==1)
+ output.println(" dispCount"+j+"++;");
+ mask=mask>>1;
+ }
+ output.println(" } else ");
+ output.println(" refCount--;");
+
+ }
+
+ if (fsen.getDynamicInVarSet().contains(td)) {
+ // dynamic in-var case
+ //output.println(" pointer=seseToIssue->" + waitingElement.getDynID()+ "_srcSESE+seseToIssue->"+ waitingElement.getDynID()+ "_srcOffset;");
+ //output.println(" rentry=mlpCreateFineREntry("+ waitingElement.getStatus()+ ", &(seseToIssue->common), pointer );");
+ }
+ }
+ for(int i=0;i<invars.size();i++) {
+ output.println(" if(!dispCount"+i+" || !atomic_sub_and_test(dispCount"+i+",&(seseToIssue->rcrRecords["+i+"].flag)))");
+ output.println(" localCount++;");
+ }
+ output.println(" }");
+ }
+ }
+ output.println("#ifndef OOO_DISABLE_TASKMEMPOOL");
+ output.println(" RELEASE_REFERENCES_TO((SESEcommon *)seseToIssue, refCount);");
+ output.println("#endif");
+ }
+
+ public void generateFlatSESEExitNode( FlatMethod fm,
+ LocalityBinding lb,
+ FlatSESEExitNode fsexn,
+ PrintWriter output) {
// if MLP flag is off, okay that SESE nodes are in IR graph,
// just skip over them and code generates exactly the same
output.println("#endif");
}
- String com = paramsprefix+"->common";
// this SESE cannot be done until all of its children are done
// so grab your own lock with the condition variable for watching
// that the number of your running children is greater than zero
- output.println(" pthread_mutex_lock( &("+com+".lock) );");
- output.println(" if ( "+com+".numRunningChildren > 0 ) {");
- output.println(" stopforgc((struct garbagelist *)&___locals___);");
+ output.println(" atomic_add(childSESE, &runningSESE->numRunningChildren);");
+ output.println(" pthread_mutex_lock( &(runningSESE->lock) );");
+ output.println(" if( runningSESE->numRunningChildren > 0 ) {");
+ output.println(" stopforgc( (struct garbagelist *)&___locals___ );");
output.println(" do {");
- output.println(" pthread_cond_wait( &("+com+".runningChildrenCond), &("+com+".lock) );");
- output.println(" } while( "+com+".numRunningChildren > 0 );");
+ output.println(" pthread_cond_wait( &(runningSESE->runningChildrenCond), &(runningSESE->lock) );");
+ output.println(" } while( runningSESE->numRunningChildren > 0 );");
output.println(" restartaftergc();");
output.println(" }");
" = "+from+";");
}
- // mark yourself done, your SESE data is now read-only
- output.println(" "+com+".doneExecuting = TRUE;");
- output.println(" pthread_cond_signal( &("+com+".doneCond) );");
- output.println(" pthread_mutex_unlock( &("+com+".lock) );");
+ // mark yourself done, your task data is now read-only
+ output.println(" runningSESE->doneExecuting = TRUE;");
+
+ // if parent is stalling on you, let them know you're done
+ if( (state.MLP && fsexn.getFlatEnter() != mlpa.getMainSESE()) ||
+ (state.OOOJAVA && fsexn.getFlatEnter() != oooa.getMainSESE())
+ ) {
+ output.println(" if( runningSESE->parentsStallSem != NULL ) {");
+ output.println(" psem_give( runningSESE->parentsStallSem );");
+ output.println(" }");
+ }
+
+ output.println(" pthread_mutex_unlock( &(runningSESE->lock) );");
// decrement dependency count for all SESE's on your forwarding list
// FORWARD TODO
- output.println(" while( !isEmpty( "+com+".forwardList ) ) {");
- output.println(" SESEcommon* consumer = (SESEcommon*) getItem( "+com+".forwardList );");
+ output.println(" while( !isEmpty( &runningSESE->forwardList ) ) {");
+ output.println(" SESEcommon* consumer = (SESEcommon*) getItem( &runningSESE->forwardList );");
- output.println(" if(consumer->rentryIdx>0){");
- output.println(" // resolved null pointer");
- output.println(" int idx;");
- output.println(" for(idx=0;idx<consumer->rentryIdx;idx++){");
- output.println(" resolvePointer(consumer->rentryArray[idx]);");
- output.println(" }");
- output.println(" }");
-
-
- output.println(" if( atomic_sub_and_test(1, &(consumer->unresolvedDependencies)) ){");
+ if (!state.RCR) {
+ output.println(" if(consumer->rentryIdx>0){");
+ output.println(" // resolved null pointer");
+ output.println(" int idx;");
+ output.println(" for(idx=0;idx<consumer->rentryIdx;idx++){");
+ output.println(" resolvePointer(consumer->rentryArray[idx]);");
+ output.println(" }");
+ output.println(" }");
+ }
+
+ output.println(" if( atomic_sub_and_test( 1, &(consumer->unresolvedDependencies) ) ){");
output.println(" workScheduleSubmit( (void*)consumer );");
output.println(" }");
output.println(" }");
- // eom
// clean up its lock element from waiting queue, and decrement dependency count for next SESE block
- if( (state.MLP && fsen != mlpa.getMainSESE()) ||
- (state.OOOJAVA && fsen != oooa.getMainSESE())
- ) {
-
- output.println();
- output.println(" /* check memory dependency*/");
- output.println(" {");
- output.println(" int idx;");
- output.println(" for(idx=0;idx<___params___->common.rentryIdx;idx++){");
- output.println(" REntry* re=___params___->common.rentryArray[idx];");
- output.println(" RETIRERENTRY(re->queue,re);");
- output.println(" }");
- output.println(" }");
-
+ if((state.MLP && fsen != mlpa.getMainSESE()) ||
+ (state.OOOJAVA && fsen != oooa.getMainSESE())) {
+ output.println();
+ output.println(" /* check memory dependency*/");
+ output.println(" {");
+ output.println(" int idx;");
+ output.println(" for(idx=0;idx<___params___->common.rentryIdx;idx++){");
+ output.println(" REntry* re=___params___->common.rentryArray[idx];");
+ output.println(" RETIRERENTRY(re->queue,re);");
+ output.println(" }");
+ output.println(" }");
}
- // if parent is stalling on you, let them know you're done
- if( (state.MLP && fsexn.getFlatEnter() != mlpa.getMainSESE()) ||
- (state.OOOJAVA && fsexn.getFlatEnter() != oooa.getMainSESE())
- ) {
- output.println(" psem_give( &("+paramsprefix+"->common.stallSem) );");
+ Vector<TempDescriptor> inset=fsen.getInVarsForDynamicCoarseConflictResolution();
+ if (state.RCR && inset.size() > 0) {
+ /* Make sure the running SESE is finished */
+ output.println(" if (unlikely(runningSESE->rcrstatus!=0)) {");
+ output.println(" if(CAS(&runningSESE->rcrstatus,1,0)==2) {");
+ output.println(" while(runningSESE->rcrstatus) {");
+ output.println(" BARRIER();");
+ output.println(" sched_yield();");
+ output.println(" }");
+ output.println(" }");
+ output.println(" }");
+ output.println("{");
+ output.println(" int idx,idx2;");
+
+ output.println(" struct rcrRecord *rec;");
+ output
+ .println(" struct Hashtable_rcr ** hashstruct=runningSESE->parent->allHashStructures;");
+
+ for (int i = 0; i < inset.size(); i++) {
+ output.println(" rec=&" + paramsprefix + "->rcrRecords[" + i + "];");
+ output.println(" while(rec!=NULL) {");
+ output.println(" for(idx2=0;idx2<rec->index;idx2++) {");
+
+ int weaklyConnectedComponentIndex = rcr.getWeakID(inset.get(i), fsen);
+
+ output.println(" rcr_RETIREHASHTABLE(hashstruct[" + weaklyConnectedComponentIndex
+ + "],&(___params___->common), rec->array[idx2], (BinItem_rcr *) rec->ptrarray[idx2]);");
+
+ output.println(" }");// exit idx2 for loop
+ output.println(" rec=rec->next;");
+ output.println(" }");// exit rec while loop
+ }
+ output.println("}");
}
- // last of all, decrement your parent's number of running children
- output.println(" if( "+paramsprefix+"->common.parent != NULL ) {");
- output.println(" if (atomic_sub_and_test(1, &"+paramsprefix+"->common.parent->numRunningChildren)) {");
- output.println(" pthread_mutex_lock( &("+paramsprefix+"->common.parent->lock) );");
- output.println(" pthread_cond_signal( &("+paramsprefix+"->common.parent->runningChildrenCond) );");
- output.println(" pthread_mutex_unlock( &("+paramsprefix+"->common.parent->lock) );");
- output.println(" }");
- output.println(" }");
// a task has variables to track static/dynamic instances
// that serve as sources, release the parent's ref of each
// destroy this task's mempool if it is not a leaf task
if( !fsen.getIsLeafSESE() ) {
output.println(" pooldestroy( runningSESE->taskRecordMemPool );");
+ if (state.RCR && fsen.getInVarsForDynamicCoarseConflictResolution().size() > 0 ) {
+ output.println(" returnTR();");
+ }
}
output.println("#endif // OOO_DISABLE_TASKMEMPOOL" );
+ output.println("{");
+ output.println("SESEcommon *myparent=runningSESE->parent;");
+
// if this is not the Main sese (which has no parent) then return
// THIS task's record to the PARENT'S task record pool, and only if
// the reference count is now zero
// the main task has no parent, just free its record
output.println(" mlpFreeSESErecord( runningSESE );");
}
+
+
+ // last of all, decrement your parent's number of running children
+ output.println(" if( myparent != NULL ) {");
+ output.println(" if( atomic_sub_and_test( 1, &(myparent->numRunningChildren) ) ) {");
+ output.println(" pthread_mutex_lock ( &(myparent->lock) );");
+ output.println(" pthread_cond_signal ( &(myparent->runningChildrenCond) );");
+ output.println(" pthread_mutex_unlock( &(myparent->lock) );");
+ output.println(" }");
+ output.println(" }");
+
+ output.println("}");
// as this thread is wrapping up the task, make sure the thread-local var
// for the currently running task record references an invalid task
MethodDescriptor md=fc.getMethod();
ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null ? locality.getBinding(lb, fc) : md);
ClassDescriptor cn=md.getClassDesc();
+
+ // if the called method is a static block or a static method or a constructor
+ // need to check if it can be invoked inside some static block
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ if((md.isStatic() || md.isStaticBlock() || md.isConstructor()) &&
+ ((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic()))) {
+ if(!md.isInvokedByStatic()) {
+ System.err.println("Error: a method that is invoked inside a static block is not tagged!");
+ }
+ // is a static block or is invoked in some static block
+ ClassDescriptor cd = fm.getMethod().getClassDesc();
+ if(cd == cn) {
+ // the same class, do nothing
+ // TODO may want to invoke static field initialization here
+ } else {
+ if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
+ // need to check if the class' static fields have been initialized and/or
+ // its static blocks have been executed
+ output.println("#ifdef MGC_STATIC_INIT_CHECK");
+ output.println("if(global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
+ if(cn.getNumStaticFields() != 0) {
+ // TODO add static field initialization here
+ }
+ if(cn.getNumStaticBlocks() != 0) {
+ MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
+ output.println(" "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
+ } else {
+ output.println(" global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
+ }
+ output.println("}");
+ output.println("#endif // MGC_STATIC_INIT_CHECK");
+ }
+ }
+ }
+ }
+
output.println("{");
if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
if (lb!=null) {
if (!GENERATEPRECISEGC && !this.state.MULTICOREGC) {
if (fc.getThis()!=null) {
- TypeDescriptor ptd=md.getThis().getType();
+ TypeDescriptor ptd=null;
+ if(md.getThis() != null) {
+ ptd = md.getThis().getType();
+ } else {
+ ptd = fc.getThis().getType();
+ }
if (needcomma)
output.print(",");
if (ptd.isClass()&&!ptd.isArray())
} else{
// DEBUG if(!ffn.getDst().getType().isPrimitive()){
// DEBUG output.println("within((void*)"+generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+");");
-// DEBUG }
- output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
+// DEBUG }
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ if(ffn.getField().isStatic()) {
+ // static field
+ if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
+ // is a static block or is invoked in some static block
+ ClassDescriptor cd = fm.getMethod().getClassDesc();
+ ClassDescriptor cn = ffn.getSrc().getType().getClassDesc();
+ if(cd == cn) {
+ // the same class, do nothing
+ // TODO may want to invoke static field initialization here
+ } else {
+ if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
+ // need to check if the class' static fields have been initialized and/or
+ // its static blocks have been executed
+ output.println("#ifdef MGC_STATIC_INIT_CHECK");
+ output.println("if(global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
+ if(cn.getNumStaticFields() != 0) {
+ // TODO add static field initialization here
+ }
+ if(cn.getNumStaticBlocks() != 0) {
+ MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
+ output.println(" "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
+ } else {
+ output.println(" global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
+ }
+ output.println("}");
+ output.println("#endif // MGC_STATIC_INIT_CHECK");
+ }
+ }
+ }
+ // redirect to the global_defs_p structure
+ if(ffn.getSrc().getType().isStatic()) {
+ // reference to the static field with Class name
+ output.println(generateTemp(fm, ffn.getDst(),lb)+"=global_defs_p->"+ ffn.getSrc().getType().getClassDesc().getSafeSymbol()+ffn.getField().getSafeSymbol()+";");
+ } else {
+ output.println(generateTemp(fm, ffn.getDst(),lb)+"=*"+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
+ }
+ //output.println(generateTemp(fm, ffn.getDst(),lb)+"=global_defs_p->"+ffn.getSrc().getType().getClassDesc().getSafeSymbol()+"->"+ ffn.getField().getSafeSymbol()+";");
+ } else {
+ output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
+ }
+ } else {
+ output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
+ }
}
}
// DEBUG if(!fsfn.getField().getType().isPrimitive()){
// DEBUG output.println("within((void*)"+generateTemp(fm,fsfn.getSrc(),lb)+");");
-// DEBUG }
- output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
+// DEBUG }
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ if(fsfn.getField().isStatic()) {
+ // static field
+ if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
+ // is a static block or is invoked in some static block
+ ClassDescriptor cd = fm.getMethod().getClassDesc();
+ ClassDescriptor cn = fsfn.getDst().getType().getClassDesc();
+ if(cd == cn) {
+ // the same class, do nothing
+ // TODO may want to invoke static field initialization here
+ } else {
+ if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
+ // need to check if the class' static fields have been initialized and/or
+ // its static blocks have been executed
+ output.println("#ifdef MGC_STATIC_INIT_CHECK");
+ output.println("if(global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag == 0) {");
+ if(cn.getNumStaticFields() != 0) {
+ // TODO add static field initialization here
+ }
+ if(cn.getNumStaticBlocks() != 0) {
+ MethodDescriptor t_md = (MethodDescriptor)cn.getMethodTable().get("staticblocks");
+ output.println(" "+cn.getSafeSymbol()+t_md.getSafeSymbol()+"_"+t_md.getSafeMethodDescriptor()+"();");
+ } else {
+ output.println(" global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag = 1;");
+ }
+ output.println("}");
+ output.println("#endif // MGC_STATIC_INIT_CHECK");
+ }
+ }
+ }
+ // redirect to the global_defs_p structure
+ if(fsfn.getDst().getType().isStatic()) {
+ // reference to the static field with Class name
+ output.println("global_defs_p->" + fsfn.getDst().getType().getClassDesc().getSafeSymbol() + fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
+ } else {
+ output.println("*"+generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
+ }
+ } else {
+ output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
+ }
+ } else {
+ output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
+ }
}
}
} else if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
if(this.state.MLP || state.OOOJAVA){
output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray_mlp("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+", oid, "+oooa.getDisjointAnalysis().getAllocationSiteFromFlatNew(fn).getUniqueAllocSiteID()+");");
- output.println(" oid += numWorkers;");
+ output.println(" oid += numWorkSchedWorkers;");
}else{
output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray("+localsprefixaddr+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
}
} else if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
if (this.state.MLP || state.OOOJAVA){
output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new_mlp("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+", oid, "+oooa.getDisjointAnalysis().getAllocationSiteFromFlatNew(fn).getUniqueAllocSiteID()+");");
- output.println(" oid += numWorkers;");
+ output.println(" oid += numWorkSchedWorkers;");
} else {
output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new("+localsprefixaddr+", "+fn.getType().getClassDesc().getId()+");");
}
}
protected void generateFlatReturnNode(FlatMethod fm, LocalityBinding lb, FlatReturnNode frn, PrintWriter output) {
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
+ // a static block, check if it has been executed
+ output.println(" global_defs_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
+ output.println("");
+ }
+ }
if (frn.getReturnTemp()!=null) {
if (frn.getReturnTemp().getType().isPtr())
output.println("return (struct "+fm.getMethod().getReturnType().getSafeSymbol()+"*)"+generateTemp(fm, frn.getReturnTemp(), lb)+";");
projects / IRC.git / blobdiff