outstructs=new PrintWriter(new FileOutputStream(PREFIX+"structdefs.h"), true);
outmethodheader=new PrintWriter(new FileOutputStream(PREFIX+"methodheaders.h"), true);
outclassdefs=new PrintWriter(new FileOutputStream(PREFIX+"classdefs.h"), true);
+ if(state.MGC) {
+ // TODO add version for normal Java later
outglobaldefs=new PrintWriter(new FileOutputStream(PREFIX+"globaldefs.h"), true);
+ }
outmethod=new PrintWriter(new FileOutputStream(PREFIX+"methods.c"), true);
outvirtual=new PrintWriter(new FileOutputStream(PREFIX+"virtualtable.h"), true);
if (state.TASK) {
// Output the C class declarations
// These could mutually reference each other
+ if(state.MGC) {
+ // TODO add version for normal Java later
outglobaldefs.println("#ifndef __GLOBALDEF_H_");
outglobaldefs.println("#define __GLOBALDEF_H_");
outglobaldefs.println("");
outglobaldefs.println("struct global_defs_t {");
+ }
outclassdefs.println("#ifndef __CLASSDEF_H_");
outclassdefs.println("#define __CLASSDEF_H_");
}
outclassdefs.println("#endif");
outclassdefs.close();
+ if(state.MGC) {
+ // TODO add version for normal Java later
outglobaldefs.println("};");
outglobaldefs.println("");
outglobaldefs.println("extern struct global_defs_t * global_defs_p;");
outglobaldefs.println("#endif");
outglobaldefs.flush();
outglobaldefs.close();
+ }
if (state.TASK) {
/* Map flags to integers */
* invoked inside static blocks
*/
protected void tagMethodInvokedByStaticBlock() {
- Iterator it_sclasses = this.state.getSClassSymbolTable().getDescriptorsIterator();
- MethodDescriptor current_md=null;
- HashSet tovisit=new HashSet();
- HashSet visited=new HashSet();
-
- while(it_sclasses.hasNext()) {
- ClassDescriptor cd = (ClassDescriptor)it_sclasses.next();
- MethodDescriptor md = (MethodDescriptor)cd.getMethodTable().get("staticblocks");
- tovisit.add(md);
- }
-
- while(!tovisit.isEmpty()) {
- current_md=(MethodDescriptor)tovisit.iterator().next();
- tovisit.remove(current_md);
- visited.add(current_md);
- Iterator it_callee = this.callgraph.getCalleeSet(current_md).iterator();
- while(it_callee.hasNext()) {
- Descriptor d = (Descriptor)it_callee.next();
- if(d instanceof MethodDescriptor) {
- if(!visited.contains(d)) {
- ((MethodDescriptor)d).setIsInvokedByStatic(true);
- tovisit.add(d);
+ if(state.MGC) {
+ Iterator it_sclasses = this.state.getSClassSymbolTable().getDescriptorsIterator();
+ MethodDescriptor current_md=null;
+ HashSet tovisit=new HashSet();
+ HashSet visited=new HashSet();
+
+ while(it_sclasses.hasNext()) {
+ ClassDescriptor cd = (ClassDescriptor)it_sclasses.next();
+ MethodDescriptor md = (MethodDescriptor)cd.getMethodTable().get("staticblocks");
+ tovisit.add(md);
+ }
+
+ while(!tovisit.isEmpty()) {
+ current_md=(MethodDescriptor)tovisit.iterator().next();
+ tovisit.remove(current_md);
+ visited.add(current_md);
+ Iterator it_callee = this.callgraph.getCalleeSet(current_md).iterator();
+ while(it_callee.hasNext()) {
+ Descriptor d = (Descriptor)it_callee.next();
+ if(d instanceof MethodDescriptor) {
+ if(!visited.contains(d)) {
+ ((MethodDescriptor)d).setIsInvokedByStatic(true);
+ tovisit.add(d);
+ }
}
}
}
- }
+ } // TODO for normal Java version
}
/* This code generates code for each static block and static field
// execute all the static blocks and all the static field initializations
// TODO
}
+
+ /* This code generates code to create a Class object for each class for
+ * getClass() method.
+ * */
+ protected void outputClassObjects(PrintWriter outmethod) {
+ // for each class, initialize its Class object
+ if(state.MGC) {
+ SymbolTable ctbl = this.state.getClassSymbolTable();
+ Iterator it_classes = ctbl.getDescriptorsIterator();
+ while(it_classes.hasNext()) {
+ ClassDescriptor t_cd = (ClassDescriptor)it_classes.next();
+ outmethod.println(" {");
+ outmethod.println(" global_defs_p->"+t_cd.getSafeSymbol()+"classobj.type="+t_cd.getId()+";");
+ outmethod.println(" initlock((struct ___Object___ *)(&(global_defs_p->"+t_cd.getSafeSymbol()+"classobj)));");
+ outmethod.println(" }");
+ }
+ } // else TODO normal java version
+ }
/* This code just generates the main C method for java programs.
* The main C method packs up the arguments into a string array
outmethod.println(" int i;");
outputStaticBlocks(outmethod);
+ outputClassObjects(outmethod);
if (state.MLP || state.OOOJAVA) {
outmethod.println("#include \"runtime_arch.h\"");
}
if (state.THREAD||state.DSM||state.SINGLETM) {
- if(state.MGC) {
- outmethod.println("#include \"thread.h\"");
- } else {
- outmethod.println("#include <thread.h>");
- }
+ outmethod.println("#include <thread.h>");
}
+ if(state.MGC) {
+ outmethod.println("#include \"thread.h\"");
+ }
if (state.main!=null) {
outmethod.println("#include <string.h>");
}
}
}
+ if(state.MGC) {
+ // TODO add version for normal Java later
outmethod.println("struct global_defs_t * global_defs_p;");
+ }
//Store the sizes of classes & array elements
generateSizeArray(outmethod);
while(it.hasNext()) {
ClassDescriptor cn=(ClassDescriptor)it.next();
outclassdefs.println("struct "+cn.getSafeSymbol()+";");
+
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
+ // this class has static fields/blocks, need to add a global flag to
+ // indicate if its static fields have been initialized and/or if its
+ // static blocks have been executed
+ outglobaldefs.println(" int "+cn.getSafeSymbol()+"static_block_exe_flag;");
+ }
+
+ // for each class, create a global object
+ outglobaldefs.println(" struct Class "+cn.getSafeSymbol()+"classobj;");
+ }
}
outclassdefs.println("");
//Print out definition for array type
outclassdefs.println(" int ___length___;");
outclassdefs.println("};\n");
+
+ if(state.MGC) {
+ // TODO add version for normal Java later
+ outclassdefs.println("");
+ //Print out definition for Class type
+ outclassdefs.println("struct Class {");
+ outclassdefs.println(" int type;");
+ if(state.MLP || state.OOOJAVA ){
+ outclassdefs.println(" int oid;");
+ outclassdefs.println(" int allocsite;");
+ }
+ if (state.EVENTMONITOR) {
+ outclassdefs.println(" int objuid;");
+ }
+ if (state.THREAD) {
+ outclassdefs.println(" pthread_t tid;");
+ outclassdefs.println(" void * lockentry;");
+ outclassdefs.println(" int lockcount;");
+ }
+ if(state.MGC) {
+ outclassdefs.println(" int mutex;");
+ outclassdefs.println(" int objlock;");
+ if(state.MULTICOREGC) {
+ outclassdefs.println(" int marked;");
+ }
+ }
+ if (state.TASK) {
+ outclassdefs.println(" int flag;");
+ if(!state.MULTICORE) {
+ outclassdefs.println(" void * flagptr;");
+ } else {
+ outclassdefs.println(" int version;");
+ outclassdefs.println(" int * lock;"); // lock entry for this obj
+ outclassdefs.println(" int mutex;");
+ outclassdefs.println(" int lockcount;");
+ if(state.MULTICOREGC) {
+ outclassdefs.println(" int marked;");
+ }
+ }
+ if(state.OPTIONAL) {
+ outclassdefs.println(" int numfses;");
+ outclassdefs.println(" int * fses;");
+ }
+ }
+ printClassStruct(typeutil.getClass(TypeUtil.ObjectClass), outclassdefs, outglobaldefs);
+ outclassdefs.println("};\n");
+ }
+
+ outclassdefs.println("");
outclassdefs.println("extern int classsize[];");
outclassdefs.println("extern int hasflags[];");
outclassdefs.println("extern unsigned INTPTR * pointerarray[];");
outclassdefs.println("extern int supertypes[];");
+ if(state.MGC) {
+ // TODO add version for normal Java later
outclassdefs.println("#include \"globaldefs.h\"");
+ }
outclassdefs.println("");
}
}
}
Vector fields=(Vector)fieldorder.get(cn);
-
- if((cn.getNumStaticFields() != 0) || (cn.getNumStaticBlocks() != 0)) {
- // this class has static fields/blocks, need to add a global flag to
- // indicate if its static fields have been initialized and/or if its
- // static blocks have been executed
- globaldefout.println(" int "+cn.getSafeSymbol()+"static_block_exe_flag;");
- }
for(int i=0; i<fields.size(); i++) {
FieldDescriptor fd=(FieldDescriptor)fields.get(i);
if (fd.getType().isClass()||fd.getType().isArray())
classdefout.println(" struct "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
- else if(fd.isStatic()) {
+ else if ((state.MGC) && (fd.isStatic())) {
+ // TODO add version for normal Java later
// static field
globaldefout.println(" "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
classdefout.println(" "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
}
}
+ if(state.MGC) {
+ // TODO add version for normal Java later
if(fm.getMethod().isStaticBlock()) {
// a static block, check if it has been executed
output.println(" if(global_defs_p->" + cn.getSafeSymbol()+"static_block_exe_flag != 0) {");
}
}
}
+ }
generateCode(fm.getNext(0), fm, lb, null, output, true);
assert fsxn.getFlatEnter().equals( fsen );
}
if (current_node.kind()!=FKind.FlatReturnNode) {
+ if(state.MGC) {
+ // TODO add version for normal Java later
if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
// a static block, check if it has been executed
output.println(" global_defs_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
output.println("");
+ }
}
output.println(" return;");
}
Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(currentSESE);
if(graph!=null){
Set<Analysis.OoOJava.SESELock> seseLockSet = oooa.getLockMappings(graph);
- Set<Analysis.OoOJava.WaitingElement> waitingElementSet =
- graph.getStallSiteWaitingElementSet(fn, seseLockSet);
+ Set<Analysis.OoOJava.WaitingElement> waitingElementSet = graph.getStallSiteWaitingElementSet(fn, seseLockSet);
if(waitingElementSet.size()>0){
output.println("// stall on parent's stall sites ");
output.println(" rentry=mlpCreateFineREntry("+ waitingElement.getStatus()+ ", runningSESE, (void*)&" +generateTemp(fm,waitingElement.getTempDesc(),lb)+ ");");
}
output.println(" psem_init( &(rentry->parentStallSem) );");
+ output.println(" rentry->tag=rentry->parentStallSem.tag;");
output.println(" rentry->queue=runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "];");
- output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()
- + "],rentry)==NOTREADY){");
+ output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "],rentry)==NOTREADY){");
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_BEGIN );");
output.println("#endif");
}
- output.println(" psem_take( &(rentry->parentStallSem), (struct garbagelist *)&___locals___ );");
+ if(state.RCR) {
+ //no need to enqueue parent effect if coarse grained conflict clears us
+ output.println(" while(stallrecord.common.rcrstatus) ;");
+ output.println(" BARRIER();");
+ output.println(" stallrecord.common.parentsStallSem=&rentry->parentStallSem;");
+ output.println(" stallrecord.tag=rentry->tag;");
+ output.println(" stallrecord.___obj___=(struct ___Object___ *)"+generateTemp(fm, waitingElement.getTempDesc(), null)+";");
+ output.println(" stallrecord.common.classID=-"+rcr.getTraverserID(waitingElement.getTempDesc(), fn)+";");
+ //mark the record used..so we won't use it again until it is free
+ output.println(" stallrecord.common.rcrstatus=1;");
+ output.println(" enqueueTR(TRqueue, (void *)&stallrecord);");
+ }
+ output.println(" psem_take( &(rentry->parentStallSem), (struct garbagelist *)&___locals___ );");
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_END );");
output.println("#endif");
}
output.println(" } ");
-
- if(state.RCR) {
- output.println(" "+rcr.getTraverserInvocation(waitingElement.getTempDesc(),
- generateTemp(fm, waitingElement.getTempDesc(), null), fn));
- }
}
output.println(" }");
}
if( waitingElement.getStatus() >= ConflictNode.COARSE ){
// HERE! a parent might conflict with a child
output.println(" rentry=mlpCreateREntry("+ waitingElement.getStatus()+ ", runningSESE);");
- }else{
+ } else {
output.println(" rentry=mlpCreateFineREntry("+ waitingElement.getStatus()+ ", runningSESE, (void*)&___locals___."+ waitingElement.getDynID() + ");");
}
- output.println(" psem_init( &(rentry->parentStallSem) );");
+ output.println(" psem_init(&(rentry->parentStallSem));");
+ output.println(" rentry->tag=rentry->parentStallSem->tag;");
output.println(" rentry->queue=runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "];");
- output
- .println(" if(ADDRENTRY(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()
- + "],rentry)==NOTREADY){");
+ output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+"],rentry)==NOTREADY) {");
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_TASKSTALLMEM");
output.println(" CP_LOGEVENT( CP_EVENTID_TASKSTALLMEM, CP_EVENTTYPE_BEGIN );");
output.println(" struct garbagelist * gl= (struct garbagelist *)&(((SESEcommon*)(seseToIssue))[1]);");
output.println(" gl->size="+calculateSizeOfSESEParamList(fsen)+";");
output.println(" gl->next = NULL;");
+
+ if(state.RCR) {
+ //flag the SESE status as 1...it will be reset
+ output.println(" seseToIssue->common.rcrstatus=1;");
+ }
// there are pointers to SESE records the newly-issued SESE
// will use to get values it depends on them for--how many
output.println(" seseToIssue->common.rentryIdx=0;");
output.println(" int dispCount;");
Vector<TempDescriptor> invars=fsen.getInVarsForDynamicCoarseConflictResolution();
+ System.out.println(fm.getMethod()+"["+invars+"]");
for(int i=0;i<invars.size();i++) {
TempDescriptor td=invars.get(i);
Set<Analysis.OoOJava.WaitingElement> weset=seseWaitingQueue.getWaitingElementSet(td);
+ if (weset==null)
+ System.out.println("ERROR:"+td+" "+fsen+" "+fm.getMethod());
int numqueues=weset.size();
output.println(" seseToIssue->rcrRecords["+i+"].flag="+numqueues+";");
output.println(" dispCount=0;");
// eom
// clean up its lock element from waiting queue, and decrement dependency count for next SESE block
- if( (state.MLP && fsen != mlpa.getMainSESE()) ||
- (state.OOOJAVA && fsen != oooa.getMainSESE())
- ) {
-
- output.println();
- output.println(" /* check memory dependency*/");
- output.println(" {");
- output.println(" int idx;");
- output.println(" for(idx=0;idx<___params___->common.rentryIdx;idx++){");
- output.println(" REntry* re=___params___->common.rentryArray[idx];");
- output.println(" RETIRERENTRY(re->queue,re);");
- output.println(" }");
- output.println(" }");
-
+ if((state.MLP && fsen != mlpa.getMainSESE()) ||
+ (state.OOOJAVA && fsen != oooa.getMainSESE())) {
+ output.println();
+ output.println(" /* check memory dependency*/");
+ output.println(" {");
+ output.println(" int idx;");
+ output.println(" for(idx=0;idx<___params___->common.rentryIdx;idx++){");
+ output.println(" REntry* re=___params___->common.rentryArray[idx];");
+ output.println(" RETIRERENTRY(re->queue,re);");
+ output.println(" }");
+ output.println(" }");
}
if (state.RCR&&fsen.getDynamicInVarSet().size()>0) {
+ /* Make sure the running SESE is finished */
+ output.println(" if (unlikely(runningSESE->rcrstatus!=0)) {");
+ output.println(" if(!CAS(&runningSESE->rcrstatus,1,0)) {");
+ output.println(" while(runningSESE->rcrstatus) {");
+ output.println(" BARRIER();");
+ output.println(" sched_yield();");
+ output.println(" }");
+ output.println(" }");
+ output.println(" }");
output.println("{");
output.println(" int idx,idx2;");
if (fsen.getDynamicInVarSet().size()==1) {
output.println(" struct rcrRecord *rec="+paramsprefix+"->rcrRecords[idx];");
output.println(" while(rec!=NULL) {");
output.println(" for(idx2=0;idx2<rec->index;idx2++) {");
- output.println(" rcr_RETIREHASHTABLE(allHashStructures[0],rec,rec->array[idx2]);");
+ output.println(" rcr_RETIREHASHTABLE(allHashStructures[0],rec,rec->array[idx2], (BinItem_rcr *) rcr->ptrarray[idx2]);");
output.println(" }");//exit idx2 for loop
output.println(" rec=rec->next;");
output.println(" }");//exit rec while loop
// if the called method is a static block or a static method or a constructor
// need to check if it can be invoked inside some static block
+ if(state.MGC) {
+ // TODO add version for normal Java later
if((md.isStatic() || md.isStaticBlock() || md.isConstructor()) &&
((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic()))) {
if(!md.isInvokedByStatic()) {
}
}
}
+ }
output.println("{");
if ((GENERATEPRECISEGC) || (this.state.MULTICOREGC)) {
// DEBUG if(!ffn.getDst().getType().isPrimitive()){
// DEBUG output.println("within((void*)"+generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+");");
// DEBUG }
+ if(state.MGC) {
+ // TODO add version for normal Java later
if(ffn.getField().isStatic()) {
// static field
if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
//output.println(generateTemp(fm, ffn.getDst(),lb)+"=global_defs_p->"+ffn.getSrc().getType().getClassDesc().getSafeSymbol()+"->"+ ffn.getField().getSafeSymbol()+";");
} else {
output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
+ }
+ } else {
+ output.println(generateTemp(fm, ffn.getDst(),lb)+"="+ generateTemp(fm,ffn.getSrc(),lb)+"->"+ ffn.getField().getSafeSymbol()+";");
}
}
}
// DEBUG if(!fsfn.getField().getType().isPrimitive()){
// DEBUG output.println("within((void*)"+generateTemp(fm,fsfn.getSrc(),lb)+");");
-// DEBUG }
+// DEBUG }
+ if(state.MGC) {
+ // TODO add version for normal Java later
if(fsfn.getField().isStatic()) {
// static field
if((fm.getMethod().isStaticBlock()) || (fm.getMethod().isInvokedByStatic())) {
} else {
output.println("*"+generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
}
+ } else {
+ output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
+ }
} else {
output.println(generateTemp(fm, fsfn.getDst(),lb)+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc(),lb)+";");
}
}
protected void generateFlatReturnNode(FlatMethod fm, LocalityBinding lb, FlatReturnNode frn, PrintWriter output) {
+ if(state.MGC) {
+ // TODO add version for normal Java later
if((fm.getMethod() != null) && (fm.getMethod().isStaticBlock())) {
// a static block, check if it has been executed
output.println(" global_defs_p->" + fm.getMethod().getClassDesc().getSafeSymbol()+"static_block_exe_flag = 1;");
output.println("");
}
+ }
if (frn.getReturnTemp()!=null) {
if (frn.getReturnTemp().getType().isPtr())
output.println("return (struct "+fm.getMethod().getReturnType().getSafeSymbol()+"*)"+generateTemp(fm, frn.getReturnTemp(), lb)+";");
projects / IRC.git / blobdiff