import IR.Tree.DNFFlag;
import IR.Tree.DNFFlagAtom;
import IR.Tree.TagExpressionList;
+import IR.Tree.OffsetNode;
import IR.*;
import java.util.*;
import java.io.*;
import Analysis.Locality.LocalityBinding;
import Analysis.Prefetch.*;
+
public class BuildCode {
State state;
Hashtable temptovar;
Hashtable flagorder;
int tag=0;
String localsprefix="___locals___";
+ String fcrevert="___fcrevert___";
String paramsprefix="___params___";
String oidstr="___nextobject___";
String nextobjstr="___nextobject___";
if (state.TASK) {
outtask=new PrintWriter(new FileOutputStream(PREFIX+"task.h"), true);
outtaskdefs=new PrintWriter(new FileOutputStream(PREFIX+"taskdefs.c"), true);
- if (state.OPTIONAL){
+ if (state.OPTIONAL) {
outoptionalarrays=new PrintWriter(new FileOutputStream(PREFIX+"optionalarrays.c"), true);
optionalheaders=new PrintWriter(new FileOutputStream(PREFIX+"optionalstruct.h"), true);
}
}
/* Generate information for task with optional parameters */
- if (state.TASK&&state.OPTIONAL){
+ if (state.TASK&&state.OPTIONAL) {
generateOptionalArrays(outoptionalarrays, optionalheaders, state.getAnalysisResult(), state.getOptionalTaskDescriptors());
outoptionalarrays.close();
}
outmethod.println("printf(\"nmhashSearch= %d\\n\", nmhashSearch);");
outmethod.println("printf(\"nprehashSearch= %d\\n\", nprehashSearch);");
outmethod.println("printf(\"nRemoteReadSend= %d\\n\", nRemoteSend);");
+ outmethod.println("printf(\"nSoftAbort= %d\\n\", nSoftAbort);");
+ outmethod.println("printf(\"bytesSent= %d\\n\", bytesSent);");
+ outmethod.println("printf(\"bytesRecv= %d\\n\", bytesRecv);");
outmethod.println("#endif\n");
outmethod.println("}");
outmethod.println("#include \"addPrefetchEnhance.h\"");
outmethod.println("#include \"localobjects.h\"");
}
+ if (state.FASTCHECK) {
+ outmethod.println("#include \"localobjects.h\"");
+ }
if(state.MULTICORE) {
outmethod.println("#include \"task.h\"");
}
outclassdefs.println(" int isolate;"); // indicate if this object is shared or not
outclassdefs.println(" int version;");
outclassdefs.println(" struct ___Object___ * original;");
+ //outclassdefs.println(" int numlocks;"); // array for locks
+ outclassdefs.println(" int * lock;");
}
- if(state.OPTIONAL){
+ if(state.OPTIONAL) {
outclassdefs.println(" int numfses;");
outclassdefs.println(" int * fses;");
}
outclassdefs.print("extern int nmhashSearch;\n");
outclassdefs.print("extern int nprehashSearch;\n");
outclassdefs.print("extern int nRemoteSend;\n");
+ outclassdefs.print("extern int nSoftAbort;\n");
+ outclassdefs.print("extern int bytesSent;\n");
+ outclassdefs.print("extern int bytesRecv;\n");
outclassdefs.print("extern void handle();\n");
outclassdefs.print("#endif\n");
outclassdefs.print("int numprefetchsites = " + pa.prefetchsiteid + ";\n");
classdefout.println(" int flag;");
if((!state.MULTICORE) || (cn.getSymbol().equals("TagDescriptor"))) {
classdefout.println(" void * flagptr;");
- } else if (state.MULTICORE){
+ } 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;");
+ //classdefout.println(" int numlocks;"); // array for locks
+ classdefout.println(" int * lock;");
}
- if (state.OPTIONAL){
+ if (state.OPTIONAL) {
classdefout.println(" int numfses;");
classdefout.println(" int * fses;");
}
if ((state.THREAD||state.DSM)&&GENERATEPRECISEGC) {
if (state.DSM&&lb.isAtomic())
- output.println("checkcollect2(&"+localsprefix+",trans);");
+ output.println("if (needtocollect) checkcollect2(&"+localsprefix+",trans);");
else
- output.println("checkcollect(&"+localsprefix+");");
+ output.println("if (needtocollect) checkcollect(&"+localsprefix+");");
}
/* Do the actual code generation */
TempObject objecttemps=(TempObject) tempstable.get(lb!=null ? lb : md!=null ? md : task);
if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
+ //System.out.println("generateTemp returns " + td.getSafeSymbol());
return td.getSafeSymbol();
}
generateFlatAtomicExitNode(fm, lb, (FlatAtomicExitNode) fn, output);
return;
+ case FKind.FlatSESEEnterNode:
+ generateFlatSESEEnterNode(fm, lb, (FlatSESEEnterNode) fn, output);
+ return;
+
+ case FKind.FlatSESEExitNode:
+ generateFlatSESEExitNode(fm, lb, (FlatSESEExitNode) fn, output);
+ return;
+
case FKind.FlatGlobalConvNode:
generateFlatGlobalConvNode(fm, lb, (FlatGlobalConvNode) fn, output);
return;
case FKind.FlatBackEdge:
if ((state.THREAD||state.DSM)&&GENERATEPRECISEGC) {
if(state.DSM&&locality.getAtomic(lb).get(fn).intValue()>0) {
- output.println("checkcollect2(&"+localsprefix+",trans);");
+ output.println("if (needtocollect) checkcollect2(&"+localsprefix+",trans);");
} else
- output.println("checkcollect(&"+localsprefix+");");
+ output.println("if (needtocollect) checkcollect(&"+localsprefix+");");
} else
output.println("/* nop */");
return;
case FKind.FlatPrefetchNode:
generateFlatPrefetchNode(fm,lb, (FlatPrefetchNode) fn, output);
return;
+
+ case FKind.FlatOffsetNode:
+ generateFlatOffsetNode(fm, lb, (FlatOffsetNode)fn, output);
+ return;
}
throw new Error();
}
+ public void generateFlatOffsetNode(FlatMethod fm, LocalityBinding lb, FlatOffsetNode fofn, PrintWriter output) {
+ output.println("/* FlatOffsetNode */");
+ ClassDescriptor cn = fofn.getClassDesc();
+ FieldDescriptor fd = fofn.getField();
+ System.out.println("ClassDescriptor cn =" + cn.toString() + " FieldDescriptor fd =" + fd.toString());
+ System.out.println("TempDescriptor td =" + fofn.getDst().toString() + "Type of TempDescriptor =" + fofn.getDst().getType());
+ output.println("((struct "+cn.getSafeSymbol() +" *)0)->"+ fd.getSafeSymbol()+";");
+ }
+
public void generateFlatPrefetchNode(FlatMethod fm, LocalityBinding lb, FlatPrefetchNode fpn, PrintWriter output) {
if (state.PREFETCH) {
Vector oids = new Vector();
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)+");");
+ if (fgcn.doConvert()) {
+ output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=(void *)COMPOID("+generateTemp(fm, fgcn.getSrc(),lb)+");");
+ } else {
+ output.println(generateTemp(fm, fgcn.getSrc(),lb)+"=NULL;");
+ }
}
}
output.println("}");
}
+ public void generateFlatSESEEnterNode(FlatMethod fm, LocalityBinding lb, FlatSESEEnterNode faen, PrintWriter output) {
+
+ }
+
+ public void generateFlatSESEExitNode(FlatMethod fm, LocalityBinding lb, FlatSESEExitNode faen, PrintWriter output) {
+
+ }
+
private void generateFlatCheckNode(FlatMethod fm, LocalityBinding lb, FlatCheckNode fcn, PrintWriter output) {
if (state.CONSCHECK) {
String specname=fcn.getSpec();
String dst=generateTemp(fm,fsfn.getDst(),lb);
if (srcglobal) {
output.println("{");
- output.println("int srcoid=(int)"+src+"->"+oidstr+";");
+ output.println("int srcoid=("+src+"!=NULL?((int)"+src+"->"+oidstr+"):0);");
}
if (statusdst.equals(LocalityAnalysis.GLOBAL)) {
String glbdst=dst;
output.println("}");
}
} else {
+ if (state.FASTCHECK) {
+ String dst=generateTemp(fm, fsfn.getDst(),lb);
+ output.println("if(!"+dst+"->"+localcopystr+") {");
+ /* Link object into list */
+ if (GENERATEPRECISEGC)
+ output.println("COPY_OBJ((struct garbagelist *)&"+localsprefix+",(struct ___Object___ *)"+dst+");");
+ else
+ output.println("COPY_OBJ("+dst+");");
+ output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
+ output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
+ output.println("}");
+ }
output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
}
}
else
type=elementtype.getSafeSymbol()+" ";
- if (fen.needsBoundsCheck()) {
+ if (this.state.ARRAYBOUNDARYCHECK && fen.needsBoundsCheck()) {
output.println("if ("+generateTemp(fm, fen.getIndex(),lb)+"< 0 || "+generateTemp(fm, fen.getIndex(),lb)+" >= "+generateTemp(fm,fen.getSrc(),lb) + "->___length___)");
output.println("failedboundschk();");
}
else
type=elementtype.getSafeSymbol()+" ";
-
- if (fsen.needsBoundsCheck()) {
+ if (this.state.ARRAYBOUNDARYCHECK && 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();");
}
if (srcglobal) {
output.println("{");
String src=generateTemp(fm, fsen.getSrc(), lb);
- output.println("int srcoid=(int)"+src+"->"+oidstr+";");
+ output.println("int srcoid=("+src+"!=NULL?((int)"+src+"->"+oidstr+"):0);");
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
+ } else {
+ if (state.FASTCHECK) {
+ String dst=generateTemp(fm, fsen.getDst(),lb);
+ output.println("if(!"+dst+"->"+localcopystr+") {");
+ /* Link object into list */
+ if (GENERATEPRECISEGC)
+ output.println("COPY_OBJ((struct garbagelist *)&"+localsprefix+",(struct ___Object___ *)"+dst+");");
+ else
+ output.println("COPY_OBJ("+dst+");");
+ output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
+ output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
+ output.println("}");
+ }
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) {
+ protected 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);
}
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+";");
+ String dst=generateTemp(fm,fn.getDst(),lb);
+ output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
+ output.println(dst+"->"+nextobjstr+"="+revertptr+";");
+ output.println("trans->revertlist=(struct ___Object___ *)"+dst+";");
+ }
+ if (state.FASTCHECK) {
+ String dst=generateTemp(fm,fn.getDst(),lb);
+ output.println(dst+"->___localcopy___=(struct ___Object___*)1;");
+ output.println(dst+"->"+nextobjstr+"="+fcrevert+";");
+ output.println(fcrevert+"=(struct ___Object___ *)"+dst+";");
}
}
}
private void generateFlatLiteralNode(FlatMethod fm, LocalityBinding lb, FlatLiteralNode fln, PrintWriter output) {
+ if (fln.getType().isOffset()) {
+ if (fln.getValue() instanceof OffsetNode) {
+ OffsetNode ofn = (OffsetNode) fln.getValue();
+ output.println(generateTemp(fm, fln.getDst(),lb)+
+ " = (short) (&((struct "+ofn.getClassDesc().getSafeSymbol() +" *)0)->"+
+ ofn.getField().getSafeSymbol()+");");
+ }
+ output.println("/* offset */");
+ return;
+ }
if (fln.getValue()==null)
output.println(generateTemp(fm, fln.getDst(),lb)+"=0;");
else if (fln.getType().getSymbol().equals(TypeUtil.StringClass)) {
Hashtable<TempDescriptor, Integer> slotnumber=new Hashtable<TempDescriptor, Integer>();
int current_slot=0;
- for(Iterator vard_it = c_vard.iterator(); vard_it.hasNext();){
+ for(Iterator vard_it = c_vard.iterator(); vard_it.hasNext();) {
VarDescriptor vard = (VarDescriptor)vard_it.next();
TypeDescriptor typed = vard.getType();
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();){
+ 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();
TagExpressionList tagel = predicate.tags.get(vard.getSymbol());
output.println("int predicatetags_"+predicateindex+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
int numtags = 0;
- if (tagel!=null){
+ if (tagel!=null) {
for(int j=0; j<tagel.numTags(); j++) {
if (j!=0)
output.println(",");
//generate an array that stores the entire predicate
output.println("struct predicatemember * predicatememberarray_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+"[]={");
- for( int j = 0; j<predicateindex; j++){
+ for( int j = 0; j<predicateindex; j++) {
if( j != predicateindex-1) output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol()+",");
else output.println("&predicatemember_"+j+"_OTD"+otd.getuid()+"_"+cdtemp.getSafeSymbol());
}
Collection c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
numotd = c_otd.size();
if(maxotd<numotd) maxotd = numotd;
- if( !c_otd.isEmpty() ){
- for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();){
+ if( !c_otd.isEmpty() ) {
+ for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();) {
OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
//generate the int arrays for the predicate
//iterate through possible FSes corresponding to
//the state when entering
- for(Iterator fses = otd.enterflagstates.iterator(); fses.hasNext();){
+ for(Iterator fses = otd.enterflagstates.iterator(); fses.hasNext();) {
FlagState fs = (FlagState)fses.next();
int flagid=0;
- for(Iterator flags = fs.getFlags(); flags.hasNext();){
+ for(Iterator flags = fs.getFlags(); flags.hasNext();) {
FlagDescriptor flagd = (FlagDescriptor)flags.next();
int id=1<<((Integer)flaginfo.get(flagd)).intValue();
flagid|=id;
output.println("struct optionaltaskdescriptor * otdarray"+cdtemp.getSafeSymbol()+"[]={");
c_otd = ((Hashtable)optionaltaskdescriptors.get(cdtemp)).values();
- if( !c_otd.isEmpty() ){
+ if( !c_otd.isEmpty() ) {
boolean needcomma=false;
- for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();){
+ for(Iterator otd_it = c_otd.iterator(); otd_it.hasNext();) {
OptionalTaskDescriptor otd = (OptionalTaskDescriptor)otd_it.next();
if(needcomma)
output.println(",");
//top) into an array
output.println("struct optionaltaskdescriptor * optionaltaskdescriptorarray_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[] = {");
- for(Iterator<OptionalTaskDescriptor> mos = ordertd(availabletasks).iterator(); mos.hasNext();){
+ for(Iterator<OptionalTaskDescriptor> mos = ordertd(availabletasks).iterator(); mos.hasNext();) {
OptionalTaskDescriptor mm = mos.next();
if(!mos.hasNext())
output.println("&optionaltaskdescriptor_"+mm.getuid()+"_"+cdtemp.getSafeSymbol());
//process flag information (what the flag after failure is) so we know what optionaltaskdescriptors to choose.
int flagid=0;
- for(Iterator flags = fs.getFlags(); flags.hasNext();){
+ for(Iterator flags = fs.getFlags(); flags.hasNext();) {
FlagDescriptor flagd = (FlagDescriptor)flags.next();
int id=1<<((Integer)flaginfo.get(flagd)).intValue();
flagid|=id;
boolean first = true;
Enumeration tag_enum = fs.getTags();
output.println("int tags_FS"+fscounter+"_"+cdtemp.getSafeSymbol()+"[]={");
- while(tag_enum.hasMoreElements()){
+ while(tag_enum.hasMoreElements()) {
tagcounter++;
TagDescriptor tagd = (TagDescriptor)tag_enum.nextElement();
if(first==true)
//Build the array of fsanalysiswrappers
output.println("struct fsanalysiswrapper * fsanalysiswrapperarray_"+cdtemp.getSafeSymbol()+"[] = {");
boolean needcomma=false;
- for(int i = 0; i<fscounter; i++){
+ for(int i = 0; i<fscounter; i++) {
if (needcomma) output.print(",");
output.println("&fsanalysiswrapper_FS"+(i+1)+"_"+cdtemp.getSafeSymbol());
needcomma=true;
projects / IRC.git / blobdiff