From 4b188fd7715dc5e14068f9e82f311f62a116171f Mon Sep 17 00:00:00 2001 From: bdemsky Date: Wed, 15 Aug 2007 01:13:52 +0000 Subject: [PATCH] lots of changes for dsm now that william's stuff is checked in --- .../Locality/GenerateConversions.java | 4 +- .../Analysis/Locality/LocalityAnalysis.java | 15 ++ .../Analysis/Locality/LocalityBinding.java | 33 +++- Robust/src/IR/Flat/BuildCode.java | 172 ++++++++++++++---- Robust/src/IR/Flat/TempDescriptor.java | 5 + Robust/src/IR/Virtual.java | 82 +++++++-- Robust/src/Main/Main.java | 12 +- .../src/Runtime/DSTM/interface/localobjects.c | 18 +- .../src/Runtime/DSTM/interface/localobjects.h | 3 +- Robust/src/buildscript | 13 ++ 10 files changed, 293 insertions(+), 64 deletions(-) diff --git a/Robust/src/Analysis/Locality/GenerateConversions.java b/Robust/src/Analysis/Locality/GenerateConversions.java index 8585773b..74bfe1e7 100644 --- a/Robust/src/Analysis/Locality/GenerateConversions.java +++ b/Robust/src/Analysis/Locality/GenerateConversions.java @@ -61,6 +61,8 @@ public class GenerateConversions { HashSet tempset=new HashSet(); for(int i=0;i prevset=nodetotnpair.get(fnprev); for(Iterator it=prevset.iterator();it.hasNext();) { TempNodePair tnp=it.next(); @@ -112,7 +114,7 @@ public class GenerateConversions { toprocess=fm.getNodeSet(); for(Iterator it=toprocess.iterator();it.hasNext();) { FlatNode fn=it.next(); - if (atomictab.get(fn).intValue()==0&& + if (atomictab.get(fn).intValue()==0&&fn.numPrev()>0&& atomictab.get(fn.getPrev(0)).intValue()>0) { //sanity check assert(fn.kind()==FKind.FlatAtomicExitNode); diff --git a/Robust/src/Analysis/Locality/LocalityAnalysis.java b/Robust/src/Analysis/Locality/LocalityAnalysis.java index 86078d2e..a780a3a0 100644 --- a/Robust/src/Analysis/Locality/LocalityAnalysis.java +++ b/Robust/src/Analysis/Locality/LocalityAnalysis.java @@ -18,6 +18,7 @@ public class LocalityAnalysis { Hashtable> atomictab; Hashtable>> tempstosave; Hashtable> classtolb; + Hashtable> methodtolb; CallGraph callgraph; TypeUtil typeutil; @@ -37,6 +38,7 @@ public class LocalityAnalysis { this.callgraph=callgraph; this.tempstosave=new Hashtable>>(); this.classtolb=new Hashtable>(); + this.methodtolb=new Hashtable>(); doAnalysis(); } @@ -46,6 +48,12 @@ public class LocalityAnalysis { return classtolb.get(cd); } + /** This method returns a set of LocalityBindings for the parameter method. */ + + public Set getMethodBindings(MethodDescriptor md) { + return methodtolb.get(md); + } + /** This method returns a set of LocalityBindings. A * LocalityBinding specifies a context a method can be invoked in. * It specifies whether the method is in a transaction and whether @@ -106,6 +114,10 @@ public class LocalityAnalysis { classtolb.put(lbmain.getMethod().getClassDesc(), new HashSet()); classtolb.get(lbmain.getMethod().getClassDesc()).add(lbmain); + if (!methodtolb.containsKey(lbmain.getMethod())) + methodtolb.put(lbmain.getMethod(), new HashSet()); + methodtolb.get(lbmain.getMethod()).add(lbmain); + while(!lbtovisit.empty()) { LocalityBinding lb=(LocalityBinding) lbtovisit.pop(); Integer returnglobal=lb.getGlobalReturn(); @@ -291,6 +303,9 @@ public class LocalityAnalysis { if (!classtolb.containsKey(lb.getMethod().getClassDesc())) classtolb.put(lb.getMethod().getClassDesc(), new HashSet()); classtolb.get(lb.getMethod().getClassDesc()).add(lb); + if (!methodtolb.containsKey(lb.getMethod())) + methodtolb.put(lb.getMethod(), new HashSet()); + methodtolb.get(lb.getMethod()).add(lb); } else lb=discovered.get(lb); Integer returnval=lb.getGlobalReturn(); diff --git a/Robust/src/Analysis/Locality/LocalityBinding.java b/Robust/src/Analysis/Locality/LocalityBinding.java index cfd9c5d4..9dd6af0e 100644 --- a/Robust/src/Analysis/Locality/LocalityBinding.java +++ b/Robust/src/Analysis/Locality/LocalityBinding.java @@ -37,15 +37,15 @@ public class LocalityBinding { } public String getSignature() { - if (md.getModifiers().isNative()) - return ""; - String st="_"; if (isatomic) { st+="A"; } else st+="N"; - st+=globalToString(isglobalthis); + if (isglobalthis==null) + st+="N"; + else + st+=globalToString(isglobalthis); for(int i=0;i backuptable; + Hashtable reverttable; public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil) { + this(st, temptovar, typeutil, null); + } + + public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality) { state=st; this.temptovar=temptovar; - paramstable=new Hashtable(); + paramstable=new Hashtable(); tempstable=new Hashtable(); fieldorder=new Hashtable(); flagorder=new Hashtable(); this.typeutil=typeutil; - virtualcalls=new Virtual(state); - } - - public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil, LocalityAnalysis locality) { - this(st, temptovar, typeutil); - this.locality=locality; - this.backuptable=new Hashtable(); + virtualcalls=new Virtual(state,locality); + if (locality!=null) { + this.locality=locality; + this.backuptable=new Hashtable(); + this.reverttable=new Hashtable(); + } } /** The buildCode method outputs C code for all the methods. The Flat @@ -174,22 +178,37 @@ public class BuildCode { private void outputMainMethod(PrintWriter outmethod) { outmethod.println("int main(int argc, const char *argv[]) {"); outmethod.println(" int i;"); - if (GENERATEPRECISEGC) { - outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);"); + if (state.DSM) { + outmethod.println("if (dstmStart(argv[0])) {"); + if (GENERATEPRECISEGC) { + outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-2);"); + } else { + outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-2);"); + } } else { - outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);"); + if (GENERATEPRECISEGC) { + outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(NULL, STRINGARRAYTYPE, argc-1);"); + } else { + outmethod.println(" struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc-1);"); + } } if (state.THREAD) { outmethod.println("initializethreads();"); } - outmethod.println(" for(i=1;i___length___)+sizeof(int)))[i-1]=newstring;"); + if (state.DSM) + outmethod.println(" ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-2]=newstring;"); + else + outmethod.println(" ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;"); outmethod.println(" }"); @@ -204,7 +223,11 @@ public class BuildCode { } else outmethod.println(" "+cd.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(stringarray);"); outmethod.println(" }"); - + + if (state.DSM) { + outmethod.println("}"); + } + if (state.THREAD) { outmethod.println("pthread_mutex_lock(&gclistlock);"); outmethod.println("threadcount--;"); @@ -212,6 +235,8 @@ public class BuildCode { outmethod.println("pthread_mutex_unlock(&gclistlock);"); outmethod.println("pthread_exit(NULL);"); } + + outmethod.println("}"); } @@ -255,6 +280,8 @@ public class BuildCode { outmethod.println("#include \"methodheaders.h\""); outmethod.println("#include \"virtualtable.h\""); outmethod.println("#include "); + if (state.DSM) + outmethod.println("#include \"localobjects.h\""); if (state.THREAD) outmethod.println("#include "); if (state.main!=null) { @@ -556,13 +583,21 @@ public class BuildCode { if (virtualcalls.getMethodCount(cd)>maxcount) maxcount=virtualcalls.getMethodCount(cd); } - MethodDescriptor[][] virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount]; + MethodDescriptor[][] virtualtable=null; + LocalityBinding[][] lbvirtualtable=null; + if (state.DSM) + lbvirtualtable=new LocalityBinding[state.numClasses()+state.numArrays()][maxcount]; + else + virtualtable=new MethodDescriptor[state.numClasses()+state.numArrays()][maxcount]; /* Fill in virtual table */ classit=state.getClassSymbolTable().getDescriptorsIterator(); while(classit.hasNext()) { ClassDescriptor cd=(ClassDescriptor)classit.next(); - fillinRow(cd, virtualtable, cd.getId()); + if (state.DSM) + fillinRow(cd, lbvirtualtable, cd.getId()); + else + fillinRow(cd, virtualtable, cd.getId()); } ClassDescriptor objectcd=typeutil.getClass(TypeUtil.ObjectClass); @@ -570,7 +605,10 @@ public class BuildCode { while(arrayit.hasNext()) { TypeDescriptor td=(TypeDescriptor)arrayit.next(); int id=state.getArrayNumber(td); - fillinRow(objectcd, virtualtable, id+state.numClasses()); + if (state.DSM) + fillinRow(objectcd, lbvirtualtable, id+state.numClasses()); + else + fillinRow(objectcd, virtualtable, id+state.numClasses()); } outvirtual.print("void * virtualtable[]={"); @@ -579,7 +617,11 @@ public class BuildCode { for(int j=0;j lbit=locality.getClassBindings(cd).iterator();lbit.hasNext();) { + LocalityBinding lb=lbit.next(); + MethodDescriptor md=lb.getMethod(); + //Is the method static or a constructor + if (md.isStatic()||md.getReturnType()==null) + continue; + int methodnum=virtualcalls.getLocalityNumber(lb); + virtualtable[rownum][methodnum]=lb; + } + } + + /** Generate array that contains the sizes of class objects. The * object allocation functions in the runtime use this * information. */ @@ -708,7 +768,7 @@ public class BuildCode { } /* Create backup temps */ - if (state.DSM) + if (state.DSM) { for(Iterator tmpit=backuptable.values().iterator();tmpit.hasNext();) { TempDescriptor tmp=tmpit.next(); TypeDescriptor type=tmp.getType(); @@ -717,6 +777,12 @@ public class BuildCode { else objecttemps.addPrim(tmp); } + /* Create temp to hold revert table */ + if (lb.getHasAtomic()) { + TempDescriptor reverttmp=new TempDescriptor("revertlist", typeutil.getClass(TypeUtil.ObjectClass)); + reverttable.put(lb, reverttmp); + } + } } /** This method outputs the following information about classes @@ -766,7 +832,7 @@ public class BuildCode { output.println(", "); TypeDescriptor tdelement=arraytable[i].dereference(); if (tdelement.isArray()||tdelement.isClass()) - output.print("((int *)1)"); + output.print("((unsigned int *)1)"); else output.print("0"); needcomma=true; @@ -900,11 +966,13 @@ public class BuildCode { if (state.DSM) { /* Cycle through LocalityBindings */ - for(Iterator lbit=locality.getClassBindings(cn).iterator();lbit.hasNext();) { - LocalityBinding lb=lbit.next(); - MethodDescriptor md=lb.getMethod(); - generateMethod(cn, md, lb, headersout, output); - } + Set lbset=locality.getClassBindings(cn); + if (lbset!=null) + for(Iterator lbit=lbset.iterator();lbit.hasNext();) { + LocalityBinding lb=lbit.next(); + MethodDescriptor md=lb.getMethod(); + generateMethod(cn, md, lb, headersout, output); + } } else { /* Cycle through methods */ for(Iterator methodit=cn.getMethods();methodit.hasNext();) { @@ -917,7 +985,7 @@ public class BuildCode { private void generateMethod(ClassDescriptor cn, MethodDescriptor md, LocalityBinding lb, PrintWriter headersout, PrintWriter output) { FlatMethod fm=state.getMethodFlat(md); - generateTempStructs(fm, null); + generateTempStructs(fm, lb); ParamsObject objectparams=(ParamsObject) paramstable.get(md); TempObject objecttemps=(TempObject) tempstable.get(md); @@ -1059,7 +1127,7 @@ public class BuildCode { } } - /** Generate code for FlatMethod fm. */ + /***** Generate code for FlatMethod fm. *****/ private void generateFlatMethod(FlatMethod fm, LocalityBinding lb, PrintWriter output) { MethodDescriptor md=fm.getMethod(); @@ -1224,11 +1292,14 @@ public class BuildCode { case FKind.FlatAtomicExitNode: generateFlatAtomicExitNode(fm, lb, (FlatAtomicExitNode) fn, output); return; + case FKind.FlatGlobalConvNode: + generateFlatGlobalConvNode(fm, lb, (FlatGlobalConvNode) fn, output); + return; case FKind.FlatTagDeclaration: generateFlatTagDeclaration(fm, (FlatTagDeclaration) fn,output); return; case FKind.FlatCall: - generateFlatCall(fm, (FlatCall) fn,output); + generateFlatCall(fm, lb, (FlatCall) fn,output); return; case FKind.FlatFieldNode: generateFlatFieldNode(fm, lb, (FlatFieldNode) fn,output); @@ -1277,6 +1348,18 @@ public class BuildCode { } + 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())+"=transRead(trans,"+generateTemp(fm, fgcn.getSrc())+");"); + } else { + /* Need to convert to OID */ + output.println(generateTemp(fm, fgcn.getSrc())+"=OID("+generateTemp(fm, fgcn.getSrc())+");"); + } + } + 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) @@ -1297,7 +1380,15 @@ public class BuildCode { output.println(generateTemp(fm, tmp)+"="+generateTemp(fm,backuptable.get(tmp))+";"); } - /* Need to revert local object store */ + /********* Need to revert local object store ********/ + String revertptr=generateTemp(fm, reverttable.get(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 *******/ @@ -1309,11 +1400,21 @@ public class BuildCode { /* Check to see if we need to generate code for this atomic */ if (locality.getAtomic(lb).get(faen).intValue()>0) return; - output.println("if (transCommit(trans))"); + //store the revert list before we lose the transaction object + String revertptr=generateTemp(fm, reverttable.get(lb)); + output.println(revertptr+"=trans->revertlist;"); + output.println("if (transCommit(trans)) {"); /* Transaction aborts if it returns true */ output.println("goto transretry"+faen.getAtomicEnter().getIdentifier()+";"); + output.println("} else {"); /* Need to commit local object store */ - //TODO + 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("}"); } private void generateFlatCheckNode(FlatMethod fm, FlatCheckNode fcn, PrintWriter output) { @@ -1340,7 +1441,7 @@ public class BuildCode { } } - private void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) { + private void generateFlatCall(FlatMethod fm, LocalityBinding lb, FlatCall fc, PrintWriter output) { MethodDescriptor md=fc.getMethod(); ParamsObject objectparams=(ParamsObject) paramstable.get(md); ClassDescriptor cn=md.getClassDesc(); @@ -1504,7 +1605,7 @@ public class BuildCode { 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) { + if (state.DSM && locality.getAtomic(lb).get(fsfn).intValue()>0) { Integer statussrc=locality.getNodeTempInfo(lb).get(fsfn).get(fsfn.getDst()); Integer statusdst=locality.getNodeTempInfo(lb).get(fsfn).get(fsfn.getDst()); boolean srcglobal=statusdst==LocalityAnalysis.GLOBAL; @@ -1529,7 +1630,10 @@ public class BuildCode { /* Link object into list */ output.println(dst+"->"+nextobjstr+"=trans->localtrans;"); output.println("trans->localtrans="+dst+";"); - output.println("OBJECT_COPY("+dst+");"); + if (GENERATEPRECISEGC) + output.println("COPY_OBJ((struct garbagelist *)&"+localsprefix+",(struct ___Object___ *)"+dst+");"); + else + output.println("COPY_OBJ("+dst+");"); output.println("}"); if (srcglobal) output.println(dst+"->"+ fsfn.getField().getSafeSymbol()+"=srcoid;"); diff --git a/Robust/src/IR/Flat/TempDescriptor.java b/Robust/src/IR/Flat/TempDescriptor.java index 40faaa4c..a25fdb83 100644 --- a/Robust/src/IR/Flat/TempDescriptor.java +++ b/Robust/src/IR/Flat/TempDescriptor.java @@ -18,6 +18,11 @@ public class TempDescriptor extends Descriptor { type=td; } + public TempDescriptor(String name, ClassDescriptor cd) { + this(name); + type=new TypeDescriptor(cd); + } + public TempDescriptor(String name, TypeDescriptor type, TagDescriptor td) { this(name); this.type=type; diff --git a/Robust/src/IR/Virtual.java b/Robust/src/IR/Virtual.java index 11d027b5..39822908 100644 --- a/Robust/src/IR/Virtual.java +++ b/Robust/src/IR/Virtual.java @@ -1,23 +1,35 @@ package IR; import java.util.*; +import Analysis.Locality.LocalityBinding; +import Analysis.Locality.LocalityAnalysis; public class Virtual { State state; - Hashtable methodnumber; - Hashtable classmethodcount; - + LocalityAnalysis locality; + Hashtable methodnumber; + Hashtable classmethodcount; + Hashtable localitynumber; + public int getMethodNumber(MethodDescriptor md) { - return ((Integer)methodnumber.get(md)).intValue(); + return methodnumber.get(md).intValue(); } - + public int getMethodCount(ClassDescriptor md) { - return ((Integer)classmethodcount.get(md)).intValue(); + return classmethodcount.get(md).intValue(); + } + + public int getLocalityNumber(LocalityBinding lb) { + return localitynumber.get(lb).intValue(); } - public Virtual(State state) { + public Virtual(State state, LocalityAnalysis locality) { this.state=state; - methodnumber=new Hashtable(); - classmethodcount=new Hashtable(); + this.locality=locality; + classmethodcount=new Hashtable(); + if (state.DSM) + localitynumber=new Hashtable(); + else + methodnumber=new Hashtable(); doAnalysis(); } @@ -25,13 +37,61 @@ public class Virtual { Iterator classit=state.getClassSymbolTable().getDescriptorsIterator(); while(classit.hasNext()) { ClassDescriptor cd=(ClassDescriptor)classit.next(); - numberMethods(cd); + if (state.DSM) + numberLocality(cd); + else + numberMethods(cd); } } + private int numberLocality(ClassDescriptor cd) { + if (classmethodcount.containsKey(cd)) + return classmethodcount.get(cd).intValue(); + ClassDescriptor superdesc=cd.getSuperDesc(); + int start=0; + if (superdesc!=null) + start=numberLocality(superdesc); + + if (locality.getClassBindings(cd)!=null) + for(Iterator lbit=locality.getClassBindings(cd).iterator();lbit.hasNext();) { + LocalityBinding lb=lbit.next(); + MethodDescriptor md=lb.getMethod(); + //Is it a static method or constructor + if (md.isStatic()||md.getReturnType()==null) + continue; + + if (superdesc!=null) { + Set possiblematches=superdesc.getMethodTable().getSet(md.getSymbol()); + boolean foundmatch=false; + for(Iterator matchit=possiblematches.iterator();matchit.hasNext();) { + MethodDescriptor matchmd=(MethodDescriptor)matchit.next(); + if (md.matches(matchmd)) { + Set lbset=locality.getMethodBindings(matchmd); + if (lbset!=null) + for(Iterator suplbit=lbset.iterator();suplbit.hasNext();) { + LocalityBinding suplb=suplbit.next(); + if (lb.contextMatches(suplb)) { + foundmatch=true; + localitynumber.put(lb, localitynumber.get(suplb)); + break; + } + } + break; + } + } + if (!foundmatch) + localitynumber.put(lb, new Integer(start++)); + } else { + localitynumber.put(lb, new Integer(start++)); + } + } + classmethodcount.put(cd, new Integer(start)); + return start; + } + private int numberMethods(ClassDescriptor cd) { if (classmethodcount.containsKey(cd)) - return ((Integer)classmethodcount.get(cd)).intValue(); + return classmethodcount.get(cd).intValue(); ClassDescriptor superdesc=cd.getSuperDesc(); int start=0; if (superdesc!=null) diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java index 0221524e..6e7f80fc 100644 --- a/Robust/src/Main/Main.java +++ b/Robust/src/Main/Main.java @@ -97,6 +97,9 @@ public class Main { if (state.TASK) { readSourceFile(state, ClassLibraryPrefix+"Object.java"); readSourceFile(state, ClassLibraryPrefix+"TagDescriptor.java"); + } else if (state.DSM) { + readSourceFile(state, ClassLibraryPrefix+"ThreadDSM.java"); + readSourceFile(state, ClassLibraryPrefix+"ObjectJavaDSM.java"); } else { if (state.THREAD) { readSourceFile(state, ClassLibraryPrefix+"Thread.java"); @@ -157,11 +160,12 @@ public class Main { CallGraph callgraph=new CallGraph(state); LocalityAnalysis la=new LocalityAnalysis(state, callgraph, tu); GenerateConversions gc=new GenerateConversions(la, state); + BuildCode bc=new BuildCode(state, bf.getMap(), tu, la); + bc.buildCode(); + } else { + BuildCode bc=new BuildCode(state, bf.getMap(), tu); + bc.buildCode(); } - - BuildCode bc=new BuildCode(state, bf.getMap(), tu); - bc.buildCode(); - System.exit(0); } diff --git a/Robust/src/Runtime/DSTM/interface/localobjects.c b/Robust/src/Runtime/DSTM/interface/localobjects.c index 5c3e8b04..f1c46535 100644 --- a/Robust/src/Runtime/DSTM/interface/localobjects.c +++ b/Robust/src/Runtime/DSTM/interface/localobjects.c @@ -1,14 +1,16 @@ #include "localobjects.h" +#include + void REVERT_OBJ(struct ___Object___ * obj) { int type=((int *)obj)[0]; - struct ___Object___ * copyobj=obj->localcopy; + struct ___Object___ * copyobj=obj->___localcopy___; if (type___length___; int size=sizeof(struct ArrayObject)+length*elementsize; @@ -27,23 +29,25 @@ void COPY_OBJ(struct ___Object___ *obj) { int size=classsize[type]; #ifdef PRECISE_GC int ptrarray[]={1, (int) gl, (int) obj}; - struct ___Object___ * newobj=mygcmalloc(ptrarray, size); + struct ___Object___ * newobj=mygcmalloc((struct garbagelist *)ptrarray, size); #else struct ___Object___ * newobj=FREEMALLOC(size); #endif memcpy(newobj, (struct ___Object___ *) ptrarray[1], size); - ((struct ___Object___*)ptrarray[1])->localcopy=newobj; + ((struct ___Object___*)ptrarray[1])->___localcopy___=newobj; } else { /* We have an array */ - struct ArrayObject *ao=(struct ArrayObject *)orig; + struct ArrayObject *ao=(struct ArrayObject *)obj; int elementsize=classsize[type]; int length=ao->___length___; int size=sizeof(struct ArrayObject)+length*elementsize; #ifdef PRECISE_GC int ptrarray[]={1, (int) gl, (int) obj}; - struct ___Object___ * newobj=mygcmalloc(ptrarray, size); + struct ___Object___ * newobj=mygcmalloc((struct garbagelist *)ptrarray, size); #else struct ___Object___ * newobj=FREEMALLOC(size); #endif - ((struct ___Object___*)ptrarray[1])->localcopy=newobj; + memcpy(newobj, (struct ___Object___ *) ptrarray[1], size); + ((struct ___Object___*)ptrarray[1])->___localcopy___=newobj; + } } diff --git a/Robust/src/Runtime/DSTM/interface/localobjects.h b/Robust/src/Runtime/DSTM/interface/localobjects.h index 2e35a765..d32095ba 100644 --- a/Robust/src/Runtime/DSTM/interface/localobjects.h +++ b/Robust/src/Runtime/DSTM/interface/localobjects.h @@ -1,6 +1,7 @@ #ifndef LOCALOBJECT_H -#include LOCALOBJECT_H +#define LOCALOBJECT_H #include "structdefs.h" +#include "garbage.h" void REVERT_OBJ(struct ___Object___ *); #define COMMIT_OBJ(obj) obj->localcopy=NULL diff --git a/Robust/src/buildscript b/Robust/src/buildscript index 1c73bf72..69000d15 100755 --- a/Robust/src/buildscript +++ b/Robust/src/buildscript @@ -2,6 +2,7 @@ printhelp() { echo -dsm distributed shared memory +echo -mac distributed shared memory mac support echo -check generate check code echo -dmalloc link in dmalloc echo -recover compile task code @@ -22,8 +23,10 @@ echo -help help } ROBUSTROOT=~/research/Robust/src +DSMRUNTIME=$ROBUSTROOT/Runtime/DSTM/interface/ REPAIRROOT=~/research/Repair/RepairCompiler/ CURDIR=`pwd` +DSMFLAG=false CHECKFLAG=false RECOVERFLAG=false USEDMALLOC=false @@ -58,6 +61,10 @@ shift elif [[ $1 = '-dsm' ]] then JAVAOPTS="$JAVAOPTS -dsm" +DSMFLAG=true +elif [[ $1 = '-mac' ]] +then +EXTRAOPTIONS="$EXTRAOPTIONS -DMAC" elif [[ $1 = '-taskstate' ]] then JAVAOPTS="$JAVAOPTS -taskstate" @@ -183,6 +190,12 @@ $ROBUSTROOT/Runtime/SimpleHash.c $ROBUSTROOT/Runtime/option.c \ $ROBUSTROOT/Runtime/garbage.c $ROBUSTROOT/Runtime/socket.c \ $ROBUSTROOT/Runtime/GenericHashtable.c $ROBUSTROOT/Runtime/object.c" +if $DSMFLAG +then +EXTRAOPTIONS="$EXTRAOPTIONS -lpthread -I$DSMRUNTIME" +FILES="$FILES $DSMRUNTIME/dstm.c $DSMRUNTIME/mlookup.c $DSMRUNTIME/clookup.c $DSMRUNTIME/llookup.c $DSMRUNTIME/dstmserver.c $DSMRUNTIME/plookup.c $DSMRUNTIME/ip.c $DSMRUNTIME/queue.c $DSMRUNTIME/prelookup.c $DSMRUNTIME/machinepile.c $DSMRUNTIME/localobjects.c" +fi + if $RECOVERFLAG then EXTRAOPTIONS="$EXTRAOPTIONS -DTASK" -- 2.34.1