output.println(" seseToIssue->"+srcPair+" = "+srcPair+";");
}
- ////////////////
- // count up memory conflict dependencies,
- // eom
- ConflictGraph graph = null;
- FlatSESEEnterNode parent = fsen.getParent();
- if (parent != null) {
- if (parent.isCallerSESEplaceholder) {
- graph = mlpa.getConflictGraphResults().get(parent.getfmEnclosing());
- } else {
- graph = mlpa.getConflictGraphResults().get(parent);
- }
- }
- if (graph != null && graph.hasConflictEdge()) {
- HashSet<SESELock> seseLockSet = mlpa.getConflictGraphLockMap()
- .get(graph);
- output.println();
- output.println(" //add memory queue element");
- Set<WaitingElement> waitingQueueSet = graph
- .getWaitingElementSetBySESEID(fsen.getIdentifier(),
- seseLockSet);
- if (waitingQueueSet.size() > 0) {
- output.println(" {");
- output.println(" REntry* rentry=NULL;");
- output.println(" seseToIssue->common.rentryIdx=0;");
- for (Iterator iterator = waitingQueueSet.iterator(); iterator
- .hasNext();) {
- WaitingElement waitingElement = (WaitingElement) iterator
- .next();
-
- if (waitingElement.getStatus() >= ConflictNode.COARSE) {
- output.println(" rentry=mlpCreateREntry("
- + waitingElement.getStatus()
- + ", seseToIssue);");
- } else {
- TempDescriptor td = waitingElement.getTempDesc();
- output
- .println(" rentry=mlpCreateFineREntry("
- + waitingElement.getStatus()
- + ", seseToIssue, seseToIssue->"
- + waitingElement.getDynID()
- + ");");
- if (td != null) {
- VariableSourceToken vst = fsen
- .getStaticInVarSrc(td);
- String srcId = "SESE_"
- + vst.getSESE().getPrettyIdentifier()
- + vst.getSESE().getIdentifier() + "_"
- + vst.getAge();
- output.println(" if(seseToIssue->"
- + waitingElement.getDynID()
- + " == NULL) {");
- output
- .println(" rentry->pointer=(void*)&seseToIssue->"
- + srcId
- + "->"
- + waitingElement.getDynID()
- + ";");
- output
- .println(" seseToIssue->common.unresolvedRentryArray[seseToIssue->common.unresolvedRentryIdx++]=rentry;");
- output.println(" }");
- }
- }
- output
- .println(" rentry->queue=parentCommon->memoryQueueArray["
- + waitingElement.getQueueID() + "];");
- output
- .println(" seseToIssue->common.rentryArray[seseToIssue->common.rentryIdx++]=rentry;");
- output
- .println(" if(ADDRENTRY(parentCommon->memoryQueueArray["
- + waitingElement.getQueueID()
- + "],rentry)==NOTREADY){");
- output.println(" ++(localCount);");
- output.println(" } ");
- output.println();
- }
- output.println(" }");
- }
- output.println();
- }
-
- ////////////////
-
// dynamic sources might already be accounted for in the static list,
// so only add them to forwarding lists if they're not already there
Iterator<TempDescriptor> dynVarsItr = fsen.getDynamicInVarSet().iterator();
}
output.println(" "+pair+" = seseToIssue;");
}
+
+ ////////////////
+ // count up memory conflict dependencies,
+ // eom
+ ConflictGraph graph = null;
+ FlatSESEEnterNode parent = fsen.getParent();
+ if (parent != null) {
+ if (parent.isCallerSESEplaceholder) {
+ graph = mlpa.getConflictGraphResults().get(parent.getfmEnclosing());
+ } else {
+ graph = mlpa.getConflictGraphResults().get(parent);
+ }
+ }
+ if (graph != null && graph.hasConflictEdge()) {
+ HashSet<SESELock> seseLockSet = mlpa.getConflictGraphLockMap()
+ .get(graph);
+ output.println();
+ output.println(" //add memory queue element");
+ Set<WaitingElement> waitingQueueSet = graph
+ .getWaitingElementSetBySESEID(fsen.getIdentifier(),
+ seseLockSet);
+ if (waitingQueueSet.size() > 0) {
+ output.println(" {");
+ output.println(" REntry* rentry=NULL;");
+ output.println(" INTPTR* pointer=NULL;");
+ output.println(" seseToIssue->common.rentryIdx=0;");
+ for (Iterator iterator = waitingQueueSet.iterator(); iterator
+ .hasNext();) {
+ WaitingElement waitingElement = (WaitingElement) iterator
+ .next();
+
+ if (waitingElement.getStatus() >= ConflictNode.COARSE) {
+ output.println(" rentry=mlpCreateREntry("
+ + waitingElement.getStatus()
+ + ", seseToIssue);");
+ } else {
+ TempDescriptor td = waitingElement.getTempDesc();
+ // decide whether waiting element is dynamic or
+ // static
+ 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, pointer );");
+ }else if(fsen.getStaticInVarSet().contains(td)){
+ // static in-var case
+ VariableSourceToken vst = fsen.getStaticInVarSrc(td);
+ if (vst != null) {
+ String srcId = "SESE_"
+ + vst.getSESE()
+ .getPrettyIdentifier()
+ + vst.getSESE().getIdentifier()
+ + "_" + vst.getAge();
+ output
+ .println(" pointer=(void*)&seseToIssue->"
+ + srcId
+ + "->"
+ + waitingElement.getDynID()
+ + ";");
+ output.println(" rentry=mlpCreateFineREntry("
+ + waitingElement.getStatus()
+ + ", seseToIssue, pointer );");
+ }
+ }else{
+ output.println(" rentry=mlpCreateFineREntry("
+ + waitingElement.getStatus()
+ + ", seseToIssue, (void*)&seseToIssue->"
+ + waitingElement.getDynID() + ");");
+ }
+ }
+ output
+ .println(" rentry->queue=parentCommon->memoryQueueArray["
+ + waitingElement.getQueueID() + "];");
+ output
+ .println(" seseToIssue->common.rentryArray[seseToIssue->common.rentryIdx++]=rentry;");
+ output
+ .println(" if(ADDRENTRY(parentCommon->memoryQueueArray["
+ + waitingElement.getQueueID()
+ + "],rentry)==NOTREADY){");
+ output.println(" ++(localCount);");
+ output.println(" } ");
+ output.println();
+ }
+ output.println(" }");
+ }
+ output.println();
+ }
+
+ ////////////////
+
}
output.println(" while( !isEmpty( "+com+".forwardList ) ) {");
output.println(" SESEcommon* consumer = (SESEcommon*) getItem( "+com+".forwardList );");
- output.println(" if(consumer->unresolvedRentryIdx>0){");
+
+ output.println(" if(consumer->rentryIdx>0){");
output.println(" // resolved null pointer");
output.println(" int idx;");
- output.println(" for(idx=0;idx<consumer->unresolvedRentryIdx;idx++){");
- output.println(" resolvePointer(consumer->unresolvedRentryArray[idx]);");
+ output.println(" for(idx=0;idx<consumer->rentryIdx;idx++){");
+ output.println(" resolvePointer(consumer->rentryArray[idx]);");
output.println(" }");
output.println(" }");
+
// output.println(" pthread_mutex_lock( &(consumer->lock) );");
// output.println(" --(consumer->unresolvedDependencies);");
// output.println(" if( consumer->unresolvedDependencies == 0 ) {");
REntry* newREntry=(REntry*)RUNMALLOC(sizeof(REntry));
newREntry->type=type;
newREntry->seseRec=seseToIssue;
- newREntry->dynID=dynID;
+ newREntry->pointer=dynID;
return newREntry;
}
//at this point, have table
Hashtable* table=(Hashtable*)q->tail;
- r->hashtable=table;
- if(r->pointer!=0 && (*(r->pointer)==0 || (*(r->pointer)!=0 && table->unresolvedQueue!=NULL))){
- struct Queue* val;
+ r->hashtable=table; // set rentry's hashtable
+ if((*(r->pointer)==0 || (*(r->pointer)!=0 && BARRIER() && table->unresolvedQueue!=NULL))){
+ struct Queue* val;
// grab lock on the queue
do {
val=(struct Queue*)0x1;
val=(struct Queue*)LOCKXCHG((unsigned INTPTR*)&(table->unresolvedQueue), (unsigned INTPTR)val);
- } while(val==(struct Queue*)0x1);
-
+ } while(val==(struct Queue*)0x1);
if(val==NULL){
- //first case
+ //queue is null, first case
if(*(r->pointer)!=0){
- // pointer is already resolved.
- table->unresolvedQueue=val; //released lock;
- return ADDTABLE(q,r);
+ // check whether pointer is already resolved, or not.
+ table->unresolvedQueue=NULL; //released lock;
+ return ADDTABLEITEM(table,r,TRUE);
}
- table->unresolvedQueue=(struct Queue*)0x1;
struct Queue* queue=createQueue();
- addNewItem(queue,r);
+ addNewItemBack(queue,r);
atomic_inc(&table->item.total);
table->unresolvedQueue=queue; // expose new queue
- }else{
- if(val==NULL){
- // someone else has already cleared all queue stuff
- table->unresolvedQueue=val; // released lock
- return ADDTABLE(q,r);
- }
+ }else{
+ // add unresolved rentry at the end of the queue.
addNewItemBack(val,r);
atomic_inc(&table->item.total);
table->unresolvedQueue=val; // released lock
}
return NOTREADY;
}
- if(r->pointer!=0){
- r->dynID=(void*)*(r->pointer); // interim fix.
- }
BinItem * val;
- int key=generateKey((unsigned int)(unsigned INTPTR)r->dynID);
+ int key=generateKey((unsigned int)(unsigned INTPTR)*(r->pointer));
do {
val=(BinItem*)0x1;
BinElement* bin=table->array[key];
}
}
-int ADDTABLEITEM(Hashtable* table, REntry* r){
+int ADDTABLEITEM(Hashtable* table, REntry* r, int inc){
+
BinItem * val;
- int key=generateKey((unsigned int)(unsigned INTPTR)r->dynID);
+ int key=generateKey((unsigned int)(unsigned INTPTR)*(r->pointer));
do {
val=(BinItem*)0x1;
BinElement* bin=table->array[key];
- val=(BinItem*)LOCKXCHG((unsigned INTPTR*)&(bin->head), (unsigned INTPTR)val);//note...talk to me about optimizations here.
+ val=(BinItem*)LOCKXCHG((unsigned INTPTR*)&(bin->head), (unsigned INTPTR)val);
} while(val==(BinItem*)0x1);
//at this point have locked bin
if (val==NULL) {
- return EMPTYBINCASE(table, table->array[key], r, FALSE);
+ return EMPTYBINCASE(table, table->array[key], r, inc);
} else {
if (isFineWrite(r)) {
- return WRITEBINCASE(table, r, val, key, FALSE);
+ return WRITEBINCASE(table, r, val, key, inc);
} else if (isFineRead(r)) {
- return READBINCASE(table, r, val, key, FALSE);
+ return READBINCASE(table, r, val, key, inc);
}
}
}
READBINCASE(Hashtable *T, REntry *r, BinItem *val, int key, int inc) {
BinItem * bintail=T->array[key]->tail;
if (isReadBinItem(bintail)) {
- return TAILREADCASE(T, r, val, bintail, key);
+ return TAILREADCASE(T, r, val, bintail, key, inc);
} else if (!isReadBinItem(bintail)) {
- TAILWRITECASE(T, r, val, bintail, key);
+ TAILWRITECASE(T, r, val, bintail, key, inc);
return NOTREADY;
}
}
}
RETIREBIN(Hashtable *T, REntry *r, BinItem *b) {
- int key=generateKey((unsigned int)(unsigned INTPTR)r->dynID);
+ int key=generateKey((unsigned int)(unsigned INTPTR)*(r->pointer));
if(isFineRead(r)) {
atomic_dec(&b->total);
}
}
resolvePointer(REntry* rentry){
- rentry->dynID=(void*)*(rentry->pointer); // interim.
+
Hashtable* table=rentry->hashtable;
+ if(table==NULL){
+ //resolved already before related rentry is enqueued to the waiting queue
+ return;
+ }
struct Queue* val;
do {
val=(struct Queue*)0x1;
break;
}
removeItem(val,head);
- if(ADDTABLEITEM(table, rentry)==READY){
- SESEcommon* seseCommon=(SESEcommon*)rentry->seseRec;
- atomic_sub_and_test(1, &(seseCommon->unresolvedDependencies));
+ if(ADDTABLEITEM(table, rentry, FALSE)==READY){
+ resolveDependencies(rentry);
}
}else{
table->unresolvedQueue=NULL; // set hashtable as normal-mode.
}
}while(TRUE);
}else{
+ // resolved rentry is not head of queue
table->unresolvedQueue=val;//released lock;
}
}
-
projects / IRC.git / commitdiff