#include <sys/types.h>
#include <sys/mman.h>
#include <string.h>
+#include <signal.h>
extern int injectfailures;
extern float failurechance;
struct RuntimeHash * forward;
struct RuntimeHash * reverse;
-
int main(int argc, char **argv) {
#ifdef BOEHM_GC
GC_init(); // Initialize the garbage collector
/* Create queue of active tasks */
activetasks=genallocatehashtable((unsigned int (*)(void *)) &hashCodetpd,
(int (*)(void *,void *)) &comparetpd);
-
-
+
/* Process task information */
processtasks();
((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i-1]=newstring;
}
- /* Set initialized flag for startup object */
+ /* Set initialized flag for startup object */
flagorand(startupobject,1,0xFFFFFFFF);
+ enqueueObject(startupobject);
}
int hashCodetpd(struct taskparamdescriptor *ftd) {
int hash=(int)ftd->task;
int i;
- for(i=0;i<ftd->numParameters;i++) {
+ for(i=0;i<ftd->numParameters;i++){
hash^=(int)ftd->parameterArray[i];
}
return hash;
if (ftd1->task!=ftd2->task)
return 0;
for(i=0;i<ftd1->numParameters;i++)
- if (ftd1->parameterArray[i]!=ftd2->parameterArray[i])
+ if(ftd1->parameterArray[i]!=ftd2->parameterArray[i])
return 0;
+#ifdef OPTIONAL
+ for(i=0;i<ftd1->numParameters;i++) {
+ if(ftd1->failed[i]!=ftd2->failed[i])
+ return 0;
+ }
+#endif
return 1;
}
-
/* This function sets a tag. */
#ifdef PRECISE_GC
void tagset(void *ptr, struct ___Object___ * obj, struct ___TagDescriptor___ * tagd) {
{
struct ___Object___ * tagset=tagd->flagptr;
-
if(tagset==NULL) {
tagd->flagptr=obj;
} else if (tagset->type!=OBJECTARRAYTYPE) {
ARRAYSET(aonew, struct ___Object___*, i, ARRAYGET(ao, struct ___Object___*, i));
}
ARRAYSET(aonew, struct ___Object___ *, ao->___cachedCode___, obj);
- tagd->flagptr=(struct ___Object___ *) ao;
+ tagd->flagptr=(struct ___Object___ *) aonew;
}
}
}
}
ENDCLEAR:
return;
-
}
/* This function allocates a new tag. */
with the or mask and and's it with the andmask. */
void flagbody(struct ___Object___ *ptr, int flag);
+#ifdef OPTIONAL
+void enqueueoptional(struct ___Object___ * currobj, int numfailedfses, int * failedfses, struct taskdescriptor * task, int index);
+#endif
+
+ int flagcomp(const int *val1, const int *val2) {
+ return (*val1)-(*val2);
+ }
void flagorand(void * ptr, int ormask, int andmask) {
- int oldflag=((int *)ptr)[1];
- int flag=ormask|oldflag;
- flag&=andmask;
- // Not sure why this was necessary
- // if (flag==oldflag) /* Don't do anything */
- // return;
- //else
- flagbody(ptr, flag);
+#ifdef OPTIONAL
+ struct ___Object___ * obj = (struct ___Object___ *)ptr;
+ if(obj->numfses){/*store the information about fses*/
+ int flag, i, j,counter, offset=0;
+ for(i=0;i<obj->numfses;i++) {
+ int oldoffset;
+ counter=obj->fses[offset++];
+ oldoffset=offset;
+ for(j=0;j<counter;j++) {
+ flag=obj->fses[offset];
+ obj->fses[offset++]=(flag|ormask)&andmask;
+ }
+ qsort(&obj->fses[oldoffset], sizeof(int), counter, (int (*)(const void *, const void *)) &flagcomp);
+ }
+ enqueueoptional(obj, 0, NULL, NULL, 0);
+ }
+ else
+#endif
+ {
+ int oldflag=((int *)ptr)[1];
+ int flag=ormask|oldflag;
+ flag&=andmask;
+ flagbody(ptr, flag);
+ }
}
-
-void intflagorand(void * ptr, int ormask, int andmask) {
- int oldflag=((int *)ptr)[1];
- int flag=ormask|oldflag;
- flag&=andmask;
- if (flag==oldflag) /* Don't do anything */
- return;
- else flagbody(ptr, flag);
+
+bool intflagorand(void * ptr, int ormask, int andmask) {
+#ifdef OPTIONAL
+ struct ___Object___ * obj = (struct ___Object___ *)ptr;
+ if(obj->numfses) {/*store the information about fses*/
+ int flag, i, j,counter, offset=0;
+ for(i=0;i<obj->numfses;i++) {
+ int oldoffset;
+ counter=obj->fses[offset++];
+ oldoffset=offset;
+ for(j=0;j<counter;j++) {
+ flag=obj->fses[offset];
+ obj->fses[offset++]=(flag|ormask)&andmask;
+ }
+ qsort(&obj->fses[oldoffset], sizeof(int), counter, (int (*)(const void *, const void *)) &flagcomp);
+ }
+ enqueueoptional(obj, 0, NULL, NULL, 0);
+ }
+ else
+#endif
+ {
+ int oldflag=((int *)ptr)[1];
+ int flag=ormask|oldflag;
+ flag&=andmask;
+ if (flag==oldflag) /* Don't do anything */
+ return false;
+ else {
+ flagbody(ptr, flag);
+ return true;
+ }
+ }
}
void flagorandinit(void * ptr, int ormask, int andmask) {
/*Remove object from all queues */
while(flagptr!=NULL) {
struct parameterwrapper *next;
- struct ___Object___ * tag=ptr->___tags___;
- RuntimeHashget(flagptr->objectset, (int) ptr, (int *) &next);
- RuntimeHashremove(flagptr->objectset, (int)ptr, (int) next);
+ int UNUSED, UNUSED2;
+ int * enterflags;
+ ObjectHashget(flagptr->objectset, (int) ptr, (int *) &next, (int *) &enterflags, &UNUSED, &UNUSED2);
+ ObjectHashremove(flagptr->objectset, (int)ptr);
+ if (enterflags!=NULL)
+ free(enterflags);
flagptr=next;
}
+ }
+
+ void enqueueObject(void *vptr) {
+ struct ___Object___ *ptr = (struct ___Object___ *)vptr;
{
struct QueueItem *tmpptr;
int i;
struct parameterwrapper * prevptr=NULL;
struct ___Object___ *tagptr=ptr->___tags___;
-
+
/* Outer loop iterates through all parameter queues an object of
this type could be in. */
-
+
while(parameter!=NULL) {
/* Check tags */
if (parameter->numbertags>0) {
if (tagptr==NULL)
- goto nextloop;
- else if(tagptr->type==TAGTYPE) {
+ goto nextloop;//that means the object has no tag but that param needs tag
+ else if(tagptr->type==TAGTYPE) {//one tag
struct ___TagDescriptor___ * tag=(struct ___TagDescriptor___*) tagptr;
for(i=0;i<parameter->numbertags;i++) {
//slotid is parameter->tagarray[2*i];
int tagid=parameter->tagarray[2*i+1];
if (tagid!=tagptr->flag)
goto nextloop; /*We don't have this tag */
- }
- } else {
+ }
+ } else {//multiple tags
struct ArrayObject * ao=(struct ArrayObject *) tagptr;
for(i=0;i<parameter->numbertags;i++) {
//slotid is parameter->tagarray[2*i];
int tagid=parameter->tagarray[2*i+1];
int j;
for(j=0;j<ao->___cachedCode___;j++) {
- if (tagid==ARRAYGET(ao, struct ___TagDescriptor___*, i)->flag)
+ if (tagid==ARRAYGET(ao, struct ___TagDescriptor___*, j)->flag)
goto foundtag;
}
goto nextloop;
}
}
}
-
+
/* Check flags */
for(i=0;i<parameter->numberofterms;i++) {
int andmask=parameter->intarray[i*2];
int checkmask=parameter->intarray[i*2+1];
- if ((flag&andmask)==checkmask) {
- enqueuetasks(parameter, prevptr, ptr);
+ if ((ptr->flag&andmask)==checkmask) {
+ enqueuetasks(parameter, prevptr, ptr, NULL, 0);
prevptr=parameter;
break;
}
ptr->flagptr=prevptr;
}
}
+
+#ifdef OPTIONAL
+
+int checktags(struct ___Object___ * currobj, struct fsanalysiswrapper * fswrapper) {
+ /* Check Tags */
+ struct ___Object___ * tagptr = currobj->___tags___;
+ if(fswrapper->numtags>0){
+ if (tagptr==NULL)
+ return 0; //that means the object has no tag but that param
+ //needs tag
+ else if(tagptr->type==TAGTYPE) {//one tag
+ if(fswrapper->numtags!=1)
+ return 0; //we don't have the right number of tags
+ struct ___TagDescriptor___ * tag=(struct ___TagDescriptor___*) tagptr;
+ if (fswrapper->tags[0]!=tagptr->flag)
+ return 0;
+ } else { //multiple tags
+ struct ArrayObject * ao=(struct ArrayObject *) tagptr;
+ int tag_counter=0;
+ int foundtag=0;
+
+ if(ao->___length___!=fswrapper->numtags)
+ return 0;//we don't have the right number of tags
+ for(tag_counter=0;tag_counter<fswrapper->numtags;tag_counter++) {
+ int tagid=fswrapper->tags[tag_counter];
+ int j;
+ for(j=0;j<ao->___cachedCode___;j++) {
+ if (tagid==ARRAYGET(ao, struct ___TagDescriptor___*, tag_counter)->flag)
+ return 1;
+ }
+ return 0;
+ }
+ }
+ }
+ return 1;
+}
+
+int getlength(int *flist, int len) {
+ int count=0;
+ int i;
+ for(i=0;i<len;i++) {
+ int size=flist[count];
+ count+=1+size;
+ }
+ return count;
+}
+
+int * domergeor(int *flist1, int len1, int *flist2, int len2) {
+ int size1=getlength(flist1, len1);
+ int size2=getlength(flist2, len2);
+ int *merge=RUNMALLOC((size1+size2)*sizeof(int));
+ memcpy(merge, flist1, size1*sizeof(int));
+ memcpy(&merge[size1], flist2, size2*sizeof(int));
+ return merge;
+}
+
+int domerge(int * flist1, int len1, int *flist2, int len2, int *merge) {
+ int count=0;
+ int i=0;
+ int j=0;
+ while(i<len1||j<len2) {
+ if (i<len1&&(j==len2||flist1[i]<flist2[j])) {
+ if(merge!=NULL) {
+ merge[count]=flist1[i];
+ }
+ i++;
+ count++;
+ } else if (j<len2&&(i==len1||flist2[j]<flist1[i])) {
+ if(merge!=NULL) {
+ merge[count]=flist2[j];
+ }
+ j++;
+ count++;
+ } else if (i<len1&&j<len2&&flist1[i]==flist2[j]) {
+ if(merge!=NULL) {
+ merge[count]=flist1[i];
+ }
+ i++;
+ j++;
+ count++;
+ }
+ }
+ return count;
+}
+
+/* Merge flags from ftlmerge into ftl. */
+void mergeitems(struct failedtasklist *ftl, struct failedtasklist *ftlmerge) {
+ int length=0;
+ int i,j;
+ int *mergedlist;
+ int offset=0;
+ for(i=0;i<ftl->numflags;i++) {
+ int len=ftl->flags[offset++];
+ int offsetmerge=0;
+ for(j=0;j<ftlmerge->numflags;j++) {
+ int lenmerge=ftlmerge->flags[offsetmerge++];
+ length+=1+domerge(&ftl->flags[offset],len,&ftlmerge->flags[offsetmerge],lenmerge, NULL);
+ offsetmerge+=lenmerge;
+ }
+ offset+=len;
+ }
+ mergedlist=RUNMALLOC(sizeof(int)*length);
+
+ offset=0;
+ length=0;
+ for(i=0;i<ftl->numflags;i++) {
+ int len=ftl->flags[offset++];
+ int offsetmerge=0;
+ for(j=0;j<ftlmerge->numflags;j++) {
+ int lenmerge=ftlmerge->flags[offsetmerge++];
+ int size=domerge(&ftl->flags[offset],len,&ftlmerge->flags[offsetmerge],lenmerge,&mergedlist[length+1]);
+ mergedlist[length]=size;
+ length+=size+1;
+ }
+ }
+ RUNFREE(ftl->flags);
+ ftl->flags=mergedlist;
+ ftl->numflags*=ftlmerge->numflags;
+}
+
+void mergefailedlists(struct failedtasklist **andlist, struct failedtasklist *list) {
+ struct failedtasklist *tmpptr;
+ while((*andlist)!=NULL) {
+ struct failedtasklist *searchftl=list;
+ while(searchftl!=NULL) {
+ if ((*andlist)->task==searchftl->task&&
+ (*andlist)->index==searchftl->index) {
+ mergeitems(*andlist, searchftl);
+ break;
+ }
+ searchftl=searchftl->next;
+ }
+ if (searchftl==NULL) {
+ //didn't find andlist
+ tmpptr=*andlist;
+ *andlist=(*andlist)->next;//splice item out of list
+ RUNFREE(tmpptr->flags); //free the item
+ RUNFREE(tmpptr);
+ } else {
+ andlist=&((*andlist)->next); //iterate to next item
+ }
+ }
+ //free the list we're searching
+ while(list!=NULL) {
+ tmpptr=list->next;
+ RUNFREE(list->flags);
+ RUNFREE(list);
+ list=tmpptr;
+ }
+}
+
+struct failedtasklist * processfailstate(struct classanalysiswrapper * classwrapper, struct taskdescriptor *task, int index, struct ___Object___ * currobj, int flagstate) {
+ struct failedtasklist *list=NULL;
+ int i,h;
+ struct fsanalysiswrapper *fswrapper=NULL;
+ for(h=0;h<classwrapper->numfsanalysiswrappers;h++) {
+ struct fsanalysiswrapper * tmp=classwrapper->fsanalysiswrapperarray[h];
+ if (tmp->flags==flagstate&&checktags(currobj, tmp)) {
+ //we only match exactly here
+ fswrapper=tmp;
+ break;
+ }
+ }
+ if (fswrapper==NULL)
+ return list;
+ for(i=0;i<fswrapper->numtaskfailures;i++) {
+ int j;
+ struct taskfailure * taskfail=fswrapper->taskfailurearray[i];
+ if (taskfail->task==task&&taskfail->index==index) {
+ int start=0;
+ while(start<taskfail->numoptionaltaskdescriptors) {
+ struct taskdescriptor *currtask=NULL;
+ struct failedtasklist *tmpftl;
+ int currindex;
+ int totallength=0;
+ int *enterflags;
+ int numenterflags, offset;
+ struct parameterwrapper *pw;
+ for(j=start;j<taskfail->numoptionaltaskdescriptors;j++) {
+ struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[j];
+ if(currtask==NULL) {
+ currtask=otd->task;
+ currindex=otd->index;
+ } else if (currtask!=otd->task||currindex!=otd->index)
+ break;
+ totallength+=otd->numenterflags;
+ }
+ pw=currtask->descriptorarray[currindex]->queue;
+ enterflags=RUNMALLOC(totallength*sizeof(int));
+ numenterflags=j-start;
+ offset=0;
+ for(start;start<j;start++) {
+ struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[start];
+ enterflags[offset++]=otd->numenterflags;
+ memcpy(&enterflags[offset], otd->enterflags, otd->numenterflags*sizeof(int));
+ offset+=otd->numenterflags;
+ }
+ tmpftl=RUNMALLOC(sizeof(struct failedtasklist));
+ tmpftl->next=list;
+ tmpftl->task=currtask;
+ tmpftl->numflags=numenterflags;
+ tmpftl->flags=enterflags;
+ list=tmpftl;
+ }
+ }
+ }
+ return list;
+}
+
+struct failedtasklist * processnormfailstate(struct classanalysiswrapper * classwrapper, struct ___Object___ * currobj, int flagstate) {
+ struct failedtasklist *list=NULL;
+ int i,h;
+ int start=0;
+ struct fsanalysiswrapper *fswrapper=NULL;
+ for(h=0;h<classwrapper->numfsanalysiswrappers;h++) {
+ struct fsanalysiswrapper * tmp=classwrapper->fsanalysiswrapperarray[h];
+ if (tmp->flags==flagstate&&checktags(currobj, tmp)) {
+ //we only match exactly here
+ fswrapper=tmp;
+ break;
+ }
+ }
+ if(fswrapper==NULL)
+ return NULL;
+
+ while(start<fswrapper->numoptionaltaskdescriptors) {
+ struct taskdescriptor *currtask=NULL;
+ struct failedtasklist *tmpftl;
+ int j;
+ int currindex;
+ int totallength=0;
+ int *enterflags;
+ int numenterflags, offset;
+ struct parameterwrapper *pw;
+ for(j=start;j<fswrapper->numoptionaltaskdescriptors;j++) {
+ struct optionaltaskdescriptor *otd=fswrapper->optionaltaskdescriptorarray[j];
+ if(currtask==NULL) {
+ currtask=otd->task;
+ currindex=otd->index;
+ } else if (currtask!=otd->task||currindex!=otd->index)
+ break;
+ totallength+=otd->numenterflags;
+ }
+ pw=currtask->descriptorarray[currindex]->queue;
+ enterflags=RUNMALLOC(totallength*sizeof(int));
+ numenterflags=j-start;
+ offset=0;
+ for(start;start<j;start++) {
+ struct optionaltaskdescriptor *otd=fswrapper->optionaltaskdescriptorarray[start];
+ enterflags[offset++]=otd->numenterflags;
+ memcpy(&enterflags[offset], otd->enterflags, otd->numenterflags*sizeof(int));
+ offset+=otd->numenterflags;
+ }
+ tmpftl=RUNMALLOC(sizeof(struct failedtasklist));
+ tmpftl->next=list;
+ tmpftl->task=currtask;
+ tmpftl->numflags=numenterflags;
+ tmpftl->flags=enterflags;
+ list=tmpftl;
+ }
+ return list;
+}
+
+
+
+void enqueuelist(struct ___Object___ * currobj, struct failedtasklist * andlist) {
+ while(andlist!=NULL) {
+ struct failedtasklist *tmp=andlist;
+ struct parameterwrapper *pw=andlist->task->descriptorarray[andlist->index]->queue;
+ struct parmaeterwrapper *next;
+ int * flags;
+ int numflags;
+ int isnonfailed;
+
+ if (enqueuetasks(pw, currobj->flagptr, currobj, tmp->flags, tmp->numflags))
+ currobj->flagptr=pw;
+
+ andlist=andlist->next;
+ RUNFREE(tmp);
+ }
+}
+
+void enqueueoptional(struct ___Object___ * currobj, int numfailedfses, int * failedfses, struct taskdescriptor * task, int index) {
+ struct classanalysiswrapper * classwrapper=NULL;
+
+ /*test what optionaltaskdescriptors are available, find the class
+ corresponding*/
+ if (classanalysiswrapperarray[currobj->type]!=NULL) {
+ classwrapper = classanalysiswrapperarray[currobj->type];
+ } else
+ return;
-void enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *prevptr, struct ___Object___ *ptr) {
+ if(task!=NULL) {
+ /* We have a failure */
+ if (failedfses==NULL) {
+ /* Failed in normal state */
+ /*first time the method is invoked*/
+ int i,h;
+ struct fsanalysiswrapper *fswrapper=NULL;
+
+ for(h=0;h<classwrapper->numfsanalysiswrappers;h++) {
+ struct fsanalysiswrapper * tmp=classwrapper->fsanalysiswrapperarray[h];
+ if (tmp->flags==currobj->flag&&checktags(currobj, tmp)) {
+ //we only match exactly here
+ fswrapper=tmp;
+ break;
+ }
+ }
+ if(fswrapper==NULL) //nothing to do in this state
+ return;
+ for(i=0;i<fswrapper->numtaskfailures;i++) {
+ int j;
+ struct taskfailure * taskfail=fswrapper->taskfailurearray[i];
+ if (taskfail->task==task&&taskfail->index==index) {
+ int start=0;
+ while(start<taskfail->numoptionaltaskdescriptors) {
+ struct taskdescriptor *currtask=NULL;
+ int currindex;
+ int totallength=0;
+ int *enterflags;
+ int numenterflags, offset;
+ struct parameterwrapper *pw;
+ for(j=start;j<taskfail->numoptionaltaskdescriptors;j++) {
+ struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[j];
+ if(currtask==NULL) {
+ currtask=otd->task;
+ currindex=otd->index;
+ } else if (currtask!=otd->task||currindex!=otd->index)
+ break;
+ totallength+=otd->numenterflags;//1 is to store the lengths
+ }
+ pw=currtask->descriptorarray[currindex]->queue;
+ enterflags=RUNMALLOC((totallength+numenterflags)*sizeof(int));
+ numenterflags=j-start;
+
+ offset=0;
+ for(start;start<j;start++) {
+ struct optionaltaskdescriptor *otd=taskfail->optionaltaskdescriptorarray[start];
+ enterflags[offset++]=otd->numenterflags;
+ memcpy(&enterflags[offset], otd->enterflags, otd->numenterflags*sizeof(int));
+ offset+=otd->numenterflags;
+ }
+ //Enqueue this one
+ if (enqueuetasks(pw, currobj->flagptr, currobj, enterflags, numenterflags))
+ currobj->flagptr=pw;
+ }
+ }
+ }
+ } else {
+ /* Failed in failed state */
+ int i;
+ int offset=0;
+ for(i=0;i<numfailedfses;i++) {
+ int numfses=failedfses[offset++];
+ int j;
+ struct failedtasklist *andlist=NULL;
+ for(j=0;j<numfses;j++) {
+ int flagstate=failedfses[offset++];
+ struct failedtasklist *currlist=processfailstate(classwrapper, task, index, currobj, flagstate);
+ if (andlist==NULL)
+ andlist=currlist;
+ else
+ mergefailedlists(&andlist, currlist);
+ }
+ enqueuelist(currobj, andlist);
+ }
+ }
+ } else {
+ /* No failure, but we are in a failed state */
+ struct parameterwrapper *flagptr=(struct parameterwrapper *)currobj->flagptr;
+
+ /*Remove object from all queues */
+ while(flagptr!=NULL) {
+ struct parameterwrapper *next;
+ int UNUSED, UNUSED2;
+ int * enterflags;
+ ObjectHashget(flagptr->objectset, (int) currobj, (int *) &next, (int *) &enterflags, &UNUSED, &UNUSED2);
+ ObjectHashremove(flagptr->objectset, (int)currobj);
+ if (enterflags!=NULL)
+ free(enterflags);
+ flagptr=next;
+ }
+
+ /* Failed in failed state */
+ int i;
+ int offset=0;
+ for(i=0;i<currobj->numfses;i++) {
+ int numfses=currobj->fses[offset++];
+ int j;
+ struct failedtasklist *andlist=NULL;
+ for(j=0;j<numfses;j++) {
+ int flagstate=currobj->fses[offset++];
+ struct failedtasklist *currlist=processnormfailstate(classwrapper, currobj, flagstate);
+ if (andlist==NULL)
+ andlist=currlist;
+ else
+ mergefailedlists(&andlist, currlist);
+ }
+ enqueuelist(currobj, andlist);
+ }
+ }
+}
+
+
+#endif
+
+int enqueuetasks(struct parameterwrapper *parameter, struct parameterwrapper *prevptr, struct ___Object___ *ptr, int * enterflags, int numenterflags) {
void * taskpointerarray[MAXTASKPARAMS];
+#ifdef OPTIONAL
+ int failed[MAXTASKPARAMS];
+#endif
int j;
int numparams=parameter->task->numParameters;
int numiterators=parameter->task->numTotal-1;
+ int retval=1;
+ int addnormal=1;
+ int adderror=1;
struct taskdescriptor * task=parameter->task;
-
- RuntimeHashadd(parameter->objectset, (int) ptr, (int) prevptr);
-
+
+#ifdef OPTIONAL
+ if (ObjectHashcontainskey(parameter->objectset, (int) ptr)) {
+ /* The object is already here...or it with the existing item */
+ int * oldflags;
+ int oldnumflags;
+ int oldptr;
+ int oldstatus;
+ int *mergedflags;
+ ObjectHashget(parameter->objectset, (int) ptr, & oldptr, (int *) &oldflags, &oldnumflags, &oldstatus);
+ mergedflags=domergeor(oldflags, oldnumflags, enterflags, numenterflags);
+ ObjectHashupdate(parameter->objectset, (int) ptr, oldptr, mergedflags, oldnumflags+numenterflags, oldstatus||(enterflags==NULL));
+
+ RUNFREE(oldflags);
+ RUNFREE(enterflags);
+
+ //only add if truly needed
+ if (oldstatus)
+ addnormal=0;
+ if (oldnumflags>0)
+ adderror=0;
+
+ retval=0;
+ } else {
+#endif
+ ObjectHashadd(parameter->objectset, (int) ptr, (int) prevptr, (int) enterflags, numenterflags, enterflags==NULL);//this add the object to parameterwrapper
+#ifdef OPTIONAL
+ }
+#endif
+
/* Add enqueued object to parameter vector */
taskpointerarray[parameter->slot]=ptr;
+#ifdef OPTIONAL
+ failed[parameter->slot]=(enterflags!=NULL);
+#endif
/* Reset iterators */
for(j=0;j<numiterators;j++) {
/* Find initial state */
for(j=0;j<numiterators;j++) {
backtrackinit:
- if(toiHasNext(¶meter->iterators[j], taskpointerarray))
- toiNext(¶meter->iterators[j], taskpointerarray);
+ if(toiHasNext(¶meter->iterators[j], taskpointerarray OPTARG(failed))){
+ toiNext(¶meter->iterators[j], taskpointerarray OPTARG(failed));
+ }
else if (j>0) {
/* Need to backtrack */
toiReset(¶meter->iterators[j]);
goto backtrackinit;
} else {
/* Nothing to enqueue */
- return;
+ return retval;
}
}
while(1) {
/* Enqueue current state */
+ int launch = 0;
struct taskparamdescriptor *tpd=RUNMALLOC(sizeof(struct taskparamdescriptor));
tpd->task=task;
tpd->numParameters=numiterators+1;
tpd->parameterArray=RUNMALLOC(sizeof(void *)*(numiterators+1));
- for(j=0;j<=numiterators;j++)
- tpd->parameterArray[j]=taskpointerarray[j];
-
+#ifdef OPTIONAL
+ tpd->failed=RUNMALLOC(sizeof(int)*(numiterators+1));
+#endif
+ for(j=0;j<=numiterators;j++){
+ tpd->parameterArray[j]=taskpointerarray[j];//store the actual parameters
+#ifdef OPTIONAL
+ tpd->failed[j]=failed[j];
+ if (failed[j]!=0&&failed[j]!=1) {
+ printf("BAD\n");
+ }
+#endif
+ }
/* Enqueue task */
- if (!gencontains(failedtasks, tpd)&&!gencontains(activetasks,tpd)) {
+ if ((!gencontains(failedtasks, tpd)&&!gencontains(activetasks,tpd))) {
genputtable(activetasks, tpd, tpd);
} else {
RUNFREE(tpd->parameterArray);
+#ifdef OPTIONAL
+ RUNFREE(tpd->failed);
+#endif
RUNFREE(tpd);
}
-
+
/* This loop iterates to the next parameter combination */
if (numiterators==0)
- return;
+ return retval;
for(j=numiterators-1; j<numiterators;j++) {
backtrackinc:
- if(toiHasNext(¶meter->iterators[j], taskpointerarray))
- toiNext(¶meter->iterators[j], taskpointerarray);
+ if(toiHasNext(¶meter->iterators[j], taskpointerarray OPTARG(failed))){
+ toiNext(¶meter->iterators[j], taskpointerarray OPTARG(failed));
+ }
else if (j>0) {
/* Need to backtrack */
toiReset(¶meter->iterators[j]);
goto backtrackinc;
} else {
/* Nothing more to enqueue */
- return;
+ return retval;
}
}
}
+ return retval;
}
/* Handler for signals. The signals catch null pointer errors and
arithmatic errors. */
void myhandler(int sig, siginfo_t *info, void *uap) {
+ sigset_t toclear;
#ifdef DEBUG
printf("sig=%d\n",sig);
printf("signal\n");
#endif
+ sigemptyset(&toclear);
+ sigaddset(&toclear, sig);
+ sigprocmask(SIG_UNBLOCK, &toclear,NULL);
longjmp(error_handler,1);
}
#define OFFSET 0
#endif
+#ifdef OPTIONAL
+ int * fsescopy(int *src, int len) {
+ int *dst;
+ if (src==NULL)
+ return NULL;
+ dst=RUNMALLOC(len*sizeof(int));
+ memcpy(dst, src, len*sizeof(int));
+ return dst;
+ }
+#endif
+
void executetasks() {
void * taskpointerarray[MAXTASKPARAMS+OFFSET];
+#ifdef OPTIONAL
+ int * fsesarray[MAXTASKPARAMS];
+ int * oldfsesarray[MAXTASKPARAMS];
+ int numfsesarray[MAXTASKPARAMS];
+#endif
/* Set up signal handlers */
struct sigaction sig;
void * objptr;
// printf("Setting fd %d\n",fd);
if (RuntimeHashget(fdtoobject, fd,(int *) &objptr)) {
- intflagorand(objptr,1,0xFFFFFFFF); /* Set the first flag to 1 */
+ if(intflagorand(objptr,1,0xFFFFFFFF)) { /* Set the first flag to 1 */
+ enqueueObject(objptr);
+ }
}
}
}
int i;
currtpd=(struct taskparamdescriptor *) getfirstkey(activetasks);
genfreekey(activetasks, currtpd);
-
- /* Check if this task has failed */
+
+ /* Check if this task has failed, allow a task that contains optional objects to fire */
if (gencontains(failedtasks, currtpd)) {
// Free up task parameter descriptor
RUNFREE(currtpd->parameterArray);
+#ifdef OPTIONAL
+ RUNFREE(currtpd->failed);
+#endif
RUNFREE(currtpd);
goto newtask;
}
int numparams=currtpd->task->numParameters;
int numtotal=currtpd->task->numTotal;
-
+
/* Make sure that the parameters are still in the queues */
for(i=0;i<numparams;i++) {
void * parameter=currtpd->parameterArray[i];
struct parameterwrapper *pw=(struct parameterwrapper *) pd->queue;
int j;
/* Check that object is still in queue */
- if (!RuntimeHashcontainskey(pw->objectset, (int) parameter)) {
- RUNFREE(currtpd->parameterArray);
- RUNFREE(currtpd);
- goto newtask;
+#ifdef OPTIONAL
+ {
+ int UNUSED, UNUSED2;
+ int *flags;
+ int numflags, isnonfailed;
+ int failed=currtpd->failed[i];
+ if (!ObjectHashget(pw->objectset, (int) parameter, &UNUSED, (int *) &flags, &numflags, &isnonfailed)) {
+ RUNFREE(currtpd->parameterArray);
+ RUNFREE(currtpd->failed);
+ RUNFREE(currtpd);
+ goto newtask;
+ } else {
+ if (failed&&(flags!=NULL)) {
+ //Failed parameter
+ fsesarray[i]=flags;
+ numfsesarray[i]=numflags;
+ } else if (!failed && isnonfailed) {
+ //Non-failed parameter
+ fsesarray[i]=NULL;
+ numfsesarray[i]=0;
+ } else {
+ RUNFREE(currtpd->parameterArray);
+ RUNFREE(currtpd->failed);
+ RUNFREE(currtpd);
+ goto newtask;
+ }
+ }
}
+#else
+ {
+ if (!ObjectHashcontainskey(pw->objectset, (int) parameter)) {
+ RUNFREE(currtpd->parameterArray);
+ RUNFREE(currtpd);
+ goto newtask;
+ }
+ }
+#endif
+ parameterpresent:
+ ;
/* Check that object still has necessary tags */
for(j=0;j<pd->numbertags;j++) {
int slotid=pd->tagarray[2*j]+numparams;
struct ___TagDescriptor___ *tagd=currtpd->parameterArray[slotid];
if (!containstag(parameter, tagd)) {
RUNFREE(currtpd->parameterArray);
+#ifdef OPTIONAL
+ RUNFREE(currtpd->failed);
+#endif
RUNFREE(currtpd);
goto newtask;
}
void ** checkpoint=makecheckpoint(currtpd->task->numParameters, currtpd->parameterArray, forward, reverse);
int x;
if (x=setjmp(error_handler)) {
+ int counter;
/* Recover */
- int h;
#ifdef DEBUG
printf("Fatal Error=%d, Recovering!\n",x);
#endif
genputtable(failedtasks,currtpd,currtpd);
restorecheckpoint(currtpd->task->numParameters, currtpd->parameterArray, checkpoint, forward, reverse);
+
+#ifdef OPTIONAL
+ for(counter=0; counter<currtpd->task->numParameters; counter++){
+ //enqueue as failed
+ enqueueoptional(currtpd->parameterArray[counter], numfsesarray[counter], fsesarray[counter], currtpd->task, counter);
+
+ //free fses copies
+ if (fsesarray[counter]!=NULL)
+ RUNFREE(fsesarray[counter]);
+ }
+#endif
freeRuntimeHash(forward);
freeRuntimeHash(reverse);
freemalloc();
}
/* Actually call task */
#ifdef PRECISE_GC
- ((int *)taskpointerarray)[0]=currtpd->task->numParameters;
+ ((int *)taskpointerarray)[0]=currtpd->numParameters;
taskpointerarray[1]=NULL;
#endif
-
- if (debugtask) {
+#ifdef OPTIONAL
+ //get the task flags set
+ for(i=0;i<numparams;i++) {
+ oldfsesarray[i]=((struct ___Object___ *)taskpointerarray[i+OFFSET])->fses;
+ fsesarray[i]=fsescopy(fsesarray[i], numfsesarray[i]);
+ ((struct ___Object___ *)taskpointerarray[i+OFFSET])->fses=fsesarray[i];
+ }
+#endif
+ if(debugtask){
printf("ENTER %s count=%d\n",currtpd->task->name, (instaccum-instructioncount));
((void (*) (void **)) currtpd->task->taskptr)(taskpointerarray);
printf("EXIT %s count=%d\n",currtpd->task->name, (instaccum-instructioncount));
} else
((void (*) (void **)) currtpd->task->taskptr)(taskpointerarray);
+
+#ifdef OPTIONAL
+ for(i=0;i<numparams;i++) {
+ //free old fses
+ if(oldfsesarray[i]!=NULL)
+ RUNFREE(oldfsesarray[i]);
+ }
+#endif
+
freeRuntimeHash(forward);
freeRuntimeHash(reverse);
freemalloc();
// Free up task parameter descriptor
RUNFREE(currtpd->parameterArray);
+#ifdef OPTIONAL
+ RUNFREE(currtpd->failed);
+#endif
RUNFREE(currtpd);
forward=NULL;
reverse=NULL;
}
}
}
-
+
/* This function processes an objects tags */
void processtags(struct parameterdescriptor *pd, int index, struct parameterwrapper *parameter, int * iteratorcount, int *statusarray, int numparams) {
int i;
-
+
for(i=0;i<pd->numbertags;i++) {
int slotid=pd->tagarray[2*i];
int tagid=pd->tagarray[2*i+1];
void processobject(struct parameterwrapper *parameter, int index, struct parameterdescriptor *pd, int *iteratorcount, int * statusarray, int numparams) {
int i;
int tagcount=0;
- struct RuntimeHash * objectset=((struct parameterwrapper *)pd->queue)->objectset;
+ struct ObjectHash * objectset=((struct parameterwrapper *)pd->queue)->objectset;
parameter->iterators[*iteratorcount].istag=0;
parameter->iterators[*iteratorcount].slot=index;
}
}
-
+ void printdebug() {
+ int i;
+ int j;
+ for(i=0;i<numtasks;i++) {
+ struct taskdescriptor * task=taskarray[i];
+ printf("%s\n", task->name);
+ for(j=0;j<task->numParameters;j++) {
+ struct parameterdescriptor *param=task->descriptorarray[j];
+ struct parameterwrapper *parameter=param->queue;
+ struct ObjectHash * set=parameter->objectset;
+ struct ObjectIterator objit;
+ printf(" Parameter %d\n", j);
+ ObjectHashiterator(set, &objit);
+ while(ObjhasNext(&objit)) {
+ struct ___Object___ * obj=(struct ___Object___ *)Objkey(&objit);
+ struct ___Object___ * tagptr=obj->___tags___;
+ int nonfailed=Objdata4(&objit);
+ int numflags=Objdata3(&objit);
+ int flags=Objdata2(&objit);
+ Objnext(&objit);
+ printf(" Contains %lx\n", obj);
+ printf(" flag=%d\n", obj->flag);
+#ifdef OPTIONAL
+ printf(" flagsstored=%x\n",flags);
+ printf(" numflags=%d\n", numflags);
+ printf(" nonfailed=%d\n",nonfailed);
+#endif
+ if (tagptr==NULL) {
+ } else if (tagptr->type==TAGTYPE) {
+ printf(" tag=%lx\n",tagptr);
+ } else {
+ int tagindex=0;
+ struct ArrayObject *ao=(struct ArrayObject *)tagptr;
+ for(;tagindex<ao->___cachedCode___;tagindex++) {
+ printf(" tag=%lx\n",ARRAYGET(ao, struct ___TagDescriptor___*, tagindex));
+ }
+ }
+ }
+ }
+ }
+ }
/* This function processes the task information to create queues for
void processtasks() {
int i;
for(i=0;i<numtasks;i++) {
- struct taskdescriptor * task=taskarray[i];
+ struct taskdescriptor * task=taskarray[i];
int j;
for(j=0;j<task->numParameters;j++) {
struct parameterwrapper ** ptr=&objectqueues[param->type];
param->queue=parameter;
- parameter->objectset=allocateRuntimeHash(10);
+ parameter->objectset=allocateObjectHash(10);
parameter->numberofterms=param->numberterms;
parameter->intarray=param->intarray;
parameter->numbertags=param->numbertags;
parameter->tagarray=param->tagarray;
parameter->task=task;
+ parameter->slot=j;
/* Link new queue in */
while((*ptr)!=NULL)
ptr=&((*ptr)->next);
/* Build iterators for parameters */
for(j=0;j<task->numParameters;j++) {
struct parameterdescriptor *param=task->descriptorarray[j];
- struct parameterwrapper *parameter=param->queue;
- parameter->slot=j;
+ struct parameterwrapper *parameter=param->queue;
builditerators(task, j, parameter);
}
}
it->tagobjindex=0;
} else if (it->numtags>0) {
it->tagobjindex=0;
+#ifdef OPTIONAL
+ it->failedstate=0;
+#endif
} else {
- RuntimeHashiterator(it->objectset, &it->it);
+ ObjectHashiterator(it->objectset, &it->it);
+#ifdef OPTIONAL
+ it->failedstate=0;
+#endif
}
}
-int toiHasNext(struct tagobjectiterator *it, void ** objectarray) {
+int toiHasNext(struct tagobjectiterator *it, void ** objectarray OPTARG(int * failed)) {
if (it->istag) {
/* Iterate tag */
/* Get object with tags */
if (objptr->type!=OBJECTARRAYTYPE) {
if (it->tagobjindex>0)
return 0;
- if (!RuntimeHashcontainskey(it->objectset, (int) objptr))
+ if (!ObjectHashcontainskey(it->objectset, (int) objptr))
return 0;
for(i=1;i<it->numtags;i++) {
struct ___TagDescriptor___ *tag2=objectarray[it->tagbindings[i]];
if (!containstag(objptr,tag2))
return 0;
}
+#ifdef OPTIONAL
+ if (it->failedstate==1) {
+ int UNUSED, UNUSED2;
+ int * flags;
+ int isnonfailed;
+ ObjectHashget(it->objectset, (int) objptr, &UNUSED, (int *) &flags, &UNUSED2, &isnonfailed);
+ if (flags!=NULL) {
+ return 1;
+ } else {
+ it->tagobjindex++;
+ it->failedstate=0;
+ return 0;
+ }
+ } else {
+ int UNUSED, UNUSED2;
+ int * flags;
+ int isnonfailed;
+ ObjectHashget(it->objectset, (int) objptr, &UNUSED, (int *) &flags, &UNUSED2, &isnonfailed);
+ if (!isnonfailed) {
+ it->failedstate=1;
+ }
+ return 1;
+ }
+#endif
return 1;
} else {
struct ArrayObject *ao=(struct ArrayObject *) objptr;
int tagindex;
int i;
+#ifdef OPTIONAL
+ if (it->failedstate==1) {
+ int UNUSED, UNUSED2;
+ int * flags;
+ int isnonfailed;
+ struct ___Object___ *objptr=ARRAYGET(ao, struct ___Object___*, it->tagobjindex);
+ ObjectHashget(it->objectset, (int) objptr, &UNUSED, (int *) &flags, &UNUSED2, &isnonfailed);
+ if (flags!=NULL) {
+ return 1;
+ } else {
+ it->failedstate=0;
+ it->tagobjindex++;
+ }
+ }
+#endif
for(tagindex=it->tagobjindex;tagindex<ao->___cachedCode___;tagindex++) {
struct ___Object___ *objptr=ARRAYGET(ao, struct ___Object___*, tagindex);
- if (!RuntimeHashcontainskey(it->objectset, (int) objptr))
+ if (!ObjectHashcontainskey(it->objectset, (int) objptr))
continue;
for(i=1;i<it->numtags;i++) {
struct ___TagDescriptor___ *tag2=objectarray[it->tagbindings[i]];
if (!containstag(objptr,tag2))
goto nexttag;
}
+#ifdef OPTIONAL
+ {
+ int UNUSED, UNUSED2;
+ int flags, isnonfailed;
+ struct ___Object___ *objptr=ARRAYGET(ao, struct ___Object___*, tagindex);
+ ObjectHashget(it->objectset, (int) objptr, &UNUSED, &flags, &UNUSED2, &isnonfailed);
+ if (!isnonfailed) {
+ it->failedstate=1;
+ }
+ }
+#endif
+ it->tagobjindex=tagindex;
return 1;
nexttag:
;
return 0;
}
} else {
- return RunhasNext(&it->it);
+#ifdef OPTIONAL
+ if (it->failedstate==1) {
+ if (Objdata2(&it->it))
+ return 1;
+ else {
+ it->failedstate=0;
+ Objnext(&it->it);
+ }
+ }
+ if (ObjhasNext(&it->it)) {
+ if (!Objdata4(&it->it)) {
+ //failed state only
+ it->failedstate=1;
+ }
+ return 1;
+ } else
+ return 0;
+#else
+ return ObjhasNext(&it->it);
+#endif
}
}
return objptr==ptr;
}
-void toiNext(struct tagobjectiterator *it , void ** objectarray) {
+void toiNext(struct tagobjectiterator *it , void ** objectarray OPTARG(int * failed)) {
/* hasNext has all of the intelligence */
if(it->istag) {
/* Iterate tag */
/* Get object with tags */
struct ___Object___ *obj=objectarray[it->tagobjectslot];
struct ___Object___ *tagptr=obj->___tags___;
+#ifdef OPTIONAL
+ failed[it->slot]=0; //have to set it to something
+#endif
if (tagptr->type==TAGTYPE) {
it->tagobjindex++;
objectarray[it->slot]=tagptr;
struct ___TagDescriptor___ *tag=objectarray[it->tagbindings[0]];
struct ___Object___ *objptr=tag->flagptr;
if (objptr->type!=OBJECTARRAYTYPE) {
+#ifdef OPTIONAL
+ failed[it->slot]=it->failedstate;
+ objectarray[it->slot]=objptr;
+ if (it->failedstate==0) {
+ it->failedstate=1;
+ } else {
+ it->failedstate=0;
+ it->tagobjindex++;
+ }
+#else
it->tagobjindex++;
objectarray[it->slot]=objptr;
+#endif
} else {
struct ArrayObject *ao=(struct ArrayObject *) objptr;
+#ifdef OPTIONAL
+ failed[it->slot]=it->failedstate;
+ objectarray[it->slot]=ARRAYGET(ao, struct ___Object___ *, it->tagobjindex);
+ if (it->failedstate==0) {
+ it->failedstate=1;
+ } else {
+ it->failedstate=0;
+ it->tagobjindex++;
+ }
+#else
objectarray[it->slot]=ARRAYGET(ao, struct ___Object___ *, it->tagobjindex++);
+#endif
}
} else {
/* Iterate object */
- objectarray[it->slot]=(void *)Runkey(&it->it);
- Runnext(&it->it);
+ void * tmpp = (void *) Objkey(&it->it);
+ objectarray[it->slot]=tmpp;
+#ifdef OPTIONAL
+ failed[it->slot]=it->failedstate;
+ if (it->failedstate==0) {
+ it->failedstate=1;
+ } else {
+ it->failedstate=0;
+ Objnext(&it->it);
+ }
+#else
+ Objnext(&it->it);
+#endif
}
}
-
-
#endif
projects / IRC.git / blobdiff