if(rcr != null) {
rcr.close();
System.out.println("Runtime Conflict Resolver Done.");
- }
+ }
}
/* This method goes though the call graph and tag those methods that are
else if ((state.MGC) && (fd.isStatic())) {
// TODO add version for normal Java later
// static field
- globaldefout.println(" "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
+ if(fd.isVolatile()) {
+ globaldefout.println(" volatile "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
+ } else {
+ globaldefout.println(" "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
+ }
+ classdefout.println(" "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
+ } else if ((state.MGC) && (fd.isVolatile())) {
+ // TODO add version for normal Java later
+ // static field
+ globaldefout.println(" volatile "+fd.getType().getSafeSymbol()+ " "+cn.getSafeSymbol()+fd.getSafeSymbol()+";");
classdefout.println(" "+fd.getType().getSafeSymbol()+" * "+fd.getSafeSymbol()+";");
} else
classdefout.println(" "+fd.getType().getSafeSymbol()+" "+fd.getSafeSymbol()+";");
if( !fsen.getIsLeafSESE() ) {
output.println(" runningSESE->taskRecordMemPool = poolcreate( "+
maxTaskRecSizeStr+", freshTaskRecordInitializer );");
+ if (state.RCR && !rcr.hasEmptyTraversers(fsen)) {
+ output.println(" createTR();");
+ output.println(" runningSESE->allHashStructures=TRqueue->allHashStructures;");
+ }
} else {
// make it clear we purposefully did not initialize this
output.println(" runningSESE->taskRecordMemPool = (MemPool*)0x7;");
throw new Error();
}
+
+ void stallMEMRCR(FlatMethod fm, FlatNode fn, Set<Analysis.OoOJava.WaitingElement> waitingElementSet, PrintWriter output) {
+ output.println("// stall on parent's stall sites ");
+ output.println(" {");
+ output.println(" REntry* rentry;");
+ output.println(" // stallrecord sometimes is used as a task record for instance ");
+ output.println(" // when you call RELEASE_REFERENCE_TO on a stall record.");
+ output.println(" // so the parent field must be initialized.");
+ output.println(" SESEstall * stallrecord=(SESEstall *) poolalloc(runningSESE->taskRecordMemPool);");
+ output.println(" stallrecord->common.parent=runningSESE;");
+ output.println(" stallrecord->common.unresolvedDependencies=10000;");
+ output.println(" stallrecord->common.rcrstatus=1;");
+ output.println(" stallrecord->common.offsetToParamRecords=(INTPTR) & (((SESEstall *)0)->rcrRecords);");
+ output.println(" stallrecord->common.refCount = 10003;");
+ output.println(" int localCount=10000;");
+ output.println(" stallrecord->rcrRecords[0].index=0;");
+ output.println(" stallrecord->rcrRecords[0].flag=0;");
+ output.println(" stallrecord->rcrRecords[0].next=NULL;");
+ output.println(" stallrecord->common.parentsStallSem=&runningSESEstallSem;");
+ output.println(" psem_reset( &runningSESEstallSem);");
+ output.println(" stallrecord->tag=runningSESEstallSem.tag;");
+
+ TempDescriptor stalltd=null;
+ for (Iterator iterator = waitingElementSet.iterator(); iterator.hasNext();) {
+ Analysis.OoOJava.WaitingElement waitingElement =(Analysis.OoOJava.WaitingElement) iterator.next();
+ if (waitingElement.getStatus() >= ConflictNode.COARSE) {
+ output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "]," + waitingElement.getStatus()
+ + ", (SESEcommon *) stallrecord, 1LL);");
+ } else {
+ throw new Error("Fine-grained conflict: This should not happen in RCR");
+ }
+ output.println(" rentry->queue=runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "];");
+ output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "],rentry)==NOTREADY) {");
+ output.println(" localCount--;");
+ output.println(" }");
+ output.println("#if defined(RCR)&&!defined(OOO_DISABLE_TASKMEMPOOL)");
+ output.println(" else poolfreeinto(runningSESE->memoryQueueArray["+waitingElement.getQueueID()+"]->rentrypool, rentry);");
+ output.println("#endif");
+ if (stalltd==null) {
+ stalltd=waitingElement.getTempDesc();
+ } else if (stalltd!=waitingElement.getTempDesc()) {
+ throw new Error("Multiple temp descriptors at stall site"+stalltd+"!="+waitingElement.getTempDesc());
+ }
+ }
+
+ //did all of the course grained stuff
+ output.println(" if(!atomic_sub_and_test(localCount, &(stallrecord->common.unresolvedDependencies))) {");
+ //have to do fine-grained work also
+ output.println(" stallrecord->___obj___=(struct ___Object___ *)"
+ + generateTemp(fm, stalltd, null) + ";");
+ output.println(" stallrecord->common.classID=-"
+ + rcr.getTraverserID(stalltd, fn) + ";");
+
+ output.println(" enqueueTR(TRqueue, (void *)stallrecord);");
+
+ 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( &runningSESEstallSem, (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(" } else {");//exit if condition
+ //release traversers reference if we didn't use traverser
+ output.println("#ifndef OOO_DISABLE_TASKMEMPOOL");
+ output.println(" RELEASE_REFERENCE_TO((SESEcommon *)stallrecord);");
+ output.println("#endif");
+ output.println(" }");
+ //release our reference to stall record
+ output.println("#ifndef OOO_DISABLE_TASKMEMPOOL");
+ output.println(" RELEASE_REFERENCE_TO((SESEcommon *)stallrecord);");
+ output.println("#endif");
+ output.println(" }");//exit block
+ }
+
protected void generateFlatNode(FlatMethod fm, LocalityBinding lb, FlatNode fn, PrintWriter output) {
// insert pre-node actions from the code plan
// eom
// handling stall site
if (state.OOOJAVA) {
- Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(currentSESE);
+ // NEED TO FIX IT
+ // assumes that there is only one parent, but it is possible that
+ // currentSESE has more than one so we need to generate
+ // conditional case for each parent case
+ Analysis.OoOJava.ConflictGraph graph = null;
+ if(currentSESE.getSESEParent().size()>0){
+ graph = oooa.getConflictGraph(currentSESE.getSESEParent().iterator().next());
+ }
+// 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);
- if(waitingElementSet.size()>0){
- output.println("// stall on parent's stall sites ");
- output.println(" {");
- output.println(" REntry* rentry;");
-
- for (Iterator iterator = waitingElementSet.iterator(); iterator.hasNext();) {
- Analysis.OoOJava.WaitingElement waitingElement = (Analysis.OoOJava.WaitingElement) iterator.next();
- if( waitingElement.getStatus() >= ConflictNode.COARSE ){
- output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "],"+waitingElement.getStatus()+ ", runningSESE);");
- }else{
- output.println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "],"+ waitingElement.getStatus()+ ", runningSESE, (void*)&" +generateTemp(fm,waitingElement.getTempDesc(),lb)+ ");");
- }
- output.println(" rentry->parentStallSem=&runningSESEstallSem;");
- output.println(" psem_reset( &runningSESEstallSem);");
- output.println(" rentry->tag=runningSESEstallSem.tag;");
- output.println(" rentry->queue=runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "];");
- 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");
- }
- 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=&runningSESEstallSem;");
- 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( &runningSESEstallSem, (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(" } ");
- }
- output.println(" }");
- }
- }
- }else{
+ if (waitingElementSet.size() > 0) {
+ if (state.RCR) {
+ stallMEMRCR(fm, fn, waitingElementSet, output);
+ } else {
+ output.println("// stall on parent's stall sites ");
+ output.println(" {");
+ output.println(" REntry* rentry;");
+
+ for (Iterator iterator = waitingElementSet.iterator(); iterator.hasNext();) {
+ Analysis.OoOJava.WaitingElement waitingElement =
+ (Analysis.OoOJava.WaitingElement) iterator.next();
+ if (waitingElement.getStatus() >= ConflictNode.COARSE) {
+ output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "]," + waitingElement.getStatus()
+ + ", runningSESE);");
+ } else {
+ output.println(" rentry=mlpCreateFineREntry(runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "]," + waitingElement.getStatus()
+ + ", runningSESE, (void*)&"
+ + generateTemp(fm, waitingElement.getTempDesc(), lb) + ");");
+ }
+ output.println(" rentry->parentStallSem=&runningSESEstallSem;");
+ output.println(" psem_reset( &runningSESEstallSem);");
+ output.println(" rentry->tag=runningSESEstallSem.tag;");
+ output.println(" rentry->queue=runningSESE->memoryQueueArray["
+ + waitingElement.getQueueID() + "];");
+ 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( &runningSESEstallSem, (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(" } ");
+ }
+ output.println(" }");
+ }
+ }
+ }
+ } else{
ParentChildConflictsMap conflictsMap = mlpa.getConflictsResults().get(fn);
if (conflictsMap != null) {
Set<Long> allocSet = conflictsMap.getAllocationSiteIDSetofStallSite();
output.println(" struct garbagelist * gl= (struct garbagelist *)&(((SESEcommon*)(seseToIssue))[1]);");
output.println(" gl->size="+calculateSizeOfSESEParamList(fsen)+";");
output.println(" gl->next = NULL;");
-
+ output.println(" seseToIssue->common.rentryIdx=0;");
+
if(state.RCR) {
//flag the SESE status as 1...it will be reset
output.println(" seseToIssue->common.rcrstatus=1;");
if( state.RCR ) {
// if we're using RCR, ref count is 3 because the traverser has
// a reference, too
- output.println(" seseToIssue->common.refCount = 3;");
+ if( fsen != oooa.getMainSESE() && fsen.getInVarsForDynamicCoarseConflictResolution().size()>0){
+ output.println(" seseToIssue->common.refCount = 10003;");
+ } else {
+ output.println(" seseToIssue->common.refCount = 10002;");
+ }
+ output.println(" int refCount=10000;");
} else {
output.println(" seseToIssue->common.refCount = 2;");
}
output.println(" }");
}
-
-
if( state.COREPROF ) {
output.println("#ifdef CP_EVENTID_PREPAREMEMQ");
output.println(" CP_LOGEVENT( CP_EVENTID_PREPAREMEMQ, CP_EVENTTYPE_BEGIN );");
////////////////
// count up memory conflict dependencies,
if(state.RCR) {
- dispatchMEMRC(fm, lb, fsen, output);
+ dispatchMEMRC(fm, lb, fsen, output);
} else if(state.OOOJAVA){
- FlatSESEEnterNode parent = fsen.getParent();
- Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(parent);
+ // NEED TO FIX IT
+ // assumes that there is only one parent, but it is possible that
+ // currentSESE has more than one so we need to generate
+ // conditional case for each parent case
+ assert fsen.getSESEParent().size()>0;
+ FlatSESEEnterNode parent = fsen.getSESEParent().iterator().next();
+ Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(parent);
if (graph != null && graph.hasConflictEdge()) {
Set<Analysis.OoOJava.SESELock> seseLockSet = oooa.getLockMappings(graph);
output.println();
// Enqueue Task Record
if (state.RCR) {
- output.println(" enqueueTR(TRqueue, (void *)seseToIssue);");
+ if( fsen != oooa.getMainSESE() && fsen.getInVarsForDynamicCoarseConflictResolution().size()>0){
+ output.println(" enqueueTR(TRqueue, (void *)seseToIssue);");
+ }
}
// if there were no outstanding dependencies, issue here
}
void dispatchMEMRC(FlatMethod fm, LocalityBinding lb, FlatSESEEnterNode fsen, PrintWriter output) {
- FlatSESEEnterNode parent = fsen.getParent();
+ // NEED TO FIX IT
+ // assumes that there is only one parent, but it is possible that
+ // currentSESE has more than one so we need to generate
+ // conditional case for each parent case
+ assert fsen.getSESEParent().size()>0;
+ FlatSESEEnterNode parent = fsen.getSESEParent().iterator().next();
Analysis.OoOJava.ConflictGraph graph = oooa.getConflictGraph(parent);
if (graph != null && graph.hasConflictEdge()) {
Set<Analysis.OoOJava.SESELock> seseLockSet = oooa.getLockMappings(graph);
output.println(" REntry* rentry=NULL;");
output.println(" INTPTR* pointer=NULL;");
output.println(" seseToIssue->common.rentryIdx=0;");
- output.println(" int dispCount;");
Vector<TempDescriptor> invars=fsen.getInVarsForDynamicCoarseConflictResolution();
System.out.println(fm.getMethod()+"["+invars+"]");
+
+ Vector<Long> queuetovar=new Vector<Long>();
+
+ for(int i=0;i<invars.size();i++) {
+ TempDescriptor td=invars.get(i);
+ Set<Analysis.OoOJava.WaitingElement> weset=seseWaitingQueue.getWaitingElementSet(td);
+ int numqueues=0;
+ Set<Integer> queueSet=new HashSet<Integer>();
+ for (Iterator iterator = weset.iterator(); iterator.hasNext();) {
+ Analysis.OoOJava.WaitingElement we = (Analysis.OoOJava.WaitingElement) iterator.next();
+ Integer queueID=new Integer( we.getQueueID());
+ if(!queueSet.contains(queueID)){
+ numqueues++;
+ queueSet.add(queueID);
+ }
+ }
+ output.println(" seseToIssue->rcrRecords["+i+"].flag="+numqueues+";");
+ output.println(" seseToIssue->rcrRecords["+i+"].index=0;");
+ output.println(" seseToIssue->rcrRecords["+i+"].next=NULL;");
+ output.println(" int dispCount"+i+"=0;");
+
+ for (Iterator<Analysis.OoOJava.WaitingElement> wtit = weset.iterator(); wtit.hasNext();) {
+ Analysis.OoOJava.WaitingElement waitingElement = wtit.next();
+ int queueID = waitingElement.getQueueID();
+ if (queueID >= queuetovar.size())
+ queuetovar.setSize(queueID + 1);
+ Long l = queuetovar.get(queueID);
+ long val = (l != null) ? l.longValue() : 0;
+ val = val | (1 << i);
+ queuetovar.set(queueID, new Long(val));
+ }
+ }
+
+ HashSet generatedqueueentry=new HashSet();
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;");
for(Iterator<Analysis.OoOJava.WaitingElement> wtit=weset.iterator();wtit.hasNext();) {
Analysis.OoOJava.WaitingElement waitingElement=wtit.next();
int queueID=waitingElement.getQueueID();
+
+ if(waitingElement.isBogus()){
+ continue;
+ }
+
+ if (generatedqueueentry.contains(queueID))
+ continue;
+ else
+ generatedqueueentry.add(queueID);
+
assert(waitingElement.getStatus()>=ConflictNode.COARSE);
- output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "]," + waitingElement.getStatus() + ", &(seseToIssue->common));");
+ long mask=queuetovar.get(queueID);
+ output.println(" rentry=mlpCreateREntry(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "]," + waitingElement.getStatus() + ", &(seseToIssue->common), "+mask+"LL);");
+ output.println(" rentry->count=2;");
output.println(" seseToIssue->common.rentryArray[seseToIssue->common.rentryIdx++]=rentry;");
output.println(" rentry->queue=runningSESE->memoryQueueArray[" + waitingElement.getQueueID()+"];");
+
output.println(" if(ADDRENTRY(runningSESE->memoryQueueArray["+ waitingElement.getQueueID()+ "],rentry)==READY) {");
- output.println(" dispCount++;");
- output.println(" }");
+ for(int j=0;mask!=0;j++) {
+ if ((mask&1)==1)
+ output.println(" dispCount"+j+"++;");
+ mask=mask>>1;
+ }
+ output.println(" } else ");
+ output.println(" refCount--;");
+
}
- output.println(" if(!dispCount || !atomic_sub_and_test(dispCount,&(seseToIssue->rcrRecords["+i+"].flag)))");
- output.println(" localCount++;");
+
if (fsen.getDynamicInVarSet().contains(td)) {
// dynamic in-var case
//output.println(" pointer=seseToIssue->" + waitingElement.getDynID()+ "_srcSESE+seseToIssue->"+ waitingElement.getDynID()+ "_srcOffset;");
//output.println(" rentry=mlpCreateFineREntry("+ waitingElement.getStatus()+ ", &(seseToIssue->common), pointer );");
}
}
+ for(int i=0;i<invars.size();i++) {
+ output.println(" if(!dispCount"+i+" || !atomic_sub_and_test(dispCount"+i+",&(seseToIssue->rcrRecords["+i+"].flag)))");
+ output.println(" localCount++;");
+ }
output.println(" }");
}
}
+ output.println("#ifndef OOO_DISABLE_TASKMEMPOOL");
+ output.println(" RELEASE_REFERENCES_TO((SESEcommon *)seseToIssue, refCount);");
+ output.println("#endif");
}
public void generateFlatSESEExitNode( FlatMethod fm,
output.println(" SESEcommon* consumer = (SESEcommon*) getItem( &runningSESE->forwardList );");
- output.println(" if(consumer->rentryIdx>0){");
- output.println(" // resolved null pointer");
- output.println(" int idx;");
- output.println(" for(idx=0;idx<consumer->rentryIdx;idx++){");
- output.println(" resolvePointer(consumer->rentryArray[idx]);");
- output.println(" }");
- output.println(" }");
+ if (!state.RCR) {
+ output.println(" if(consumer->rentryIdx>0){");
+ output.println(" // resolved null pointer");
+ output.println(" int idx;");
+ output.println(" for(idx=0;idx<consumer->rentryIdx;idx++){");
+ output.println(" resolvePointer(consumer->rentryArray[idx]);");
+ output.println(" }");
+ output.println(" }");
+ }
output.println(" if( atomic_sub_and_test( 1, &(consumer->unresolvedDependencies) ) ){");
output.println(" workScheduleSubmit( (void*)consumer );");
output.println(" }");
- // 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(" }");
}
-
- if (state.RCR && fsen.getDynamicInVarSet().size() > 0) {
+ Vector<TempDescriptor> inset=fsen.getInVarsForDynamicCoarseConflictResolution();
+ if (state.RCR && inset.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(" if(CAS(&runningSESE->rcrstatus,1,0)==2) {");
output.println(" while(runningSESE->rcrstatus) {");
output.println(" BARRIER();");
output.println(" sched_yield();");
output.println(" }");
output.println(" }");
output.println("{");
- output.println(" int idx,idx2;");
- if (fsen.getDynamicInVarSet().size() == 1) {
- output.println(" idx=0; {");
- } else {
- output.println(" for(idx=0;idx<" + fsen.getDynamicInVarSet().size() + ";idx++){");
- }
- output.println(" struct rcrRecord *rec=&" + paramsprefix + "->rcrRecords[idx];");
- output.println(" while(rec!=NULL) {");
- output.println(" for(idx2=0;idx2<rec->index;idx2++) {");
+ output.println(" int idx,idx2;");
+
+ output.println(" struct rcrRecord *rec;");
output
- .println(" rcr_RETIREHASHTABLE(allHashStructures[0],&(___params___->common),rec->array[idx2], (BinItem_rcr *) rec->ptrarray[idx2]);");
- output.println(" }");// exit idx2 for loop
- output.println(" rec=rec->next;");
- output.println(" }");// exit rec while loop
- output.println(" }");// exit idx for loop
+ .println(" struct Hashtable_rcr ** hashstruct=runningSESE->parent->allHashStructures;");
+
+ for (int i = 0; i < inset.size(); i++) {
+ output.println(" rec=&" + paramsprefix + "->rcrRecords[" + i + "];");
+ output.println(" while(rec!=NULL) {");
+ output.println(" for(idx2=0;idx2<rec->index;idx2++) {");
+
+ int weaklyConnectedComponentIndex = rcr.getWeakID(inset.get(i), fsen);
+
+ output.println(" rcr_RETIREHASHTABLE(hashstruct[" + weaklyConnectedComponentIndex
+ + "],&(___params___->common), rec->array[idx2], (BinItem_rcr *) rec->ptrarray[idx2]);");
+
+ output.println(" }");// exit idx2 for loop
+ output.println(" rec=rec->next;");
+ output.println(" }");// exit rec while loop
+ }
output.println("}");
}
// destroy this task's mempool if it is not a leaf task
if( !fsen.getIsLeafSESE() ) {
output.println(" pooldestroy( runningSESE->taskRecordMemPool );");
+ if (state.RCR && fsen.getInVarsForDynamicCoarseConflictResolution().size() > 0 ) {
+ output.println(" returnTR();");
+ }
}
output.println("#endif // OOO_DISABLE_TASKMEMPOOL" );
projects / IRC.git / blobdiff