Hashtable<FlatNew, Vector<FlatNew>> m_aliasFNTbl;
Hashtable<FlatNew, Vector<Integer>> m_aliaslocksTbl4FN;
- public BuildCodeMultiCore(State st,
- Hashtable temptovar,
- TypeUtil typeutil,
- SafetyAnalysis sa,
- Vector<Schedule> scheduling,
- int coreNum,
- int gcoreNum, CallGraph callgraph) {
+ public BuildCodeMultiCore(State st,
+ Hashtable temptovar,
+ TypeUtil typeutil,
+ SafetyAnalysis sa,
+ Vector<Schedule> scheduling,
+ int coreNum,
+ int gcoreNum, CallGraph callgraph) {
super(st, temptovar, typeutil, sa, callgraph);
this.scheduling = scheduling;
this.coreNum = coreNum; // # of the active cores
e.printStackTrace();
System.exit(-1);
}
-
+
/* Fix field safe symbols due to shadowing */
FieldShadow.handleFieldShadow(state);
/* Build the virtual dispatch tables */
buildVirtualTables(outvirtual);
-
+
/* Tag the methods that are invoked by static blocks */
tagMethodInvokedByStaticBlock();
/* Output Structures */
outputStructs(outstructs);
-
+
outglobaldefs.println("#ifndef __GLOBALDEF_H_");
outglobaldefs.println("#define __GLOBALDEF_H_");
outglobaldefs.println("");
boolean comma = false;
outtaskdefs.println("struct parameterwrapper ** objectqueues[][NUMCLASSES] = {");
boolean needcomma = false;
- for(int i = 0; i < numqueues.length ; ++i) {
+ for(int i = 0; i < numqueues.length; ++i) {
if(needcomma) {
outtaskdefs.println(",");
} else {
/* parameter queue arrays for all the tasks*/
outtaskdefs.println("struct parameterwrapper *** paramqueues[] = {");
needcomma = false;
- for(int i = 0; i < this.coreNum ; ++i) {
+ for(int i = 0; i < this.coreNum; ++i) {
if(needcomma) {
outtaskdefs.println(",");
} else {
/* Record number of total cores */
outstructs.println("#define NUMCORES "+this.tcoreNum);
/* Record number of active cores */
- outstructs.println("#define NUMCORESACTIVE "+this.coreNum); // this.coreNum
- // can be reset by the scheduling analysis
+ outstructs.println("#define NUMCORESACTIVE "+this.coreNum); // this.coreNum
+ // can be reset by the scheduling analysis
/* Record number of garbage collection cores */
outstructs.println("#ifdef MULTICORE_GC");
outstructs.println("#define NUMCORES4GC "+this.gcoreNum);
}*/
outputInitStaticAndGlobalMethod(outmethod);
-
+
/* Close files */
outmethodheader.println("#endif");
outmethodheader.close();
outstructs.println("#endif");
outstructs.close();
}
-
+
private void outputInitStaticAndGlobalMethod(PrintWriter outmethod) {
outmethod.println("void initStaticAndGlobal() {");
outmethod.println(" int i;");
-
+
if (state.MULTICOREGC) {
outmethod.println(" global_defs_p->size="+globaldefscount+";");
outmethod.println(" global_defs_p->next=NULL;");
outmethod.println(" ((struct garbagelist *)global_defs_p)->array[i]=NULL;");
outmethod.println(" }");
}
-
+
outputStaticBlocks(outmethod);
outputClassObjects(outmethod);
* passed in (when PRECISE GC is enabled) and (2) function
* prototypes for the tasks */
- protected void generateTaskStructs(PrintWriter output,
- PrintWriter headersout) {
+ protected void generateTaskStructs(PrintWriter output,
+ PrintWriter headersout) {
/* Cycle through tasks */
for(int i = 0; i < this.scheduling.size(); ++i) {
Schedule tmpschedule = this.scheduling.elementAt(i);
/* This method outputs code for each task. */
- protected void outputTaskCode(PrintWriter outtaskdefs,
- PrintWriter outmethod,
- PrintWriter outtask,
- Iterator[] taskits,
- int[] numtasks,
- int[][] numqueues) {
+ protected void outputTaskCode(PrintWriter outtaskdefs,
+ PrintWriter outmethod,
+ PrintWriter outtask,
+ Iterator[] taskits,
+ int[] numtasks,
+ int[][] numqueues) {
/* Compile task based program */
outtaskdefs.println("#include \"task.h\"");
outtaskdefs.println("#include \"methodheaders.h\"");
outtask.println("#include \"structdefs.h\"");
outtask.println("#include \"Queue.h\"");
outtask.println("#include <string.h>");
- outtask.println("#include \"runtime_arch.h\"");
+ outtask.println("#include \"runtime_arch.h\"");
//outtask.println("#ifdef RAW");
//outtask.println("#include <raw.h>");
//outtask.println("#endif");
output.println();
}
- protected void generateTaskMethod(FlatMethod fm,
- PrintWriter output) {
+ protected void generateTaskMethod(FlatMethod fm,
+ PrintWriter output) {
/*if (State.PRINTFLAT)
System.out.println(fm.printMethod());*/
TaskDescriptor task=fm.getTask();
if (type.isNull())
output.println(" void * "+td.getSafeSymbol()+";");
else if (state.MGC && type.isClass() && type.getClassDesc().isEnum()) {
- output.println(" int " + td.getSafeSymbol()+";");
+ output.println(" int " + td.getSafeSymbol()+";");
} else if (type.isClass()||type.isArray())
output.println(" struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
else
/* generate print information for RAW version */
output.println("#ifdef MULTICORE");
- if(this.state.RAW) {
- output.println("{");
- output.println("int tmpsum = 0;");
- output.println("char * taskname = \"" + task.getSymbol() + "\";");
- output.println("int tmplen = " + task.getSymbol().length() + ";");
- output.println("int tmpindex = 1;");
- output.println("for(;tmpindex < tmplen; tmpindex++) {");
- output.println(" tmpsum = tmpsum * 10 + *(taskname + tmpindex) - '0';");
- output.println("}");
- }
+ if(this.state.RAW) {
+ output.println("{");
+ output.println("int tmpsum = 0;");
+ output.println("char * taskname = \"" + task.getSymbol() + "\";");
+ output.println("int tmplen = " + task.getSymbol().length() + ";");
+ output.println("int tmpindex = 1;");
+ output.println("for(;tmpindex < tmplen; tmpindex++) {");
+ output.println(" tmpsum = tmpsum * 10 + *(taskname + tmpindex) - '0';");
+ output.println("}");
+ }
output.println("#ifdef RAWPATH");
- if(this.state.RAW) {
- output.println("BAMBOO_DEBUGPRINT(0xAAAA);");
- output.println("BAMBOO_DEBUGPRINT_REG(tmpsum);");
- } else {
- //output.println("BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();");
- output.println("printf(\"(%x,%x) Process %x(%d): task %s\\n\", udn_tile_coord_x(), udn_tile_coord_y(), corenum, corenum, \"" + task.getSymbol() + "\");");
- //output.println("BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();");
- }
- //output.println("BAMBOO_DEBUGPRINT(BAMBOO_GET_EXE_TIME());");
+ if(this.state.RAW) {
+ output.println("BAMBOO_DEBUGPRINT(0xAAAA);");
+ output.println("BAMBOO_DEBUGPRINT_REG(tmpsum);");
+ } else {
+ //output.println("BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();");
+ output.println("printf(\"(%x,%x) Process %x(%d): task %s\\n\", udn_tile_coord_x(), udn_tile_coord_y(), corenum, corenum, \"" + task.getSymbol() + "\");");
+ //output.println("BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();");
+ }
+ //output.println("BAMBOO_DEBUGPRINT(BAMBOO_GET_EXE_TIME());");
output.println("#endif");
output.println("#ifdef DEBUG");
- if(this.state.RAW) {
- output.println("BAMBOO_DEBUGPRINT(0xAAAA);");
- output.println("BAMBOO_DEBUGPRINT_REG(tmpsum);");
- } else {
- //output.println("BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();");
- output.println("printf(\"(%x,%x) Process %x(%d): task %s\\n\", udn_tile_coord_x(), udn_tile_coord_y(), corenum, corenum, \"" + task.getSymbol() + "\");");
- //output.println("BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();");
- }
+ if(this.state.RAW) {
+ output.println("BAMBOO_DEBUGPRINT(0xAAAA);");
+ output.println("BAMBOO_DEBUGPRINT_REG(tmpsum);");
+ } else {
+ //output.println("BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();");
+ output.println("printf(\"(%x,%x) Process %x(%d): task %s\\n\", udn_tile_coord_x(), udn_tile_coord_y(), corenum, corenum, \"" + task.getSymbol() + "\");");
+ //output.println("BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();");
+ }
+ output.println("#endif");
+ if(this.state.RAW) {
+ output.println("}");
+ }
output.println("#endif");
- if(this.state.RAW) {
- output.println("}");
- }
- output.println("#endif");
for(int i = 0; i < fm.numParameters(); ++i) {
TempDescriptor temp = fm.getParameter(i);
}
/** This method outputs TaskDescriptor information */
- protected void generateTaskDescriptor(PrintWriter output,
- PrintWriter outtask,
- FlatMethod fm,
- TaskDescriptor task,
- Vector[] qnames) {
+ protected void generateTaskDescriptor(PrintWriter output,
+ PrintWriter outtask,
+ FlatMethod fm,
+ TaskDescriptor task,
+ Vector[] qnames) {
int num = this.currentSchedule.getCoreNum();
output.println("/* TaskDescriptor information for task " + task.getSymbol() + " on core " + num + "*/");
/** This method generates header information for the task
* referenced by the Descriptor des. */
- protected void generateTaskHeader(FlatMethod fm,
- Descriptor des,
- PrintWriter output) {
+ protected void generateTaskHeader(FlatMethod fm,
+ Descriptor des,
+ PrintWriter output) {
/* Print header */
ParamsObject objectparams=(ParamsObject)paramstable.get(des);
TaskDescriptor task=(TaskDescriptor) des;
} else output.println(") {");
}
- protected void generateFlagOrAnd(FlatFlagActionNode ffan,
- FlatMethod fm,
- TempDescriptor temp,
- PrintWriter output,
- int ormask,
+ protected void generateFlagOrAnd(FlatFlagActionNode ffan,
+ FlatMethod fm,
+ TempDescriptor temp,
+ PrintWriter output,
+ int ormask,
int andmask) {
if (ffan.getTaskType()==FlatFlagActionNode.NEWOBJECT) {
output.println("flagorandinit("+generateTemp(fm, temp)+", 0x"+Integer.toHexString(ormask)+", 0x"+Integer.toHexString(andmask)+");");
output.println("}");
}
if(ffan.getTaskType()==FlatFlagActionNode.TASKEXIT) {
- // generate codes for profiling, recording which task exit it is
- output.println("#ifdef PROFILE");
- output.println("setTaskExitIndex(" + ffan.getTaskExitIndex() + ");");
- output.println("#endif");
+ // generate codes for profiling, recording which task exit it is
+ output.println("#ifdef PROFILE");
+ output.println("setTaskExitIndex(" + ffan.getTaskExitIndex() + ");");
+ output.println("#endif");
}
}
}
- protected void generateObjectDistribute(FlatFlagActionNode ffan,
- FlatMethod fm,
- TempDescriptor temp,
+ protected void generateObjectDistribute(FlatFlagActionNode ffan,
+ FlatMethod fm,
+ TempDescriptor temp,
PrintWriter output) {
ClassDescriptor cd = temp.getType().getClassDesc();
Vector<FlagState> initfstates = null;
", " + qinfo.length + ");");
output.println("}");
} /*else {
- // TODO
- // really needed?
- output.println("/* possibly needed by multi-parameter tasks on this core*//*");
- output.println("enqueueObject("+generateTemp(fm, temp)+", NULL, 0);");
- }*/ // deleted 09/07/06, multi-param tasks are pinned to one core now
+ // TODO
+ // really needed?
+ output.println("/* possibly needed by multi-parameter tasks on this core*//*");
+ output.println("enqueueObject("+generateTemp(fm, temp)+", NULL, 0);");
+ }*/ // deleted 09/07/06, multi-param tasks are pinned to one core now
} else {
/*if(!isolate) {
- // TODO
- // Is it possible to decide the actual queues?
- output.println("/* possibly needed by multi-parameter tasks on this core*//*");
- output.println("enqueueObject("+generateTemp(fm, temp)+", NULL, 0);");
- }*/ // deleted 09/07/06, multi-param tasks are pinned to one core now
+ // TODO
+ // Is it possible to decide the actual queues?
+ output.println("/* possibly needed by multi-parameter tasks on this core*//*");
+ output.println("enqueueObject("+generateTemp(fm, temp)+", NULL, 0);");
+ }*/ // deleted 09/07/06, multi-param tasks are pinned to one core now
output.println("/* transfer to core " + targetcore.toString() + "*/");
output.println("{");
// enqueue this object and its destinations for later process
} else {
tmpinfo.fs = tmpFState;
}
- qinfo = outputtransqueues(tmpinfo.fs, targetcore, output);
- output.println("tmpObjInfo = RUNMALLOC(sizeof(struct transObjInfo));");
- output.println("tmpObjInfo->objptr = (void *)" + tmpinfo.name + ";");
- output.println("tmpObjInfo->targetcore = "+targetcore.toString()+";");
- output.println("tmpObjInfo->queues = " + qinfo.qname + ";");
- output.println("tmpObjInfo->length = " + qinfo.length + ";");
- output.println("addNewItem(totransobjqueue, (void*)tmpObjInfo);");
+ qinfo = outputtransqueues(tmpinfo.fs, targetcore, output);
+ output.println("tmpObjInfo = RUNMALLOC(sizeof(struct transObjInfo));");
+ output.println("tmpObjInfo->objptr = (void *)" + tmpinfo.name + ";");
+ output.println("tmpObjInfo->targetcore = "+targetcore.toString()+";");
+ output.println("tmpObjInfo->queues = " + qinfo.qname + ";");
+ output.println("tmpObjInfo->length = " + qinfo.length + ";");
+ output.println("addNewItem(totransobjqueue, (void*)tmpObjInfo);");
output.println("}");
}
output.println("break;");
output.println("}");
} else {
/*if(!isolate) {
- // TODO
- // Is it possible to decide the actual queues?
- output.println("/* possibly needed by multi-parameter tasks on this core*//*");
- output.println("enqueueObject("+generateTemp(fm, temp)+", NULL, 0);");
- }*/ // deleted 09/07/06, multi-param tasks are pinned to one core now
+ // TODO
+ // Is it possible to decide the actual queues?
+ output.println("/* possibly needed by multi-parameter tasks on this core*//*");
+ output.println("enqueueObject("+generateTemp(fm, temp)+", NULL, 0);");
+ }*/ // deleted 09/07/06, multi-param tasks are pinned to one core now
output.println("/* transfer to core " + targetcore.toString() + "*/");
output.println("{");
// enqueue this object and its destinations for later process
} else {
tmpinfo.fs = tmpFState;
}
- qinfo = outputtransqueues(tmpinfo.fs, targetcore, output);
- output.println("tmpObjInfo = RUNMALLOC(sizeof(struct transObjInfo));");
- output.println("tmpObjInfo->objptr = (void *)" + tmpinfo.name + ";");
- output.println("tmpObjInfo->targetcore = "+targetcore.toString()+";");
- output.println("tmpObjInfo->queues = " + qinfo.qname + ";");
- output.println("tmpObjInfo->length = " + qinfo.length + ";");
- output.println("addNewItem(totransobjqueue, (void*)tmpObjInfo);");
+ qinfo = outputtransqueues(tmpinfo.fs, targetcore, output);
+ output.println("tmpObjInfo = RUNMALLOC(sizeof(struct transObjInfo));");
+ output.println("tmpObjInfo->objptr = (void *)" + tmpinfo.name + ";");
+ output.println("tmpObjInfo->targetcore = "+targetcore.toString()+";");
+ output.println("tmpObjInfo->queues = " + qinfo.qname + ";");
+ output.println("tmpObjInfo->length = " + qinfo.length + ";");
+ output.println("addNewItem(totransobjqueue, (void*)tmpObjInfo);");
output.println("}");
}
output.println("/* increase index*/");
", " + qinfo.length + ");");
output.println("}");
} /*else {
- // TODO
- // really needed?
- output.println("enqueueObject("+generateTemp(fm, temp)+", NULL, 0);");
- }*/ // deleted 09/07/06, multi-param tasks are pinned to one core now
+ // TODO
+ // really needed?
+ output.println("enqueueObject("+generateTemp(fm, temp)+", NULL, 0);");
+ }*/ // deleted 09/07/06, multi-param tasks are pinned to one core now
}
// codes for multi-params tasks
// need to be send to other cores
Vector<Integer> targetcores = this.currentSchedule.getAllyCores(tmpFState);
output.println("/* send the shared object to possible queues on other cores*/");
- // TODO, temporary solution, send to mostly the first two
- int upperbound = targetcores.size() > 2? 2: targetcores.size();
+ // TODO, temporary solution, send to mostly the first two
+ int upperbound = targetcores.size() > 2?2:targetcores.size();
for(int k = 0; k < upperbound; ++k) {
// TODO
// add the information of exactly which queue
int targetcore = targetcores.elementAt(k).intValue();
if(!sendto.contains(targetcore)) {
- // previously not sended to this target core
- // enqueue this object and its destinations for later process
- output.println("{");
- // all the possible queues
- QueueInfo qinfo = null;
- TranObjInfo tmpinfo = new TranObjInfo();
- tmpinfo.name = generateTemp(fm, temp);
- tmpinfo.targetcore = targetcore;
- FlagState targetFS = this.currentSchedule.getTargetFState(tmpFState);
- if(targetFS != null) {
- tmpinfo.fs = targetFS;
- } else {
- tmpinfo.fs = tmpFState;
- }
+ // previously not sended to this target core
+ // enqueue this object and its destinations for later process
+ output.println("{");
+ // all the possible queues
+ QueueInfo qinfo = null;
+ TranObjInfo tmpinfo = new TranObjInfo();
+ tmpinfo.name = generateTemp(fm, temp);
+ tmpinfo.targetcore = targetcore;
+ FlagState targetFS = this.currentSchedule.getTargetFState(tmpFState);
+ if(targetFS != null) {
+ tmpinfo.fs = targetFS;
+ } else {
+ tmpinfo.fs = tmpFState;
+ }
qinfo = outputtransqueues(tmpinfo.fs, targetcore, output);
output.println("tmpObjInfo = RUNMALLOC(sizeof(struct transObjInfo));");
output.println("tmpObjInfo->objptr = (void *)" + tmpinfo.name + ";");
}
}
- protected QueueInfo outputqueues(FlagState tmpFState,
- int num,
- PrintWriter output,
- boolean isEnqueue) {
+ protected QueueInfo outputqueues(FlagState tmpFState,
+ int num,
+ PrintWriter output,
+ boolean isEnqueue) {
// queue array
QueueInfo qinfo = new QueueInfo();
qinfo.qname = "queues_" + tmpFState.getLabel() + "_" + tmpFState.getiuid();
return qinfo;
}
- protected QueueInfo outputtransqueues(FlagState tmpFState,
- int targetcore,
- PrintWriter output) {
+ protected QueueInfo outputtransqueues(FlagState tmpFState,
+ int targetcore,
+ PrintWriter output) {
// queue array
QueueInfo qinfo = new QueueInfo();
qinfo.qname = "queues_" + tmpFState.getLabel() + "_" + tmpFState.getiuid();
public String qname;
}
- protected String generateTempFlagName(FlatMethod fm,
- TempDescriptor td) {
+ protected String generateTempFlagName(FlatMethod fm,
+ TempDescriptor td) {
MethodDescriptor md=fm.getMethod();
TaskDescriptor task=fm.getTask();
- TempObject objecttemps=(TempObject) tempstable.get(md!=null ? md : task);
+ TempObject objecttemps=(TempObject) tempstable.get(md!=null?md:task);
if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
return td.getSafeSymbol() + "_oldflag";
//output.println("freeQueue(totransobjqueue);");
}
- protected void outputAliasLockCode(FlatMethod fm,
- PrintWriter output) {
+ protected void outputAliasLockCode(FlatMethod fm,
+ PrintWriter output) {
if(this.m_oa == null) {
return;
}
for( int j = i + 1; j < fm.numParameters(); ++j ) {
common = this.m_oa.createsPotentialAliases(td, i, j);
if(!common.isEmpty()) {
- // ith parameter and jth parameter has alias, create lock to protect them
+ // ith parameter and jth parameter has alias, create lock to protect them
if(aliasSets.elementAt(i) == null) {
aliasSets.setElementAt(new Vector<Integer>(), i);
}
AllocationSite as = (AllocationSite)allocSites[j];
common = this.m_oa.createsPotentialAliases(td, i, as);
if( !common.isEmpty() ) {
- // ith parameter and allocationsite as has alias
+ // ith parameter and allocationsite as has alias
if(aliasFNSets.elementAt(i) == null) {
aliasFNSets.setElementAt(new Vector<FlatNew>(), i);
}
common = this.m_oa.createsPotentialAliases(td, as1, as2);
if( !common.isEmpty() ) {
- // as1 and as2 has alias
+ // as1 and as2 has alias
if(!aliasFNTbl.containsKey(as1.getFlatNew())) {
aliasFNTbl.put(as1.getFlatNew(), new Vector<FlatNew>());
}
// create locks
if(numlock > 0) {
output.println("int aliaslocks[" + numlock + "];");
- output.println("int tmpi = 0;");
+ output.println("int tmpi = 0;");
// associate locks with parameters
int lockindex = 0;
for(int i = 0; i < this.m_aliasSets.size(); i++) {
- Vector<Integer> toadd = this.m_aliasSets.elementAt(i);
-
- output.println("int tmplen_" + lockindex + " = " + toadd.size());
- output.println("void * tmpptrs_" + lockindex + "[] = {");
- for(int j = 0; j < toadd.size(); j++) {
- int para = toadd.elementAt(j).intValue();
- output.print(generateTemp(fm, fm.getParameter(para)));
- if(j < toadd.size() - 1) {
- output.print(", ");
- } else {
- output.println("};");
- }
- }
- output.println("aliaslocks[tmpi++] = getAliasLock(tmpptrs_" + lockindex + ", tmplen_" + lockindex + ", lockRedirectTbl);");
-
- for(int j = 0; j < toadd.size(); j++) {
- int para = toadd.elementAt(j).intValue();
- output.println("addAliasLock(" + generateTemp(fm, fm.getParameter(para)) + ", aliaslocks[" + i + "]);");
- }
- // check if this lock is also associated with any FlatNew nodes
- if(this.m_aliasFNTbl4Para.containsKey(toadd.elementAt(0))) {
- if(this.m_aliaslocksTbl4FN == null) {
- this.m_aliaslocksTbl4FN = new Hashtable<FlatNew, Vector<Integer>>();
- }
- Vector<FlatNew> tmpv = this.m_aliasFNTbl4Para.get(toadd.elementAt(0));
- for(int j = 0; j < tmpv.size(); j++) {
- FlatNew fn = tmpv.elementAt(j);
- if(!this.m_aliaslocksTbl4FN.containsKey(fn)) {
- this.m_aliaslocksTbl4FN.put(fn, new Vector<Integer>());
- }
- this.m_aliaslocksTbl4FN.get(fn).add(i);
- }
- this.m_aliasFNTbl4Para.remove(toadd.elementAt(0));
- }
- lockindex++;
+ Vector<Integer> toadd = this.m_aliasSets.elementAt(i);
+
+ output.println("int tmplen_" + lockindex + " = " + toadd.size());
+ output.println("void * tmpptrs_" + lockindex + "[] = {");
+ for(int j = 0; j < toadd.size(); j++) {
+ int para = toadd.elementAt(j).intValue();
+ output.print(generateTemp(fm, fm.getParameter(para)));
+ if(j < toadd.size() - 1) {
+ output.print(", ");
+ } else {
+ output.println("};");
+ }
+ }
+ output.println("aliaslocks[tmpi++] = getAliasLock(tmpptrs_" + lockindex + ", tmplen_" + lockindex + ", lockRedirectTbl);");
+
+ for(int j = 0; j < toadd.size(); j++) {
+ int para = toadd.elementAt(j).intValue();
+ output.println("addAliasLock(" + generateTemp(fm, fm.getParameter(para)) + ", aliaslocks[" + i + "]);");
+ }
+ // check if this lock is also associated with any FlatNew nodes
+ if(this.m_aliasFNTbl4Para.containsKey(toadd.elementAt(0))) {
+ if(this.m_aliaslocksTbl4FN == null) {
+ this.m_aliaslocksTbl4FN = new Hashtable<FlatNew, Vector<Integer>>();
+ }
+ Vector<FlatNew> tmpv = this.m_aliasFNTbl4Para.get(toadd.elementAt(0));
+ for(int j = 0; j < tmpv.size(); j++) {
+ FlatNew fn = tmpv.elementAt(j);
+ if(!this.m_aliaslocksTbl4FN.containsKey(fn)) {
+ this.m_aliaslocksTbl4FN.put(fn, new Vector<Integer>());
+ }
+ this.m_aliaslocksTbl4FN.get(fn).add(i);
+ }
+ this.m_aliasFNTbl4Para.remove(toadd.elementAt(0));
+ }
+ lockindex++;
}
-
+
Object[] key = this.m_aliasFNTbl4Para.keySet().toArray();
for(int i = 0; i < key.length; i++) {
int para = ((Integer)key[i]).intValue();
output.println("void * tmpptrs_" + lockindex + "[] = {" + generateTemp(fm, fm.getParameter(para)) + "};");
output.println("aliaslocks[tmpi++] = getAliasLock(tmpptrs_" + lockindex + ", 1, lockRedirectTbl);");
-
+
output.println("addAliasLock(" + generateTemp(fm, fm.getParameter(para)) + ", aliaslocks[" + lockindex + "]);");
Vector<FlatNew> tmpv = this.m_aliasFNTbl4Para.get(para);
for(int j = 0; j < tmpv.size(); j++) {
}
lockindex++;
}
-
+
// check m_aliasFNTbl for locks associated with FlatNew nodes
Object[] FNkey = this.m_aliasFNTbl.keySet().toArray();
for(int i = 0; i < FNkey.length; i++) {
FlatNew fn = (FlatNew)FNkey[i];
Vector<FlatNew> tmpv = this.m_aliasFNTbl.get(fn);
-
+
output.println("aliaslocks[tmpi++] = (int)(RUNMALLOC(sizeof(int)));");
-
+
if(this.m_aliaslocksTbl4FN == null) {
this.m_aliaslocksTbl4FN = new Hashtable<FlatNew, Vector<Integer>>();
}
}
}
- protected void generateFlatReturnNode(FlatMethod fm,
- FlatReturnNode frn,
- PrintWriter output) {
+ protected void generateFlatReturnNode(FlatMethod fm,
+ 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())+";");
}
}
- protected void generateFlatNew(FlatMethod fm,
- FlatNew fn,
+ protected void generateFlatNew(FlatMethod fm,
+ FlatNew fn,
PrintWriter output) {
if (fn.getType().isArray()) {
int arrayid = state.getArrayNumber(fn.getType())
}
}
// generate codes for profiling, recording how many new objects are created
- if(!fn.getType().isArray() &&
- (fn.getType().getClassDesc() != null)
- && (fn.getType().getClassDesc().hasFlags())) {
- output.println("#ifdef PROFILE");
- output.println("addNewObjInfo(\"" + fn.getType().getClassDesc().getSymbol() + "\");");
- output.println("#endif");
+ if(!fn.getType().isArray() &&
+ (fn.getType().getClassDesc() != null)
+ && (fn.getType().getClassDesc().hasFlags())) {
+ output.println("#ifdef PROFILE");
+ output.println("addNewObjInfo(\"" + fn.getType().getClassDesc().getSymbol() + "\");");
+ output.println("#endif");
}
}
public FlagState fs;
}
- protected boolean contains(Vector<TranObjInfo> sendto,
- TranObjInfo t) {
+ protected boolean contains(Vector<TranObjInfo> sendto,
+ TranObjInfo t) {
if(sendto.size() == 0) {
return false;
}
projects / IRC.git / blobdiff