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.LocalityAnalysis;
import Analysis.Locality.LocalityBinding;
import Analysis.Prefetch.*;
+import Analysis.Loops.WriteBarrier;
public class BuildCode {
State state;
Hashtable flagorder;
int tag=0;
String localsprefix="___locals___";
+ String fcrevert="___fcrevert___";
String paramsprefix="___params___";
String oidstr="___nextobject___";
String nextobjstr="___nextobject___";
ClassDescriptor[] cdarray;
TypeDescriptor[] arraytable;
LocalityAnalysis locality;
- Hashtable<TempDescriptor, TempDescriptor> backuptable;
Hashtable<LocalityBinding, TempDescriptor> reverttable;
+ Hashtable<LocalityBinding, Hashtable<TempDescriptor, TempDescriptor>> backuptable;
SafetyAnalysis sa;
PrefetchAnalysis pa;
+ WriteBarrier wb;
public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, SafetyAnalysis sa, PrefetchAnalysis pa) {
this(st, temptovar, typeutil, null, sa, pa);
this.sa=sa;
this.pa=pa;
state=st;
+ if (state.SINGLETM)
+ oidstr="___objlocation___";
this.temptovar=temptovar;
paramstable=new Hashtable();
tempstable=new Hashtable();
virtualcalls=new Virtual(state,locality);
if (locality!=null) {
this.locality=locality;
- this.backuptable=new Hashtable<TempDescriptor, TempDescriptor>();
this.reverttable=new Hashtable<LocalityBinding, TempDescriptor>();
+ this.backuptable=new Hashtable<LocalityBinding, Hashtable<TempDescriptor, TempDescriptor>>();
+ this.wb=new WriteBarrier(locality, st);
}
}
outmethodheader.println("#include \"structdefs.h\"");
if (state.DSM)
outmethodheader.println("#include \"dstm.h\"");
+ if (state.SINGLETM)
+ outmethodheader.println("#include \"tm.h\"");
+ if (state.ABORTREADERS) {
+ outmethodheader.println("#include \"abortreaders.h\"");
+ outmethodheader.println("#include <setjmp.h>");
+ }
/* Output Structures */
outputStructs(outstructs);
outstructs.close();
}
+
/* 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. */
outmethod.println("#ifdef TRANSSTATS \n");
outmethod.println("handle();\n");
outmethod.println("#endif\n");
- if (state.THREAD||state.DSM) {
+ if (state.THREAD||state.DSM||state.SINGLETM) {
outmethod.println("initializethreads();");
}
if (state.DSM) {
outmethod.println(" {");
if (GENERATEPRECISEGC) {
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
outmethod.print(" struct "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
} else
outmethod.print(" struct "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
outmethod.println("1, NULL,"+"stringarray};");
- if (state.DSM)
+ if (state.DSM||state.SINGLETM)
outmethod.println(" "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
else
outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(& __parameterlist__);");
} else {
- if (state.DSM)
+ if (state.DSM||state.SINGLETM)
outmethod.println(" "+cd.getSafeSymbol()+locality.getMain().getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
else
outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);");
outmethod.println("}");
}
- if (state.THREAD||state.DSM) {
+ if (state.THREAD||state.DSM||state.SINGLETM) {
outmethod.println("pthread_mutex_lock(&gclistlock);");
outmethod.println("threadcount--;");
outmethod.println("pthread_cond_signal(&gccond);");
outmethod.println("pthread_mutex_unlock(&gclistlock);");
- if (state.THREAD)
+ if (state.THREAD||state.SINGLETM)
outmethod.println("pthread_exit(NULL);");
}
- outmethod.println("#ifdef TRANSSTATS \n");
- outmethod.println("printf(\"****** Transaction Stats ******\\n\");");
- outmethod.println("printf(\"numTransAbort= %d\\n\", numTransAbort);");
- outmethod.println("printf(\"numTransCommit= %d\\n\", numTransCommit);");
- outmethod.println("printf(\"nchashSearch= %d\\n\", nchashSearch);");
- outmethod.println("printf(\"nmhashSearch= %d\\n\", nmhashSearch);");
- outmethod.println("printf(\"nprehashSearch= %d\\n\", nprehashSearch);");
- outmethod.println("printf(\"nRemoteReadSend= %d\\n\", nRemoteSend);");
- outmethod.println("#endif\n");
+ if (state.DSM||state.SINGLETM) {
+ outmethod.println("#ifdef TRANSSTATS \n");
+ outmethod.println("printf(\"****** Transaction Stats ******\\n\");");
+ outmethod.println("printf(\"numTransAbort= %d\\n\", numTransAbort);");
+ outmethod.println("printf(\"numTransCommit= %d\\n\", numTransCommit);");
+ outmethod.println("printf(\"nchashSearch= %d\\n\", nchashSearch);");
+ 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\"");
}
- if (state.THREAD||state.DSM)
+ if (state.THREAD||state.DSM||state.SINGLETM)
outmethod.println("#include <thread.h>");
if (state.main!=null) {
outmethod.println("#include <string.h>");
if (state.CONSCHECK) {
outmethod.println("#include \"checkers.h\"");
}
+ if (state.MLP) {
+ outmethod.println("#include \"mlp_runtime.h\"");
+ }
+
//Store the sizes of classes & array elements
generateSizeArray(outmethod);
generateLayoutStructs(outmethod);
/* Generate code for methods */
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
for(Iterator<LocalityBinding> lbit=locality.getLocalityBindings().iterator(); lbit.hasNext();) {
LocalityBinding lb=lbit.next();
MethodDescriptor md=lb.getMethod();
FlatMethod fm=state.getMethodFlat(md);
+ wb.analyze(lb);
if (!md.getModifiers().isNative()) {
generateFlatMethod(fm, lb, outmethod);
}
/* Output #defines that the runtime uses to determine type
* numbers for various objects it needs */
outstructs.println("#define MAXCOUNT "+maxcount);
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
LocalityBinding lb=new LocalityBinding(typeutil.getRun(), false);
- lb.setGlobalThis(LocalityAnalysis.GLOBAL);
+ if (state.DSM)
+ lb.setGlobalThis(LocalityAnalysis.GLOBAL);
outstructs.println("#define RUNMETHOD "+virtualcalls.getLocalityNumber(lb));
}
}
protected void outputClassDeclarations(PrintWriter outclassdefs) {
- if (state.THREAD||state.DSM)
+ if (state.THREAD||state.DSM||state.SINGLETM)
outclassdefs.println("#include <pthread.h>");
if(state.OPTIONAL)
outclassdefs.println("#include \"optionalstruct.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) {
outclassdefs.println(" int numfses;");
}
MethodDescriptor[][] virtualtable=null;
LocalityBinding[][] lbvirtualtable=null;
- if (state.DSM)
+ if (state.DSM||state.SINGLETM)
lbvirtualtable=new LocalityBinding[state.numClasses()+state.numArrays()][maxcount];
else
virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount];
classit=state.getClassSymbolTable().getDescriptorsIterator();
while(classit.hasNext()) {
ClassDescriptor cd=(ClassDescriptor)classit.next();
- if (state.DSM)
+ if (state.DSM||state.SINGLETM)
fillinRow(cd, lbvirtualtable, cd.getId());
else
fillinRow(cd, virtualtable, cd.getId());
while(arrayit.hasNext()) {
TypeDescriptor td=(TypeDescriptor)arrayit.next();
int id=state.getArrayNumber(td);
- if (state.DSM)
+ if (state.DSM||state.SINGLETM)
fillinRow(objectcd, lbvirtualtable, id+state.numClasses());
else
fillinRow(objectcd, virtualtable, id+state.numClasses());
for(int j=0; j<maxcount; j++) {
if (needcomma)
outvirtual.print(", ");
- if (state.DSM&&lbvirtualtable[i][j]!=null) {
+ if ((state.DSM||state.SINGLETM)&&lbvirtualtable[i][j]!=null) {
LocalityBinding lb=lbvirtualtable[i][j];
MethodDescriptor md=lb.getMethod();
outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
- } else if (!state.DSM&&virtualtable[i][j]!=null) {
+ } else if (!(state.DSM||state.SINGLETM)&&virtualtable[i][j]!=null) {
MethodDescriptor md=virtualtable[i][j];
outvirtual.print("& "+md.getClassDesc().getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
} else {
}
}
-
/** Generate array that contains the sizes of class objects. The
* object allocation functions in the runtime use this
* information. */
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");
}
outclassdefs.println("};");
+
+ ClassDescriptor objectclass=typeutil.getClass(TypeUtil.ObjectClass);
+ needcomma=false;
+ outclassdefs.print("int typearray[]={");
+ for(int i=0;i<state.numClasses();i++) {
+ ClassDescriptor cd=cdarray[i];
+ ClassDescriptor supercd=cd.getSuperDesc();
+ if (needcomma)
+ outclassdefs.print(", ");
+ if (supercd==null)
+ outclassdefs.print("-1");
+ else
+ outclassdefs.print(supercd.getId());
+ needcomma=true;
+ }
+
+ for(int i=0;i<state.numArrays();i++) {
+ TypeDescriptor arraytd=arraytable[i];
+ ClassDescriptor arraycd=arraytd.getClassDesc();
+ if (arraycd==null) {
+ if (needcomma)
+ outclassdefs.print(", ");
+ outclassdefs.print(objectclass.getId());
+ needcomma=true;
+ continue;
+ }
+ ClassDescriptor cd=arraycd.getSuperDesc();
+ int type=-1;
+ while(cd!=null) {
+ TypeDescriptor supertd=new TypeDescriptor(cd);
+ supertd.setArrayCount(arraytd.getArrayCount());
+ type=state.getArrayNumber(supertd);
+ if (type!=-1) {
+ type+=state.numClasses();
+ break;
+ }
+ cd=cd.getSuperDesc();
+ }
+ if (needcomma)
+ outclassdefs.print(", ");
+ outclassdefs.print(type);
+ needcomma=true;
+ }
+
+ outclassdefs.println("};");
+
+ needcomma=false;
+
+
+ outclassdefs.print("int typearray2[]={");
+ for(int i=0;i<state.numArrays();i++) {
+ TypeDescriptor arraytd=arraytable[i];
+ ClassDescriptor arraycd=arraytd.getClassDesc();
+ if (arraycd==null) {
+ if (needcomma)
+ outclassdefs.print(", ");
+ outclassdefs.print("-1");
+ needcomma=true;
+ continue;
+ }
+ ClassDescriptor cd=arraycd.getSuperDesc();
+ int level=arraytd.getArrayCount()-1;
+ int type=-1;
+ for(;level>0;level--) {
+ TypeDescriptor supertd=new TypeDescriptor(objectclass);
+ supertd.setArrayCount(level);
+ type=state.getArrayNumber(supertd);
+ if (type!=-1) {
+ type+=state.numClasses();
+ break;
+ }
+ }
+ if (needcomma)
+ outclassdefs.print(", ");
+ outclassdefs.print(type);
+ needcomma=true;
+ }
+
+ outclassdefs.println("};");
}
/** Constructs params and temp objects for each method or task.
TaskDescriptor task=fm.getTask();
Set<TempDescriptor> saveset=lb!=null ? locality.getTempSet(lb) : null;
ParamsObject objectparams=md!=null ? new ParamsObject(md,tag++) : new ParamsObject(task, tag++);
-
- if (lb!=null)
+ if (lb!=null) {
paramstable.put(lb, objectparams);
+ backuptable.put(lb, new Hashtable<TempDescriptor, TempDescriptor>());
+ }
else if (md!=null)
paramstable.put(md, objectparams);
else
else
objectparams.addPrim(temp);
if(lb!=null&&saveset.contains(temp)) {
- backuptable.put(temp, temp.createNew());
+ backuptable.get(lb).put(temp, temp.createNew());
}
}
else
objecttemps.addPrim(temp);
if(lb!=null&&saveset.contains(temp)&&
- !backuptable.containsKey(temp))
- backuptable.put(temp, temp.createNew());
+ !backuptable.get(lb).containsKey(temp))
+ backuptable.get(lb).put(temp, temp.createNew());
}
}
/* Create backup temps */
if (lb!=null) {
- for(Iterator<TempDescriptor> tmpit=backuptable.values().iterator(); tmpit.hasNext();) {
+ for(Iterator<TempDescriptor> tmpit=backuptable.get(lb).values().iterator(); tmpit.hasNext();) {
TempDescriptor tmp=tmpit.next();
TypeDescriptor type=tmp.getType();
if (type.isPtr()&&GENERATEPRECISEGC)
objecttemps.addPrim(tmp);
}
/* Create temp to hold revert table */
- if (lb.getHasAtomic()||lb.isAtomic()) {
+ if (state.DSM&&(lb.getHasAtomic()||lb.isAtomic())) {
TempDescriptor reverttmp=new TempDescriptor("revertlist", typeutil.getClass(TypeUtil.ObjectClass));
if (GENERATEPRECISEGC)
objecttemps.addPtr(reverttmp);
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) {
classdefout.println(" int numfses;");
printClassStruct(cn, classdefout);
classdefout.println("};\n");
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
/* Cycle through LocalityBindings */
HashSet<MethodDescriptor> nativemethods=new HashSet<MethodDescriptor>();
Set<LocalityBinding> lbset=locality.getClassBindings(cn);
/* Output parameter structure */
if (GENERATEPRECISEGC) {
ParamsObject objectparams=(ParamsObject) paramstable.get(lb!=null ? lb : md);
- if (state.DSM&&lb!=null)
+ if ((state.DSM||state.SINGLETM)&&lb!=null)
output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
else
output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
/* Output temp structure */
if (GENERATEPRECISEGC) {
- if (state.DSM)
+ if (state.DSM||state.SINGLETM)
output.println("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
else
output.println("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals {");
headersout.print("void ");
/* Next the method name */
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
headersout.print(cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
} else
headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
boolean printcomma=false;
if (GENERATEPRECISEGC) {
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
headersout.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
} else
headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
printcomma=true;
}
- if (state.DSM&&lb.isAtomic()&&!md.getModifiers().isNative()) {
- if (printcomma)
- headersout.print(", ");
- headersout.print("transrecord_t * trans");
- printcomma=true;
- }
-
/* Output parameter list*/
for(int i=0; i<objectparams.numPrimitives(); i++) {
TempDescriptor temp=objectparams.getPrimitive(i);
ParamsObject objectparams=(ParamsObject)paramstable.get(lb!=null ? lb : md!=null ? md : task);
generateHeader(fm, lb, md!=null ? md : task,output);
TempObject objecttemp=(TempObject) tempstable.get(lb!=null ? lb : md!=null ? md : task);
- if (state.DSM&&lb.getHasAtomic()) {
- output.println("transrecord_t * trans;");
- }
if (GENERATEPRECISEGC) {
- if (md!=null&&state.DSM)
+ if (md!=null&&(state.DSM||state.SINGLETM))
output.print(" struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
- else if (md!=null&&!state.DSM)
+ else if (md!=null&&!(state.DSM||state.SINGLETM))
output.print(" struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_locals "+localsprefix+"={");
else
output.print(" struct "+task.getSafeSymbol()+"_locals "+localsprefix+"={");
/* Check to see if we need to do a GC if this is a
* multi-threaded program...*/
- if ((state.THREAD||state.DSM)&&GENERATEPRECISEGC) {
+ if ((state.THREAD||state.DSM||state.SINGLETM)&&GENERATEPRECISEGC) {
if (state.DSM&&lb.isAtomic())
- output.println("checkcollect2(&"+localsprefix+",trans);");
+ output.println("if (needtocollect) checkcollect2(&"+localsprefix+");");
else
- output.println("checkcollect(&"+localsprefix+");");
+ output.println("if (needtocollect) checkcollect(&"+localsprefix+");");
}
/* Do the actual code generation */
if (current_node==null) {
current_node=(FlatNode)tovisit.iterator().next();
tovisit.remove(current_node);
+ } else if (tovisit.contains(current_node)){
+ tovisit.remove(current_node);
}
visited.add(current_node);
if (nodetolabel.containsKey(current_node))
output.println("L"+nodetolabel.get(current_node)+":");
if (state.INSTRUCTIONFAILURE) {
- if (state.THREAD||state.DSM) {
+ if (state.THREAD||state.DSM||state.SINGLETM) {
output.println("if ((++instructioncount)>failurecount) {instructioncount=0;injectinstructionfailure();}");
} else
output.println("if ((--instructioncount)==0) injectinstructionfailure();");
} else if(current_node.numNext()==1) {
output.print(" ");
generateFlatNode(fm, lb, current_node, output);
+ if (state.MLP && current_node.kind()==FKind.FlatSESEEnterNode) {
+ current_node=((FlatSESEEnterNode)current_node).getFlatExit();
+ }
FlatNode nextnode=current_node.getNext(0);
if (visited.contains(nextnode)) {
output.println("goto L"+nodetolabel.get(nextnode)+";");
MethodDescriptor md=fm.getMethod();
TaskDescriptor task=fm.getTask();
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.FlatInstanceOfNode:
+ generateFlatInstanceOfNode(fm, lb, (FlatInstanceOfNode)fn, output);
+ return;
+
+ case FKind.FlatSESEEnterNode:
+ if( state.MLP ) generateFlatSESEEnterNode(fm, lb, (FlatSESEEnterNode) fn, output);
+ return;
+
+ case FKind.FlatSESEExitNode:
+ if( state.MLP ) generateFlatSESEExitNode(fm, lb, (FlatSESEExitNode) fn, output);
+ return;
+
case FKind.FlatGlobalConvNode:
generateFlatGlobalConvNode(fm, lb, (FlatGlobalConvNode) fn, output);
return;
output.println("/* nop */");
return;
+ case FKind.FlatExit:
+ output.println("/* exit */");
+ return;
+
case FKind.FlatBackEdge:
- if ((state.THREAD||state.DSM)&&GENERATEPRECISEGC) {
+ if ((state.THREAD||state.DSM||state.SINGLETM)&&GENERATEPRECISEGC) {
if(state.DSM&&locality.getAtomic(lb).get(fn).intValue()>0) {
- output.println("checkcollect2(&"+localsprefix+",trans);");
+ output.println("if (needtocollect) checkcollect2(&"+localsprefix+");");
} 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 */");
+ FieldDescriptor fd=fofn.getField();
+ output.println(generateTemp(fm, fofn.getDst(),lb)+ " = (short) (&((struct "+fofn.getClassType().getSafeSymbol() +" *)0)->"+ fd.getSafeSymbol()+");");
+ output.println("/* offset */");
+ }
+
public void generateFlatPrefetchNode(FlatMethod fm, LocalityBinding lb, FlatPrefetchNode fpn, PrintWriter output) {
if (state.PREFETCH) {
Vector oids = new Vector();
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)+");");
+ output.println("TRANSREAD("+generateTemp(fm, fgcn.getSrc(),lb)+", (unsigned int) "+generateTemp(fm, fgcn.getSrc(),lb)+");");
} else {
/* Need to convert to OID */
if (fgcn.doConvert()) {
}
}
+ public void generateFlatInstanceOfNode(FlatMethod fm, LocalityBinding lb, FlatInstanceOfNode fion, PrintWriter output) {
+ int type;
+ if (fion.getType().isArray()) {
+ type=state.getArrayNumber(fion.getType())+state.numClasses();
+ } else {
+ type=fion.getType().getClassDesc().getId();
+ }
+
+ if (fion.getType().getSymbol().equals(TypeUtil.ObjectClass))
+ output.println(generateTemp(fm, fion.getDst(), lb)+"=1;");
+ else
+ output.println(generateTemp(fm, fion.getDst(), lb)+"=instanceof("+generateTemp(fm,fion.getSrc(),lb)+","+type+");");
+ }
+
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)
/* Backup the temps. */
for(Iterator<TempDescriptor> 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(generateTemp(fm, backuptable.get(lb).get(tmp),lb)+"="+generateTemp(fm,tmp,lb)+";");
}
+
output.println("goto transstart"+faen.getIdentifier()+";");
/******* Print code to retry aborted transaction *******/
/* Restore temps */
for(Iterator<TempDescriptor> 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)+";");
+ output.println(generateTemp(fm, tmp,lb)+"="+generateTemp(fm,backuptable.get(lb).get(tmp),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+";");
- output.println("REVERT_OBJ("+revertptr+");");
- output.println(revertptr+"=tmpptr;");
- output.println("}");
-
+ if (state.DSM) {
+ /********* 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+";");
+ output.println("REVERT_OBJ("+revertptr+");");
+ output.println(revertptr+"=tmpptr;");
+ output.println("}");
+ }
/******* Tell the runtime to start the transaction *******/
output.println("transstart"+faen.getIdentifier()+":");
- output.println("trans=transStart();");
+ output.println("transStart();");
+
+ if (state.ABORTREADERS) {
+ output.println("if (_setjmp(aborttrans)) {");
+ output.println(" goto transretry"+faen.getIdentifier()+"; }");
+ }
}
public void generateFlatAtomicExitNode(FlatMethod fm, LocalityBinding lb, FlatAtomicExitNode faen, PrintWriter output) {
if (locality.getAtomic(lb).get(faen).intValue()>0)
return;
//store the revert list before we lose the transaction object
- String revertptr=generateTemp(fm, reverttable.get(lb),lb);
- output.println(revertptr+"=trans->revertlist;");
- output.println("if (transCommit(trans)) {");
+ String revertptr=null;
+ if (state.DSM) {
+ revertptr=generateTemp(fm, reverttable.get(lb),lb);
+ output.println(revertptr+"=revertlist;");
+ }
+ output.println("if (transCommit()) {");
/* Transaction aborts if it returns true */
output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";");
- output.println("} else {");
+ if (state.DSM) {
+ output.println("} else {");
/* Need to commit local object store */
- output.println("while ("+revertptr+") {");
- output.println("struct ___Object___ * tmpptr;");
- output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
- output.println("COMMIT_OBJ("+revertptr+");");
- output.println(revertptr+"=tmpptr;");
+ output.println("while ("+revertptr+") {");
+ output.println("struct ___Object___ * tmpptr;");
+ output.println("tmpptr="+revertptr+"->"+nextobjstr+";");
+ output.println("COMMIT_OBJ("+revertptr+");");
+ output.println(revertptr+"=tmpptr;");
+ output.println("}");
+ }
+ output.println("}");
+ }
+
+
+ public void generateSESE(FlatMethod fm, LocalityBinding lb, FlatSESEEnterNode faen, PrintWriter output) {
+
+ }
+
+
+ public void generateFlatSESEEnterNode(FlatMethod fm, LocalityBinding lb, FlatSESEEnterNode faen, PrintWriter output) {
+ /*
+ output.println("struct sese"+faen.getPrettyIdentifier()+"in {");
+ Iterator<TempDescriptor> itr = faen.getInVarSet().iterator();
+ while( itr.hasNext() ) {
+ TempDescriptor td = itr.next();
+ output.println(" "+td+";");
+ }
output.println("}");
+
+ output.println("struct sese"+faen.getPrettyIdentifier()+"out {");
+ itr = faen.getOutVarSet().iterator();
+ while( itr.hasNext() ) {
+ TempDescriptor td = itr.next();
+ output.println(" "+td+";");
+ }
output.println("}");
+ */
+ }
+
+ public void generateFlatSESEExitNode(FlatMethod fm, LocalityBinding lb, FlatSESEExitNode faen, PrintWriter output) {
+ //output.println("mlpNotifyExit( (struct SESE*)0 );");
}
private void generateFlatCheckNode(FlatMethod fm, LocalityBinding lb, FlatCheckNode fcn, PrintWriter output) {
private void generateFlatCall(FlatMethod fm, LocalityBinding lb, FlatCall fc, PrintWriter output) {
MethodDescriptor md=fc.getMethod();
- ParamsObject objectparams=(ParamsObject)paramstable.get(state.DSM ? locality.getBinding(lb, fc) : md);
+ ParamsObject objectparams=(ParamsObject)paramstable.get(state.DSM||state.SINGLETM ? locality.getBinding(lb, fc) : md);
ClassDescriptor cn=md.getClassDesc();
output.println("{");
if (GENERATEPRECISEGC) {
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
LocalityBinding fclb=locality.getBinding(lb, fc);
output.print(" struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __parameterlist__={");
} else
}
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()+"!");
+ System.out.println("Source code calls static method "+md+" on an object in "+fm.getMethod()+"!");
}
/* Do we need to do virtual dispatch? */
if (md.isStatic()||md.getReturnType()==null||singleCall(fc.getThis().getType().getClassDesc(),md)) {
//no
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
LocalityBinding fclb=locality.getBinding(lb, fc);
output.print(cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor());
} else {
boolean printcomma=false;
if (GENERATEPRECISEGC) {
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
LocalityBinding fclb=locality.getBinding(lb, fc);
output.print("struct "+cn.getSafeSymbol()+fclb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * ");
} else
output.print(temp.getType().getSafeSymbol());
}
- if (state.DSM&&locality.getBinding(lb,fc).isAtomic()&&!fc.getMethod().getModifiers().isNative()) {
- LocalityBinding fclb=locality.getBinding(lb, fc);
- if (printcomma)
- output.print(", ");
- output.print("transrecord_t *");
- printcomma=true;
- }
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
LocalityBinding fclb=locality.getBinding(lb, fc);
output.print("))virtualtable["+generateTemp(fm,fc.getThis(),lb)+"->type*"+maxcount+"+"+virtualcalls.getLocalityNumber(fclb)+"])");
} else
needcomma=true;
}
- if (state.DSM&&locality.getBinding(lb,fc).isAtomic()&&!fc.getMethod().getModifiers().isNative()) {
- if (needcomma)
- output.print(",");
- output.print("trans");
- needcomma=true;
- }
-
if (!GENERATEPRECISEGC) {
if (fc.getThis()!=null) {
TypeDescriptor ptd=md.getThis().getType();
}
private void generateFlatFieldNode(FlatMethod fm, LocalityBinding lb, FlatFieldNode ffn, PrintWriter output) {
- if (state.DSM) {
+ if (state.SINGLETM) {
+ //single machine transactional memory case
+ String field=ffn.getField().getSafeSymbol();
+ String src=generateTemp(fm, ffn.getSrc(),lb);
+ String dst=generateTemp(fm, ffn.getDst(),lb);
+
+ output.println(dst+"="+ src +"->"+field+ ";");
+ if (ffn.getField().getType().isPtr()) {
+ output.println("TRANSREAD("+dst+", (unsigned int) "+dst+");");
+ }
+ } else if (state.DSM) {
Integer status=locality.getNodePreTempInfo(lb,ffn).get(ffn.getSrc());
if (status==LocalityAnalysis.GLOBAL) {
String field=ffn.getField().getSafeSymbol();
//} else {
output.println(dst+"="+ src +"->"+field+ ";");
//output.println("if ("+dst+"&0x1) {");
- output.println(dst+"=(void *) transRead(trans, (unsigned int) "+dst+");");
+ output.println("TRANSREAD("+dst+", (unsigned int) "+dst+");");
//output.println(src+"->"+field+"="+src+"->"+field+";");
//output.println("}");
//}
String dst=generateTemp(fm, ffn.getDst(),lb);
output.println(dst+"="+ src +"->"+field+ ";");
if (locality.getAtomic(lb).get(ffn).intValue()>0)
- output.println(dst+"=(void *) transRead(trans, (unsigned int) "+dst+");");
+ output.println("TRANSREAD("+dst+", (unsigned int) "+dst+");");
} else
output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
} else if (status==LocalityAnalysis.EITHER) {
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");
- if (state.DSM && locality.getAtomic(lb).get(fsfn).intValue()>0) {
+ if (state.SINGLETM && locality.getAtomic(lb).get(fsfn).intValue()>0) {
+ //Single Machine Transaction Case
+ boolean srcptr=fsfn.getSrc().getType().isPtr();
+ String src=generateTemp(fm,fsfn.getSrc(),lb);
+ String dst=generateTemp(fm,fsfn.getDst(),lb);
+ if (srcptr) {
+ output.println("{");
+ output.println("int srcoid=("+src+"!=NULL?((int)"+src+"->"+oidstr+"):0);");
+ }
+ if (wb.needBarrier(fsfn))
+ output.println("*((unsigned int *)&("+dst+"->___objstatus___))|=DIRTY;");
+ if (srcptr) {
+ output.println("*((unsigned int *)&("+dst+"->"+ fsfn.getField().getSafeSymbol()+"))=srcoid;");
+ output.println("}");
+ } else {
+ output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"="+ src+";");
+ }
+ } else if (state.DSM && locality.getAtomic(lb).get(fsfn).intValue()>0) {
Integer statussrc=locality.getNodePreTempInfo(lb,fsfn).get(fsfn.getSrc());
Integer statusdst=locality.getNodeTempInfo(lb).get(fsfn).get(fsfn.getDst());
boolean srcglobal=statussrc==LocalityAnalysis.GLOBAL;
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;
//mark it dirty
- output.println("*((unsigned int *)&("+dst+"->___localcopy___))|=DIRTY;");
+ if (wb.needBarrier(fsfn))
+ output.println("*((unsigned int *)&("+dst+"->___localcopy___))|=DIRTY;");
if (srcglobal) {
output.println("*((unsigned int *)&("+glbdst+"->"+ fsfn.getField().getSafeSymbol()+"))=srcoid;");
} else
output.println("if(!"+dst+"->"+localcopystr+") {");
/* Link object into list */
String revertptr=generateTemp(fm, reverttable.get(lb),lb);
- output.println(revertptr+"=trans->revertlist;");
+ output.println(revertptr+"=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("revertlist=(struct ___Object___ *)"+dst+";");
output.println("}");
if (srcglobal)
output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;");
} else if (statusdst.equals(LocalityAnalysis.EITHER)) {
//writing to a null...bad
output.println("if ("+dst+") {");
- 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
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();");
}
- if (state.DSM) {
+ if (state.SINGLETM) {
+ //Single machine transaction case
+ String dst=generateTemp(fm, fen.getDst(),lb);
+
+ if (elementtype.isPtr()) {
+ output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
+ output.println("TRANSREAD("+dst+", "+dst+");");
+ } else {
+ output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
+ }
+ } else if (state.DSM) {
Integer status=locality.getNodePreTempInfo(lb,fen).get(fen.getSrc());
if (status==LocalityAnalysis.GLOBAL) {
String dst=generateTemp(fm, fen.getDst(),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+");");
+ output.println("TRANSREAD("+dst+", "+dst+");");
} else {
output.println(dst +"=(("+ type+"*)(((char *) &("+ generateTemp(fm,fen.getSrc(),lb)+"->___length___))+sizeof(int)))["+generateTemp(fm, fen.getIndex(),lb)+"];");
}
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 (state.DSM && locality.getAtomic(lb).get(fsen).intValue()>0) {
+ if (state.SINGLETM && locality.getAtomic(lb).get(fsen).intValue()>0) {
+ //Transaction set element case
+ if (wb.needBarrier(fsen))
+ output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst(),lb)+"->___objstatus___))|=DIRTY;");
+ if (fsen.getSrc().getType().isPtr()) {
+ output.println("{");
+ String src=generateTemp(fm, fsen.getSrc(), lb);
+ 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 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 dstlocal=statusdst==LocalityAnalysis.LOCAL;
if (dstglobal) {
- output.println("*((unsigned int *)&("+generateTemp(fm,fsen.getDst(),lb)+"->___localcopy___))|=DIRTY;");
+ if (wb.needBarrier(fsen))
+ 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;");
+ output.println(revertptr+"=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("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 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);
- output.println(revertptr+"=trans->revertlist;");
- }
- if (fn.getType().isArray()) {
+ output.println(revertptr+"=revertlist;");
+ }
+ if (state.SINGLETM) {
+ if (fn.getType().isArray()) {
+ int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
+ if (locality.getAtomic(lb).get(fn).intValue()>0) {
+ //inside transaction
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarraytrans(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
+ } else {
+ //outside transaction
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
+ }
+ } else {
+ if (locality.getAtomic(lb).get(fn).intValue()>0) {
+ //inside transaction
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newtrans(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
+ } else {
+ //outside transaction
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
+ }
+ }
+ } else if (fn.getType().isArray()) {
int arrayid=state.getArrayNumber(fn.getType())+state.numClasses();
if (fn.isGlobal()) {
- output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarrayglobal(trans, "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarrayglobal("+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
} else if (GENERATEPRECISEGC) {
output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newarray(&"+localsprefix+", "+arrayid+", "+generateTemp(fm, fn.getSize(),lb)+");");
} else {
}
} else {
if (fn.isGlobal()) {
- output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newglobal(trans, "+fn.getType().getClassDesc().getId()+");");
+ output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_newglobal("+fn.getType().getClassDesc().getId()+");");
} else if (GENERATEPRECISEGC) {
output.println(generateTemp(fm,fn.getDst(),lb)+"=allocate_new(&"+localsprefix+", "+fn.getType().getClassDesc().getId()+");");
} else {
}
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("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+";");
}
}
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(revertptr+"=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+";");
+ output.println("revertlist="+revertptr+";");
}
} else {
output.println(generateTemp(fm, fln.getDst(),lb)+"=NewString(\""+FlatLiteralNode.escapeString((String)fln.getValue())+"\","+((String)fln.getValue()).length()+");");
//catch the constructor case
output.print("void ");
if (md!=null) {
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
output.print(cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
} else
output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
boolean printcomma=false;
if (GENERATEPRECISEGC) {
if (md!=null) {
- if (state.DSM) {
+ if (state.DSM||state.SINGLETM) {
output.print("struct "+cn.getSafeSymbol()+lb.getSignature()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
} else
output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
printcomma=true;
}
- if (state.DSM&&lb.isAtomic()) {
- if (printcomma)
- output.print(", ");
- output.print("transrecord_t * trans");
- printcomma=true;
- }
-
if (md!=null) {
/* Method */
for(int i=0; i<objectparams.numPrimitives(); i++) {
projects / IRC.git / blobdiff