X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=Robust%2Fsrc%2FIR%2FFlat%2FBuildCode.java;h=8781ff4e3ca832db40545acb02f3d86ce2a20c59;hb=4cb63e913202459da4fe9d01feb7c02f1b98dd6f;hp=cc9b78fbce1ed09829ab3807b30c80bea9adf834;hpb=5f508e687d0a52fd936072e00e46690cca38c19d;p=IRC.git diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java index cc9b78fb..8781ff4e 100644 --- a/Robust/src/IR/Flat/BuildCode.java +++ b/Robust/src/IR/Flat/BuildCode.java @@ -6,12 +6,17 @@ import IR.Tree.TagExpressionList; import IR.*; import java.util.*; import java.io.*; + import Util.Relation; import Analysis.TaskStateAnalysis.FlagState; +import Analysis.TaskStateAnalysis.FlagComparator; import Analysis.TaskStateAnalysis.OptionalTaskDescriptor; import Analysis.TaskStateAnalysis.Predicate; +import Analysis.TaskStateAnalysis.SafetyAnalysis; +import Analysis.TaskStateAnalysis.TaskIndex; import Analysis.Locality.LocalityAnalysis; import Analysis.Locality.LocalityBinding; +import Analysis.Prefetch.*; public class BuildCode { State state; @@ -29,21 +34,30 @@ public class BuildCode { public static boolean GENERATEPRECISEGC=false; public static String PREFIX=""; public static String arraytype="ArrayObject"; + public static int flagcount = 0; Virtual virtualcalls; TypeUtil typeutil; - private int maxtaskparams=0; + protected int maxtaskparams=0; private int maxcount=0; ClassDescriptor[] cdarray; TypeDescriptor[] arraytable; LocalityAnalysis locality; Hashtable backuptable; Hashtable reverttable; + SafetyAnalysis sa; + PrefetchAnalysis pa; + + public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, PrefetchAnalysis pa) { + this(st, temptovar, typeutil, null, sa, pa); + } - public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil) { - this(st, temptovar, typeutil, null); + public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, PrefetchAnalysis pa) { + this(st, temptovar, typeutil, locality, null, pa); } - public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality) { + public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality, SafetyAnalysis sa, PrefetchAnalysis pa) { + this.sa=sa; + this.pa=pa; state=st; this.temptovar=temptovar; paramstable=new Hashtable(); @@ -180,6 +194,12 @@ public class BuildCode { private void outputMainMethod(PrintWriter outmethod) { outmethod.println("int main(int argc, const char *argv[]) {"); outmethod.println(" int i;"); + outmethod.println("#ifdef TRANSSTATS \n"); + outmethod.println("handle();\n"); + outmethod.println("#endif\n"); + if (state.THREAD||state.DSM) { + outmethod.println("initializethreads();"); + } if (state.DSM) { outmethod.println("if (dstmStartup(argv[1])) {"); if (GENERATEPRECISEGC) { @@ -194,9 +214,6 @@ public class BuildCode { outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);"); } } - if (state.THREAD) { - outmethod.println("initializethreads();"); - } if (state.DSM) { outmethod.println(" for(i=2;i"); + outmethod.println("#include \"runtime.h\""); if (state.DSM) { + outmethod.println("#include \"addPrefetchEnhance.h\""); outmethod.println("#include \"localobjects.h\""); } - if (state.THREAD) + if(state.MULTICORE) { + outmethod.println("#include \"task.h\""); + } + if (state.THREAD||state.DSM) outmethod.println("#include "); if (state.main!=null) { outmethod.println("#include "); @@ -315,12 +346,12 @@ public class BuildCode { /* Generate code for methods */ if (state.DSM) { for(Iterator lbit=locality.getLocalityBindings().iterator();lbit.hasNext();) { - LocalityBinding lb=lbit.next(); - MethodDescriptor md=lb.getMethod(); - FlatMethod fm=state.getMethodFlat(md); - if (!md.getModifiers().isNative()) { - generateFlatMethod(fm, lb, outmethod); - } + LocalityBinding lb=lbit.next(); + MethodDescriptor md=lb.getMethod(); + FlatMethod fm=state.getMethodFlat(md); + if (!md.getModifiers().isNative()) { + generateFlatMethod(fm, lb, outmethod); + } } } else { Iterator classit=state.getClassSymbolTable().getDescriptorsIterator(); @@ -331,14 +362,15 @@ public class BuildCode { /* Classify parameters */ MethodDescriptor md=(MethodDescriptor)methodit.next(); FlatMethod fm=state.getMethodFlat(md); - if (!md.getModifiers().isNative()) + if (!md.getModifiers().isNative()) { generateFlatMethod(fm, null, outmethod); + } } } } } - private void outputStructs(PrintWriter outstructs) { + protected void outputStructs(PrintWriter outstructs) { outstructs.println("#ifndef STRUCTDEFS_H"); outstructs.println("#define STRUCTDEFS_H"); outstructs.println("#include \"classdefs.h\""); @@ -380,8 +412,8 @@ public class BuildCode { } } - private void outputClassDeclarations(PrintWriter outclassdefs) { - if (state.THREAD) + protected void outputClassDeclarations(PrintWriter outclassdefs) { + if (state.THREAD||state.DSM) outclassdefs.println("#include "); if(state.OPTIONAL) outclassdefs.println("#include \"optionalstruct.h\""); @@ -403,14 +435,16 @@ public class BuildCode { } if (state.TASK) { outclassdefs.println(" int flag;"); - outclassdefs.println(" void * flagptr;"); + if(!state.MULTICORE) { + outclassdefs.println(" void * flagptr;"); + } else { + outclassdefs.println(" int isolate;"); // indicate if this object is shared or not + outclassdefs.println(" int version;"); + outclassdefs.println(" struct ___Object___ * original;"); + } if(state.OPTIONAL){ - outclassdefs.println(" int failedstatus;"); - outclassdefs.println(" int hashcode;"); - outclassdefs.println(" int numexitfses;"); - outclassdefs.println(" int * exitfses;"); - outclassdefs.println(" int numotds;"); - outclassdefs.println(" struct optionaltaskdescriptor ** otds;"); + outclassdefs.println(" int numfses;"); + outclassdefs.println(" int * fses;"); } } printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs); @@ -440,7 +474,7 @@ public class BuildCode { outtask.println("struct taskdescriptor {"); outtask.println("void * taskptr;"); outtask.println("int numParameters;"); - outtask.println("int numTotal;"); + outtask.println(" int numTotal;"); outtask.println("struct parameterdescriptor **descriptorarray;"); outtask.println("char * name;"); outtask.println("};"); @@ -458,7 +492,9 @@ public class BuildCode { outrepairstructs.println(" int __type__;"); if (state.TASK) { outrepairstructs.println(" int __flag__;"); - outrepairstructs.println(" int __flagptr__;"); + if(!state.MULTICORE) { + outrepairstructs.println(" int __flagptr__;"); + } } printRepairStruct(cn, outrepairstructs); outrepairstructs.println("}\n"); @@ -503,7 +539,7 @@ public class BuildCode { } /** This method outputs TaskDescriptor information */ - void generateTaskDescriptor(PrintWriter output, FlatMethod fm, TaskDescriptor task) { + private void generateTaskDescriptor(PrintWriter output, FlatMethod fm, TaskDescriptor task) { for (int i=0;i saveset=lb!=null?locality.getTempSet(lb):null; @@ -749,7 +797,7 @@ public class BuildCode { for(int i=0;i tmpit=backuptable.values().iterator();tmpit.hasNext();) { TempDescriptor tmp=tmpit.next(); TypeDescriptor type=tmp.getType(); - if ((type.isPtr()||type.isArray())&&GENERATEPRECISEGC) + if (type.isPtr()&&GENERATEPRECISEGC) objecttemps.addPtr(tmp); else objecttemps.addPrim(tmp); } /* Create temp to hold revert table */ - if (lb.getHasAtomic()) { + if (lb.getHasAtomic()||lb.isAtomic()) { TempDescriptor reverttmp=new TempDescriptor("revertlist", typeutil.getClass(TypeUtil.ObjectClass)); if (GENERATEPRECISEGC) objecttemps.addPtr(reverttmp); @@ -831,7 +879,7 @@ public class BuildCode { TypeDescriptor type=fd.getType(); if (state.DSM&&fd.isGlobal()) //Don't GC the global objects for now continue; - if (type.isPtr()||type.isArray()) + if (type.isPtr()) count++; } output.print(count); @@ -841,7 +889,7 @@ public class BuildCode { TypeDescriptor type=fd.getType(); if (state.DSM&&fd.isGlobal()) //Don't GC the global objects for now continue; - if (type.isPtr()||type.isArray()) { + if (type.isPtr()) { output.println(","); output.print("((unsigned int)&(((struct "+cn.getSafeSymbol() +" *)0)->"+fd.getSafeSymbol()+"))"); } @@ -914,10 +962,14 @@ public class BuildCode { if (!fieldorder.containsKey(cn)) { Vector fields=new Vector(); fieldorder.put(cn,fields); + if (sp==null&&!state.TASK) { + fields.add(cn.getFieldTable().get("cachedCode")); + } Iterator fieldit=cn.getFields(); while(fieldit.hasNext()) { FieldDescriptor fd=(FieldDescriptor)fieldit.next(); - if (sp==null||!sp.getFieldTable().contains(fd.getSymbol())) + if ((sp==null||!sp.getFieldTable().contains(fd.getSymbol()))&& + (!fd.getSymbol().equals("cachedCode")||state.TASK)) fields.add(fd); } } @@ -936,7 +988,7 @@ public class BuildCode { /* Map flags to integers consistently between inherited * classes. */ - private void mapFlags(ClassDescriptor cn) { + protected void mapFlags(ClassDescriptor cn) { ClassDescriptor sp=cn.getSuperDesc(); if (sp!=null) mapFlags(sp); @@ -970,7 +1022,7 @@ public class BuildCode { * passed in (when PRECISE GC is enabled) and (2) function * prototypes for the methods */ - private void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout) { + protected void generateCallStructs(ClassDescriptor cn, PrintWriter classdefout, PrintWriter output, PrintWriter headersout) { /* Output class structure */ classdefout.println("struct "+cn.getSafeSymbol()+" {"); classdefout.println(" int type;"); @@ -982,14 +1034,16 @@ public class BuildCode { if (state.TASK) { classdefout.println(" int flag;"); - classdefout.println(" void * flagptr;"); + if((!state.MULTICORE) || (cn.getSymbol().equals("TagDescriptor"))) { + classdefout.println(" void * flagptr;"); + } else if (state.MULTICORE){ + classdefout.println(" int isolate;"); // indicate if this object is shared or not + classdefout.println(" int version;"); + classdefout.println(" struct ___Object___ * original;"); + } if (state.OPTIONAL){ - classdefout.println(" int failedstatus;"); - classdefout.println(" int hashcode;"); - classdefout.println(" int numexitfses;"); - classdefout.println(" int * exitfses;"); - classdefout.println(" int numotds;"); - classdefout.println(" struct optionaltaskdescriptor ** otds;"); + classdefout.println(" int numfses;"); + classdefout.println(" int * fses;"); } } printClassStruct(cn, classdefout); @@ -1105,7 +1159,7 @@ public class BuildCode { printcomma=true; } - if (state.DSM&&lb.isAtomic()) { + if (state.DSM&&lb.isAtomic()&&!md.getModifiers().isNative()) { if (printcomma) headersout.print(", "); headersout.print("transrecord_t * trans"); @@ -1194,7 +1248,10 @@ public class BuildCode { /***** Generate code for FlatMethod fm. *****/ private void generateFlatMethod(FlatMethod fm, LocalityBinding lb, PrintWriter output) { + if (State.PRINTFLAT) + System.out.println(fm.printMethod()); MethodDescriptor md=fm.getMethod(); + TaskDescriptor task=fm.getTask(); ClassDescriptor cn=md!=null?md.getClassDesc():null; @@ -1239,8 +1296,11 @@ public class BuildCode { /* Check to see if we need to do a GC if this is a * multi-threaded program...*/ - if (state.THREAD&&GENERATEPRECISEGC) { - output.println("checkcollect(&"+localsprefix+");"); + if ((state.THREAD||state.DSM)&&GENERATEPRECISEGC) { + if (state.DSM&&lb.isAtomic()) + output.println("checkcollect2(&"+localsprefix+",trans);"); + else + output.println("checkcollect(&"+localsprefix+");"); } /* Do the actual code generation */ @@ -1257,7 +1317,7 @@ public class BuildCode { if (nodetolabel.containsKey(current_node)) output.println("L"+nodetolabel.get(current_node)+":"); if (state.INSTRUCTIONFAILURE) { - if (state.THREAD) { + if (state.THREAD||state.DSM) { output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}"); } else @@ -1292,13 +1352,12 @@ public class BuildCode { current_node=current_node.getNext(0); } else throw new Error(); } - output.println("}\n\n"); } /** This method assigns labels to FlatNodes */ - private Hashtable assignLabels(FlatMethod fm) { + protected Hashtable assignLabels(FlatMethod fm) { HashSet tovisit=new HashSet(); HashSet visited=new HashSet(); int labelindex=0; @@ -1331,7 +1390,7 @@ public class BuildCode { /** Generate text string that corresponds to the TempDescriptor td. */ - private String generateTemp(FlatMethod fm, TempDescriptor td, LocalityBinding lb) { + protected String generateTemp(FlatMethod fm, TempDescriptor td, LocalityBinding lb) { MethodDescriptor md=fm.getMethod(); TaskDescriptor task=fm.getTask(); TempObject objecttemps=(TempObject) tempstable.get(lb!=null?lb:md!=null?md:task); @@ -1350,7 +1409,7 @@ public class BuildCode { throw new Error(); } - private void generateFlatNode(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output) { + protected void generateFlatNode(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output) { switch(fn.kind()) { case FKind.FlatAtomicEnterNode: generateFlatAtomicEnterNode(fm, lb, (FlatAtomicEnterNode) fn, output); @@ -1399,7 +1458,10 @@ public class BuildCode { return; case FKind.FlatBackEdge: if ((state.THREAD||state.DSM)&&GENERATEPRECISEGC) { - output.println("checkcollect(&"+localsprefix+");"); + if(state.DSM&&locality.getAtomic(lb).get(fn).intValue()>0) { + output.println("checkcollect2(&"+localsprefix+",trans);"); + } else + output.println("checkcollect(&"+localsprefix+");"); } else output.println("/* nop */"); return; @@ -1409,46 +1471,214 @@ public class BuildCode { case FKind.FlatFlagActionNode: generateFlatFlagActionNode(fm, lb, (FlatFlagActionNode) fn, output); return; + case FKind.FlatPrefetchNode: + generateFlatPrefetchNode(fm,lb, (FlatPrefetchNode) fn, output); + return; } throw new Error(); - } + + public void generateFlatPrefetchNode(FlatMethod fm, LocalityBinding lb, FlatPrefetchNode fpn, PrintWriter output) { + if (state.PREFETCH) { + Vector oids = new Vector(); + Vector fieldoffset = new Vector(); + Vector endoffset = new Vector(); + int tuplecount = 0; //Keeps track of number of prefetch tuples that need to be generated + for(Iterator it = fpn.hspp.iterator();it.hasNext();) { + PrefetchPair pp = (PrefetchPair) it.next(); + Integer statusbase = locality.getNodePreTempInfo(lb,fpn).get(pp.base); + /* Find prefetches that can generate oid */ + if(statusbase == LocalityAnalysis.GLOBAL) { + generateTransCode(fm, lb, pp, oids, fieldoffset, endoffset, tuplecount, locality.getAtomic(lb).get(fpn).intValue()>0, false); + tuplecount++; + } else if (statusbase == LocalityAnalysis.LOCAL) { + generateTransCode(fm,lb,pp,oids,fieldoffset,endoffset,tuplecount,false,true); + } else { + continue; + } + } + if (tuplecount==0) + return; + output.println("{"); + output.println("/* prefetch */"); + output.println("/* prefetchid_" + fpn.siteid + " */"); + output.println("void * prefptr;"); + output.println("int tmpindex;"); + + output.println("if((evalPrefetch["+fpn.siteid+"].operMode) || (evalPrefetch["+fpn.siteid+"].retrycount <= 0)) {"); + /*Create C code for oid array */ + output.print(" unsigned int oidarray_[] = {"); + boolean needcomma=false; + for (Iterator it = oids.iterator();it.hasNext();) { + if (needcomma) + output.print(", "); + output.print(it.next()); + needcomma=true; + } + output.println("};"); + + /*Create C code for endoffset values */ + output.print(" unsigned short endoffsetarry_[] = {"); + needcomma=false; + for (Iterator it = endoffset.iterator();it.hasNext();) { + if (needcomma) + output.print(", "); + output.print(it.next()); + needcomma=true; + } + output.println("};"); + + /*Create C code for Field Offset Values */ + output.print(" short fieldarry_[] = {"); + needcomma=false; + for (Iterator it = fieldoffset.iterator();it.hasNext();) { + if (needcomma) + output.print(", "); + output.print(it.next()); + needcomma=true; + } + output.println("};"); + /* make the prefetch call to Runtime */ + output.println(" if(!evalPrefetch["+fpn.siteid+"].operMode) {"); + output.println(" evalPrefetch["+fpn.siteid+"].retrycount = RETRYINTERVAL;"); + output.println(" }"); + output.println(" prefetch("+fpn.siteid+" ,"+tuplecount+", oidarray_, endoffsetarry_, fieldarry_);"); + output.println(" } else {"); + output.println(" evalPrefetch["+fpn.siteid+"].retrycount--;"); + output.println(" }"); + output.println("}"); + } + } - public void generateFlatGlobalConvNode(FlatMethod fm, LocalityBinding lb, FlatGlobalConvNode fgcn, PrintWriter output) { - if (lb!=fgcn.getLocality()) + public void generateTransCode(FlatMethod fm, LocalityBinding lb,PrefetchPair pp, Vector oids, Vector fieldoffset, Vector endoffset, int tuplecount, boolean inside, boolean localbase) { + short offsetcount = 0; + int breakindex=0; + if (inside) { + breakindex=1; + } else if (localbase) { + for(;breakindexpp.desc.size()) //all local return; - /* Have to generate flat globalconv */ - if (fgcn.getMakePtr()) { - output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=(void *)transRead(trans, (unsigned int) "+generateTemp(fm, fgcn.getSrc(),lb)+");"); + + TypeDescriptor lasttype=pp.base.getType(); + String basestr=generateTemp(fm, pp.base, lb); + String teststr=""; + boolean maybenull=fm.getMethod().isStatic()|| + !pp.base.equals(fm.getParameter(0)); + + for(int i=0;i"+fd.getSafeSymbol(); + } else { + basestr=basestr+"->"+fd.getSafeSymbol(); + maybenull=true; + } + lasttype=fd.getType(); + } else { + IndexDescriptor id=(IndexDescriptor)desc; + indexcheck="((tmpindex="; + for(int j=0;j=0)&&(tmpindex<((struct ArrayObject *)prefptr)->___length___)"; + + if (!teststr.equals("")) + teststr+="&&"; + teststr+="((prefptr="+basestr+")!= NULL) &&"+indexcheck; + basestr="((void **)(((char *) &(((struct ArrayObject *)prefptr)->___length___))+sizeof(int)))[tmpindex]"; + maybenull=true; + lasttype=lasttype.dereference(); + } + } + + String oid; + if (teststr.equals("")) { + oid="((unsigned int)"+basestr+")"; } else { - /* Need to convert to OID */ - output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=(void *)COMPOID("+generateTemp(fm, fgcn.getSrc(),lb)+");"); + oid="((unsigned int)(("+teststr+")?"+basestr+":NULL))"; } + oids.add(oid); + + for(int i = breakindex; i < pp.desc.size(); i++) { + String newfieldoffset; + Object desc = pp.getDescAt(i); + if(desc instanceof FieldDescriptor) { + FieldDescriptor fd=(FieldDescriptor)desc; + newfieldoffset = new String("(unsigned int)(&(((struct "+ lasttype.getSafeSymbol()+" *)0)->"+ fd.getSafeSymbol()+ "))"); + lasttype=fd.getType(); + } else { + newfieldoffset = ""; + IndexDescriptor id=(IndexDescriptor)desc; + for(int j = 0; j < id.tddesc.size(); j++) { + newfieldoffset += generateTemp(fm, id.getTempDescAt(j), lb) + "+"; + } + newfieldoffset += id.offset.toString(); + lasttype=lasttype.dereference(); + } + fieldoffset.add(newfieldoffset); + } + + int base=(tuplecount>0)?((Short)endoffset.get(tuplecount-1)).intValue():0; + base+=pp.desc.size()-breakindex; + endoffset.add(new Short((short)base)); + } + + + + public void generateFlatGlobalConvNode(FlatMethod fm, LocalityBinding lb, FlatGlobalConvNode fgcn, PrintWriter output) { + if (lb!=fgcn.getLocality()) + return; + /* Have to generate flat globalconv */ + if (fgcn.getMakePtr()) { + output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=(void *)transRead(trans, (unsigned int) "+generateTemp(fm, fgcn.getSrc(),lb)+");"); + } else { + /* Need to convert to OID */ + output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=(void *)COMPOID("+generateTemp(fm, fgcn.getSrc(),lb)+");"); + } } public void generateFlatAtomicEnterNode(FlatMethod fm, LocalityBinding lb, FlatAtomicEnterNode faen, PrintWriter output) { - /* Check to see if we need to generate code for this atomic */ - if (locality.getAtomic(lb).get(faen.getPrev(0)).intValue()>0) - return; - /* Backup the temps. */ - for(Iterator tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) { - TempDescriptor tmp=tmpit.next(); - output.println(generateTemp(fm, backuptable.get(tmp),lb)+"="+generateTemp(fm,tmp,lb)+";"); - } - output.println("goto transstart"+faen.getIdentifier()+";"); + /* Check to see if we need to generate code for this atomic */ + if (locality.getAtomic(lb).get(faen.getPrev(0)).intValue()>0) + return; + /* Backup the temps. */ + for(Iterator tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) { + TempDescriptor tmp=tmpit.next(); + output.println(generateTemp(fm, backuptable.get(tmp),lb)+"="+generateTemp(fm,tmp,lb)+";"); + } + output.println("goto transstart"+faen.getIdentifier()+";"); - /******* Print code to retry aborted transaction *******/ - output.println("transretry"+faen.getIdentifier()+":"); + /******* Print code to retry aborted transaction *******/ + output.println("transretry"+faen.getIdentifier()+":"); - /* Restore temps */ - for(Iterator tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) { - TempDescriptor tmp=tmpit.next(); - output.println(generateTemp(fm, tmp,lb)+"="+generateTemp(fm,backuptable.get(tmp),lb)+";"); - } + /* Restore temps */ + for(Iterator tmpit=locality.getTemps(lb).get(faen).iterator();tmpit.hasNext();) { + TempDescriptor tmp=tmpit.next(); + output.println(generateTemp(fm, tmp,lb)+"="+generateTemp(fm,backuptable.get(tmp),lb)+";"); + } + + /********* Need to revert local object store ********/ + String revertptr=generateTemp(fm, reverttable.get(lb),lb); - /********* Need to revert local object store ********/ - String revertptr=generateTemp(fm, reverttable.get(lb),lb); - output.println("while ("+revertptr+") {"); output.println("struct ___Object___ * tmpptr;"); output.println("tmpptr="+revertptr+"->"+nextobjstr+";"); @@ -1521,10 +1751,16 @@ public class BuildCode { output.print(objectparams.numPointers()); output.print(", & "+localsprefix); - if (fc.getThis()!=null) { + if (md.getThis()!=null) { output.print(", "); output.print("(struct "+md.getThis().getType().getSafeSymbol() +" *)"+ generateTemp(fm,fc.getThis(),lb)); } + if (fc.getThis()!=null&&md.getThis()==null) { + System.out.println("WARNING!!!!!!!!!!!!"); + System.out.println("Source code calls static method"+md+"on an object in "+fm.getMethod()+"!"); + } + + for(int i=0;itype*"+maxcount+"+"+virtualcalls.getLocalityNumber(fclb)+"])"); @@ -1599,7 +1843,7 @@ public class BuildCode { needcomma=true; } - if (state.DSM&&locality.getBinding(lb,fc).isAtomic()) { + if (state.DSM&&locality.getBinding(lb,fc).isAtomic()&&!fc.getMethod().getModifiers().isNative()) { if (needcomma) output.print(","); output.print("trans"); @@ -1658,11 +1902,10 @@ public class BuildCode { Integer status=locality.getNodePreTempInfo(lb,ffn).get(ffn.getSrc()); if (status==LocalityAnalysis.GLOBAL) { String field=ffn.getField().getSafeSymbol(); - String src="((struct "+ffn.getSrc().getType().getSafeSymbol()+" *)((unsigned int)"+generateTemp(fm, ffn.getSrc(),lb)+"+sizeof(objheader_t)))"; + String src=generateTemp(fm, ffn.getSrc(),lb); String dst=generateTemp(fm, ffn.getDst(),lb); - if (ffn.getField().getType().isPtr()|| - ffn.getField().getType().isArray()) { + if (ffn.getField().getType().isPtr()) { //TODO: Uncomment this when we have runtime support //if (ffn.getSrc()==ffn.getDst()) { @@ -1689,7 +1932,9 @@ public class BuildCode { } else if (status==LocalityAnalysis.EITHER) { //Code is reading from a null pointer output.println("if ("+generateTemp(fm, ffn.getSrc(),lb)+") {"); - output.println("printf(\"BIG ERROR\n\");exit(-1);}"); + output.println("#ifndef RAW"); + output.println("printf(\"BIG ERROR\\n\");exit(-1);}"); + output.println("#endif"); //This should throw a suitable null pointer error output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";"); } else @@ -1698,6 +1943,7 @@ public class BuildCode { output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";"); } + private void generateFlatSetFieldNode(FlatMethod fm, LocalityBinding lb, FlatSetFieldNode fsfn, PrintWriter output) { if (fsfn.getField().getSymbol().equals("length")&&fsfn.getDst().getType().isArray()) throw new Error("Can't set array length"); @@ -1710,27 +1956,28 @@ public class BuildCode { String dst=generateTemp(fm,fsfn.getDst(),lb); if (srcglobal) { output.println("{"); - output.println("int srcoid="+src+"->"+oidstr+";"); + output.println("int srcoid=(int)"+src+"->"+oidstr+";"); } if (statusdst.equals(LocalityAnalysis.GLOBAL)) { - String glbdst="((struct "+fsfn.getDst().getType().getSafeSymbol()+" *)((unsigned int)"+dst+" +sizeof(objheader_t)))"; + String glbdst=dst; //mark it dirty output.println("*((unsigned int *)&("+dst+"->___localcopy___))|=DIRTY;"); if (srcglobal) { output.println("*((unsigned int *)&("+glbdst+"->"+ fsfn.getField().getSafeSymbol()+"))=srcoid;"); - output.println("}"); } else output.println(glbdst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";"); } else if (statusdst.equals(LocalityAnalysis.LOCAL)) { /** Check if we need to copy */ output.println("if(!"+dst+"->"+localcopystr+") {"); /* Link object into list */ - output.println(dst+"->"+nextobjstr+"=trans->localtrans;"); - output.println("trans->localtrans="+dst+";"); + String revertptr=generateTemp(fm, reverttable.get(lb),lb); + output.println(revertptr+"=trans->revertlist;"); if (GENERATEPRECISEGC) output.println("COPY_OBJ((struct garbagelist *)&"+localsprefix+",(struct ___Object___ *)"+dst+");"); else output.println("COPY_OBJ("+dst+");"); + output.println(dst+"->"+nextobjstr+"="+revertptr+";"); + output.println("trans->revertlist=(struct ___Object___ *)"+dst+";"); output.println("}"); if (srcglobal) output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;"); @@ -1739,7 +1986,9 @@ public class BuildCode { } else if (statusdst.equals(LocalityAnalysis.EITHER)) { //writing to a null...bad output.println("if ("+dst+") {"); - output.println("printf(\"BIG ERROR 2\n\");exit(-1);}"); + output.println("#ifndef RAW"); + output.println("printf(\"BIG ERROR 2\\n\");exit(-1);}"); + output.println("#endif"); if (srcglobal) output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;"); else @@ -1766,8 +2015,32 @@ public class BuildCode { output.println("if ("+generateTemp(fm, fen.getIndex(),lb)+"< 0 || "+generateTemp(fm, fen.getIndex(),lb)+" >= "+generateTemp(fm,fen.getSrc(),lb) + "->___length___)"); output.println("failedboundschk();"); } + if (state.DSM) { + Integer status=locality.getNodePreTempInfo(lb,fen).get(fen.getSrc()); + if (status==LocalityAnalysis.GLOBAL) { + String dst=generateTemp(fm, fen.getDst(),lb); - output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];"); + if (elementtype.isPtr()) { + output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];"); + output.println(dst+"=(void *) transRead(trans, (unsigned int) "+dst+");"); + } else { + output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];"); + } + } else if (status==LocalityAnalysis.LOCAL) { + output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];"); + } else if (status==LocalityAnalysis.EITHER) { + //Code is reading from a null pointer + output.println("if ("+generateTemp(fm, fen.getSrc(),lb)+") {"); + output.println("#ifndef RAW"); + output.println("printf(\"BIG ERROR\\n\");exit(-1);}"); + output.println("#endif"); + //This should throw a suitable null pointer error + output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];"); + } else + throw new Error("Read from non-global/non-local in:"+lb.getExplanation()); + } else { + output.println(generateTemp(fm, fen.getDst(),lb)+"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];"); + } } private void generateFlatSetElementNode(FlatMethod fm, LocalityBinding lb, FlatSetElementNode fsen, PrintWriter output) { @@ -1782,15 +2055,55 @@ public class BuildCode { else type=elementtype.getSafeSymbol()+" "; + if (fsen.needsBoundsCheck()) { output.println("if ("+generateTemp(fm, fsen.getIndex(),lb)+"< 0 || "+generateTemp(fm, fsen.getIndex(),lb)+" >= "+generateTemp(fm,fsen.getDst(),lb) + "->___length___)"); output.println("failedboundschk();"); } - output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";"); + if (state.DSM && locality.getAtomic(lb).get(fsen).intValue()>0) { + Integer statussrc=locality.getNodePreTempInfo(lb,fsen).get(fsen.getSrc()); + Integer statusdst=locality.getNodePreTempInfo(lb,fsen).get(fsen.getDst()); + boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL; + boolean dstglobal=statusdst==LocalityAnalysis.GLOBAL; + boolean dstlocal=statusdst==LocalityAnalysis.LOCAL; + + if (dstglobal) { + output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst(),lb)+"->___localcopy___))|=DIRTY;"); + } else if (dstlocal) { + /** Check if we need to copy */ + String dst=generateTemp(fm, fsen.getDst(),lb); + output.println("if(!"+dst+"->"+localcopystr+") {"); + /* Link object into list */ + String revertptr=generateTemp(fm, reverttable.get(lb),lb); + output.println(revertptr+"=trans->revertlist;"); + if (GENERATEPRECISEGC) + output.println("COPY_OBJ((struct garbagelist *)&"+localsprefix+",(struct ___Object___ *)"+dst+");"); + else + output.println("COPY_OBJ("+dst+");"); + output.println(dst+"->"+nextobjstr+"="+revertptr+";"); + output.println("trans->revertlist=(struct ___Object___ *)"+dst+";"); + output.println("}"); + } else throw new Error("Unknown array type"); + if (srcglobal) { + output.println("{"); + String src=generateTemp(fm, fsen.getSrc(), lb); + output.println("int srcoid=(int)"+src+"->"+oidstr+";"); + output.println("((int*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]=srcoid;"); + output.println("}"); + } else { + output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";"); + } + } else + output.println("(("+type +"*)(((char *) &("+ generateTemp(fm,fsen.getDst(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fsen.getIndex(),lb)+"]="+generateTemp(fm,fsen.getSrc(),lb)+";"); } private void generateFlatNew(FlatMethod fm, LocalityBinding lb, FlatNew fn, PrintWriter output) { + if (state.DSM && locality.getAtomic(lb).get(fn).intValue()>0&&!fn.isGlobal()) { + //Stash pointer in case of GC + String revertptr=generateTemp(fm, reverttable.get(lb),lb); + output.println(revertptr+"=trans->revertlist;"); + } if (fn.getType().isArray()) { int arrayid=state.getArrayNumber(fn.getType())+state.numClasses(); if (fn.isGlobal()) { @@ -1809,6 +2122,10 @@ public class BuildCode { output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new("+fn.getType().getClassDesc().getId()+");"); } } + if (state.DSM && locality.getAtomic(lb).get(fn).intValue()>0&&!fn.isGlobal()) { + String revertptr=generateTemp(fm, reverttable.get(lb),lb); + output.println("trans->revertlist="+revertptr+";"); + } } private void generateFlatTagDeclaration(FlatMethod fm, LocalityBinding lb, FlatTagDeclaration fn, PrintWriter output) { @@ -1820,9 +2137,16 @@ public class BuildCode { } private void generateFlatOpNode(FlatMethod fm, LocalityBinding lb, FlatOpNode fon, PrintWriter output) { - if (fon.getRight()!=null) - output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+fon.getOp().toString()+generateTemp(fm,fon.getRight(),lb)+";"); - else if (fon.getOp().getOp()==Operation.ASSIGN) + if (fon.getRight()!=null) { + if (fon.getOp().getOp()==Operation.URIGHTSHIFT) { + if (fon.getLeft().getType().isLong()) + output.println(generateTemp(fm, fon.getDest(),lb)+" = ((unsigned long long)"+generateTemp(fm, fon.getLeft(),lb)+")>>"+generateTemp(fm,fon.getRight(),lb)+";"); + else + output.println(generateTemp(fm, fon.getDest(),lb)+" = ((unsigned int)"+generateTemp(fm, fon.getLeft(),lb)+")>>"+generateTemp(fm,fon.getRight(),lb)+";"); + + } else + output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+fon.getOp().toString()+generateTemp(fm,fon.getRight(),lb)+";"); + } else if (fon.getOp().getOp()==Operation.ASSIGN) output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";"); else if (fon.getOp().getOp()==Operation.UNARYPLUS) output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+";"); @@ -1830,7 +2154,11 @@ public class BuildCode { output.println(generateTemp(fm, fon.getDest(),lb)+" = -"+generateTemp(fm, fon.getLeft(),lb)+";"); else if (fon.getOp().getOp()==Operation.LOGIC_NOT) output.println(generateTemp(fm, fon.getDest(),lb)+" = !"+generateTemp(fm, fon.getLeft(),lb)+";"); - else + else if (fon.getOp().getOp()==Operation.COMP) + output.println(generateTemp(fm, fon.getDest(),lb)+" = ~"+generateTemp(fm, fon.getLeft(),lb)+";"); + else if (fon.getOp().getOp()==Operation.ISAVAILABLE) { + output.println(generateTemp(fm, fon.getDest(),lb)+" = "+generateTemp(fm, fon.getLeft(),lb)+"->fses==NULL;"); + } else output.println(generateTemp(fm, fon.getDest(),lb)+fon.getOp().toString()+generateTemp(fm, fon.getLeft(),lb)+";"); } @@ -1849,7 +2177,17 @@ public class BuildCode { output.println(generateTemp(fm, fln.getDst(),lb)+"=0;"); else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) { if (GENERATEPRECISEGC) { + if (state.DSM && locality.getAtomic(lb).get(fln).intValue()>0) { + //Stash pointer in case of GC + String revertptr=generateTemp(fm, reverttable.get(lb),lb); + output.println(revertptr+"=trans->revertlist;"); + } output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(&"+localsprefix+", \""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");"); + if (state.DSM && locality.getAtomic(lb).get(fln).intValue()>0) { + //Stash pointer in case of GC + String revertptr=generateTemp(fm, reverttable.get(lb),lb); + output.println("trans->revertlist="+revertptr+";"); + } } else { output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");"); } @@ -1861,18 +2199,24 @@ public class BuildCode { } else if (fln.getType().isChar()) { String st=FlatLiteralNode.escapeString(fln.getValue().toString()); output.println(generateTemp(fm, fln.getDst(),lb)+"='"+st+"';"); + } else if (fln.getType().isLong()) { + output.println(generateTemp(fm, fln.getDst(),lb)+"="+fln.getValue()+"LL;"); } else output.println(generateTemp(fm, fln.getDst(),lb)+"="+fln.getValue()+";"); } - private void generateFlatReturnNode(FlatMethod fm, LocalityBinding lb, FlatReturnNode frn, PrintWriter output) { - if (frn.getReturnTemp()!=null) - output.println("return "+generateTemp(fm, frn.getReturnTemp(), lb)+";"); - else + protected void generateFlatReturnNode(FlatMethod fm, LocalityBinding lb, FlatReturnNode frn, PrintWriter output) { + if (frn.getReturnTemp()!=null) { + if (frn.getReturnTemp().getType().isPtr()) + output.println("return (struct "+fm.getMethod().getReturnType().getSafeSymbol()+"*)"+generateTemp(fm, frn.getReturnTemp(), lb)+";"); + else + output.println("return "+generateTemp(fm, frn.getReturnTemp(), lb)+";"); + } else { output.println("return;"); + } } - private void generateFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) { + protected void generateFlatCondBranch(FlatMethod fm, LocalityBinding lb, FlatCondBranch fcb, String label, PrintWriter output) { output.println("if (!"+generateTemp(fm, fcb.getTest(),lb)+") goto "+label+";"); } @@ -2062,24 +2406,31 @@ public class BuildCode { ormask=((Integer)flagortable.get(temp)).intValue(); if (flagandtable.containsKey(temp)) andmask=((Integer)flagandtable.get(temp)).intValue(); - if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) { - output.println("flagorandinit("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");"); - } else { - output.println("flagorand("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");"); - } + generateFlagOrAnd(ffan, fm, lb, temp, output, ormask, andmask); + generateObjectDistribute(ffan, fm, lb, temp, output); + } + } + + protected void generateFlagOrAnd(FlatFlagActionNode ffan, FlatMethod fm, LocalityBinding lb, TempDescriptor temp, + PrintWriter output, int ormask, int andmask) { + if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) { + output.println("flagorandinit("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");"); + } else { + output.println("flagorand("+generateTemp(fm, temp, lb)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");"); } } - void generateOptionalArrays(PrintWriter output, PrintWriter headers, Hashtable> safeexecution, Hashtable optionaltaskdescriptors) { - + protected void generateObjectDistribute(FlatFlagActionNode ffan, FlatMethod fm, LocalityBinding lb, TempDescriptor temp, PrintWriter output) { + output.println("enqueueObject("+generateTemp(fm, temp, lb)+");"); + } + + void generateOptionalHeader(PrintWriter headers) { + //GENERATE HEADERS headers.println("#include \"task.h\"\n\n"); headers.println("#ifndef _OPTIONAL_STRUCT_"); headers.println("#define _OPTIONAL_STRUCT_"); - - - //STRUCT PREDICATEMEMBER headers.println("struct predicatemember{"); headers.println("int type;"); @@ -2088,28 +2439,30 @@ public class BuildCode { headers.println("int numtags;"); headers.println("int * tags;\n};\n\n"); - /*//STRUCT EXITSTATES - headers.println("struct exitstates{"); - headers.println("int numflagstates;"); - headers.println("int * flagstatearray;\n};\n\n");*///appeared to be useless - //STRUCT OPTIONALTASKDESCRIPTOR headers.println("struct optionaltaskdescriptor{"); headers.println("struct taskdescriptor * task;"); + headers.println("int index;"); headers.println("int numenterflags;"); headers.println("int * enterflags;"); headers.println("int numpredicatemembers;"); headers.println("struct predicatemember ** predicatememberarray;"); - //headers.println("int numexitstates;"); - //headers.println("int numTotal;"); - //headers.println("struct exitstates ** exitstatesarray;\n};\n\n"); - headers.println("\n};\n\n"); - + headers.println("};\n\n"); + + //STRUCT TASKFAILURE + headers.println("struct taskfailure {"); + headers.println("struct taskdescriptor * task;"); + headers.println("int index;"); + headers.println("int numoptionaltaskdescriptors;"); + headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n"); + //STRUCT FSANALYSISWRAPPER headers.println("struct fsanalysiswrapper{"); headers.println("int flags;"); headers.println("int numtags;"); headers.println("int * tags;"); + headers.println("int numtaskfailures;"); + headers.println("struct taskfailure ** taskfailurearray;"); headers.println("int numoptionaltaskdescriptors;"); headers.println("struct optionaltaskdescriptor ** optionaltaskdescriptorarray;\n};\n\n"); @@ -2129,12 +2482,105 @@ public class BuildCode { headers.println("extern struct taskdescriptor task_"+td.getSafeSymbol()+";"); } - + } + + //CHECK OVER THIS -- THERE COULD BE SOME ERRORS HERE + int generateOptionalPredicate(Predicate predicate, OptionalTaskDescriptor otd, ClassDescriptor cdtemp, PrintWriter output) { + int predicateindex = 0; + //iterate through the classes concerned by the predicate + Set c_vard = predicate.vardescriptors; + Hashtable slotnumber=new Hashtable(); + int current_slot=0; + + for(Iterator vard_it = c_vard.iterator(); vard_it.hasNext();){ + VarDescriptor vard = (VarDescriptor)vard_it.next(); + TypeDescriptor typed = vard.getType(); + + //generate for flags + HashSet fen_hashset = predicate.flags.get(vard.getSymbol()); + output.println("int predicateflags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={"); + int numberterms=0; + if (fen_hashset!=null){ + for (Iterator fen_it = fen_hashset.iterator(); fen_it.hasNext();){ + FlagExpressionNode fen = (FlagExpressionNode)fen_it.next(); + if (fen!=null) { + DNFFlag dflag=fen.getDNF(); + numberterms+=dflag.size(); + + Hashtable flags=(Hashtable)flagorder.get(typed.getClassDesc()); + + for(int j=0;j>> safeexecution, Hashtable optionaltaskdescriptors) { + generateOptionalHeader(headers); //GENERATE STRUCTS - if (state.OPTIONAL) - output.println("#include \"optionalstruct.h\"\n\n"); + output.println("#include \"optionalstruct.h\"\n\n"); + output.println("#include \"stdlib.h\"\n"); + HashSet processedcd = new HashSet(); - int maxotd=0; Enumeration e = safeexecution.keys(); while (e.hasMoreElements()) { @@ -2143,17 +2589,7 @@ public class BuildCode { ClassDescriptor cdtemp=(ClassDescriptor)e.nextElement(); Hashtable flaginfo=(Hashtable)flagorder.get(cdtemp);//will be used several times - //////////////////////////DEBUG - System.out.println(cdtemp.getSymbol()+" "+cdtemp.getId()); - for(Iterator flags = cdtemp.getFlags(); flags.hasNext();){ - FlagDescriptor flagd = (FlagDescriptor)flags.next(); - int flagid=1<<((Integer)flaginfo.get(flagd)).intValue(); - System.out.println(" Flag "+flagd.getSymbol()+" 0x"+Integer.toHexString(flagid)+" int "+flagid); - } - /////////////////////////// - //Generate the struct of optionals - if((Hashtable)optionaltaskdescriptors.get(cdtemp)==null) System.out.println("Was in cd :"+cdtemp.getSymbol()); Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values(); numotd = c_otd.size(); if(maxotd exitfses = otd.exitfses; - int exitindex = 0; - int nbexit = exitfses.size(); - int fsnumber; - - //iterate through possible exits - int nbtotal=0; - for(Iterator exitfseshash = exitfses.iterator(); exitfseshash.hasNext();){ - HashSet temp_hashset = (HashSet)exitfseshash.next(); - fsnumber = 0 ; - output.println("int flag_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={"); - //iterate through possible FSes corresponding to the exit - for(Iterator exfses = temp_hashset.iterator(); exfses.hasNext();){ - FlagState fs = (FlagState)exfses.next(); - fsnumber++; - nbtotal++; - int flagid=0; - for(Iterator flags = fs.getFlags(); flags.hasNext();){ - FlagDescriptor flagd = (FlagDescriptor)flags.next(); - int id=1<<((Integer)flaginfo.get(flagd)).intValue(); - flagid+=id; - } - if(fsnumber!=1) output.print(","); - output.print(flagid); - //do the same for tags. - //maybe not needed because no tag changes tolerated. - } - output.println("};\n"); - - - //store that information in a struct - output.println("struct exitstates exitstates"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={"); - output.println(fsnumber+","); - output.println("flag_EXIT"+exitindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()); - output.println("};\n"); - - exitindex++; - } + int predicateindex = generateOptionalPredicate(predicate, otd, cdtemp, output); + TreeSet fsset=new TreeSet(); + //iterate through possible FSes corresponding to + //the state when entering - //store the information concerning all exits into an array - output.println("struct exitstates * exitstatesarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={"); - for( int j = 0; j it=fsset.iterator();it.hasNext();) { + if(needcomma) + output.print(", "); + output.println(it.next()); } + output.println("};\n"); - //generate optionaltaskdescriptor that actually includes exit fses, predicate and the task concerned + //generate optionaltaskdescriptor that actually + //includes exit fses, predicate and the task + //concerned output.println("struct optionaltaskdescriptor optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"={"); output.println("&task_"+otd.td.getSafeSymbol()+","); - output.println("/*number of enter flags*/"+fsnumber+","); + output.println("/*index*/"+otd.getIndex()+","); + output.println("/*number of enter flags*/"+fsset.size()+","); output.println("enterflag_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+","); output.println("/*number of members */"+predicateindex+","); output.println("predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+","); - //output.println("/*number of exitstates */"+nbexit+","); - //output.println("/*total number of fses*/"+nbtotal+","); - //output.println("exitstatesarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()); output.println("};\n"); } - } - else continue; // if there is no optionals, there is no need to build the rest of the struct + } else + continue; + // if there are no optionals, there is no need to build the rest of the struct output.println("struct optionaltaskdescriptor * otdarray"+cdtemp.getSafeSymbol()+"[]={"); c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values(); - int x=0; if( !c_otd.isEmpty() ){ + boolean needcomma=false; for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();){ OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next(); - if(x!=0) output.println(","); - x++; + if(needcomma) + output.println(","); + needcomma=true; output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()); } } output.println("};\n"); - //get all the possible falgstates reachable by an object + //get all the possible flagstates reachable by an object Hashtable hashtbtemp = safeexecution.get(cdtemp); - Enumeration fses = hashtbtemp.keys(); int fscounter = 0; - while(fses.hasMoreElements()){ - FlagState fs = (FlagState)fses.nextElement(); + TreeSet fsts=new TreeSet(new FlagComparator(flaginfo)); + fsts.addAll(hashtbtemp.keySet()); + for(Iterator fsit=fsts.iterator();fsit.hasNext();) { + FlagState fs = (FlagState)fsit.next(); fscounter++; //get the set of OptionalTaskDescriptors corresponding - HashSet availabletasks = (HashSet)hashtbtemp.get(fs); - //iterate through the OptionalTaskDescriptors and store the pointers to the optionals struct (see on top) into an array + HashSet availabletasks = (HashSet)hashtbtemp.get(fs); + //iterate through the OptionalTaskDescriptors and + //store the pointers to the optionals struct (see on + //top) into an array output.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {"); - for(Iterator mos = availabletasks.iterator(); mos.hasNext();){ - OptionalTaskDescriptor mm = (OptionalTaskDescriptor)mos.next(); - if(!mos.hasNext()) output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()); - - else output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+","); + for(Iterator mos = ordertd(availabletasks).iterator(); mos.hasNext();){ + OptionalTaskDescriptor mm = mos.next(); + if(!mos.hasNext()) + output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()); + else + output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol()+","); } output.println("};\n"); @@ -2367,10 +2690,9 @@ public class BuildCode { for(Iterator flags = fs.getFlags(); flags.hasNext();){ FlagDescriptor flagd = (FlagDescriptor)flags.next(); int id=1<<((Integer)flaginfo.get(flagd)).intValue(); - flagid+=id; + flagid|=id; } - //process tag information int tagcounter = 0; @@ -2388,13 +2710,58 @@ public class BuildCode { } output.println("};"); - + Set tiset=sa.getTaskIndex(fs); + for(Iterator itti=tiset.iterator();itti.hasNext();) { + TaskIndex ti=itti.next(); + if (ti.isRuntime()) + continue; + + Set otdset=sa.getOptions(fs, ti); + + output.print("struct optionaltaskdescriptor * optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array[] = {"); + boolean needcomma=false; + for(Iterator otdit=ordertd(otdset).iterator();otdit.hasNext();) { + OptionalTaskDescriptor otd=otdit.next(); + if(needcomma) + output.print(", "); + needcomma=true; + output.println("&optionaltaskdescriptor_"+otd.getuid()+"_"+cdtemp.getSafeSymbol()); + } + output.println("};"); + + output.print("struct taskfailure taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+" = {"); + output.print("&task_"+ti.getTask().getSafeSymbol()+", "); + output.print(ti.getIndex()+", "); + output.print(otdset.size()+", "); + output.print("optionaltaskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()+"_array"); + output.println("};"); + } + + tiset=sa.getTaskIndex(fs); + boolean needcomma=false; + int runtimeti=0; + output.println("struct taskfailure * taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={"); + for(Iterator itti=tiset.iterator();itti.hasNext();) { + TaskIndex ti=itti.next(); + if (ti.isRuntime()) { + runtimeti++; + continue; + } + if (needcomma) + output.print(", "); + needcomma=true; + output.print("&taskfailure_FS"+fscounter+"_"+ti.getTask().getSafeSymbol()+"_"+ti.getIndex()); + } + output.println("};\n"); + //Store the result in fsanalysiswrapper output.println("struct fsanalysiswrapper fsanalysiswrapper_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"={"); output.println("/*flag*/"+flagid+","); output.println("/* number of tags*/"+tagcounter+","); output.println("tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+","); + output.println("/* numtask failures */"+(tiset.size()-runtimeti)+","); + output.println("taskfailurearray"+fscounter+"_"+cdtemp.getSafeSymbol()+","); output.println("/* number of optionaltaskdescriptors */"+availabletasks.size()+","); output.println("optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()); output.println("};\n"); @@ -2403,12 +2770,14 @@ public class BuildCode { //Build the array of fsanalysiswrappers output.println("struct fsanalysiswrapper * fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"[] = {"); + boolean needcomma=false; for(int i = 0; i0) + output.print(", "); + if (processedcd.contains(cn)) + output.print("&classanalysiswrapper_"+cn.getSafeSymbol()); + else + output.print("NULL"); } output.println("};"); - output.println("int numclasses="+processedcd.size()+";"); - headers.println("extern numclasses;"); - output.println("int maxotd="+maxotd+";"); - headers.println("extern maxotd;"); + output.println("#define MAXOTD "+maxotd); headers.println("#endif"); - - } + + public List ordertd(Set otdset) { + Relation r=new Relation(); + for(Iteratorotdit=otdset.iterator();otdit.hasNext();) { + OptionalTaskDescriptor otd=otdit.next(); + TaskIndex ti=new TaskIndex(otd.td, otd.getIndex()); + r.put(ti, otd); + } + + LinkedList l=new LinkedList(); + for(Iterator it=r.keySet().iterator();it.hasNext();) { + Set s=r.get(it.next()); + for(Iterator it2=s.iterator();it2.hasNext();) { + OptionalTaskDescriptor otd=(OptionalTaskDescriptor)it2.next(); + l.add(otd); + } + } + + return l; + } + protected void outputTransCode(PrintWriter output) { + } }