more runtime stuff

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index a86a8c39a08c02d9d36881c4132c2964a0be598d..069043b0c93462c929f216cd6a56842bc2dd96e3 100644 (file)
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -21,7 +21,7 @@ public class BuildCode {
     public static String arraytype="ArrayObject";
     Virtual virtualcalls;
     TypeUtil typeutil;
-
+    private int maxtaskparams=0;
 
     public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil) {
        state=st;
@@ -114,6 +114,7 @@ public class BuildCode {
                outtask.println("int type;");
                outtask.println("int numberterms;");
                outtask.println("int *intarray;");
+               outtask.println("void * queue;");
                outtask.println("};");
 
                outtask.println("struct taskdescriptor {");
@@ -132,7 +133,7 @@ public class BuildCode {
            ClassDescriptor cn=(ClassDescriptor)it.next();
            generateCallStructs(cn, outclassdefs, outstructs, outmethodheader);
        }
-       outstructs.close();
+
 
        if (state.TASK) {
            /* Map flags to integers */
@@ -212,6 +213,9 @@ public class BuildCode {
            }
            outmethod.println("}");
        }
+       if (state.TASK)
+           outstructs.println("#define MAXTASKPARAMS "+maxtaskparams);
+       outstructs.close();
        outmethod.close();
     }
 
@@ -250,7 +254,8 @@ public class BuildCode {
            output.println("struct parameterdescriptor parameter_"+i+"_"+task.getSafeSymbol()+"={");
            output.println("/* type */"+param_type.getClassDesc().getId()+",");
            output.println("/* number of DNF terms */"+dflag.size()+",");
-           output.println("parameterdnf_"+i+"_"+task.getSafeSymbol());
+           output.println("parameterdnf_"+i+"_"+task.getSafeSymbol()+",");
+           output.println("0");
            output.println("};");
        }
 
@@ -585,6 +590,7 @@ public class BuildCode {
            /* Output parameter structure */
            if (GENERATEPRECISEGC) {
                output.println("struct "+task.getSafeSymbol()+"_params {");
+
                output.println("  int type;");
                output.println("  void * next;");
                for(int i=0;i<objectparams.numPointers();i++) {
@@ -592,6 +598,8 @@ public class BuildCode {
                    output.println("  struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+";");
                }
                output.println("};\n");
+               if (objectparams.numPointers()>maxtaskparams)
+                   maxtaskparams=objectparams.numPointers();
            }
 
            /* Output temp structure */
@@ -615,20 +623,8 @@ public class BuildCode {
            boolean printcomma=false;
            if (GENERATEPRECISEGC) {
                headersout.print("struct "+task.getSafeSymbol()+"_params * "+paramsprefix);
-               printcomma=true;
-           }
-
-           //output parameter list
-           for(int i=0;i<objectparams.numPrimitives();i++) {
-               TempDescriptor temp=objectparams.getPrimitive(i);
-               if (printcomma)
-                   headersout.print(", ");
-               printcomma=true;
-               if (temp.getType().isClass()||temp.getType().isArray())
-                   headersout.print("struct " + temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
-               else
-                   headersout.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
-           }
+           } else
+               headersout.print("void * parameterarray[]");
            headersout.println(");\n");
        }
     }
@@ -646,7 +642,6 @@ public class BuildCode {
        generateHeader(md!=null?md:task,output);
 
        /* Print code */
-       output.println(" {");
        
        if (GENERATEPRECISEGC) {
            if (md!=null)
@@ -1043,17 +1038,27 @@ public class BuildCode {
            printcomma=true;
        } 
 
-       for(int i=0;i<objectparams.numPrimitives();i++) {
-           TempDescriptor temp=objectparams.getPrimitive(i);
-           if (printcomma)
-               output.print(", ");
-           printcomma=true;
-           if (temp.getType().isClass()||temp.getType().isArray())
-               output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
-           else
-               output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
-       }
-       output.print(")");
+       if (md!=null) {
+           for(int i=0;i<objectparams.numPrimitives();i++) {
+               TempDescriptor temp=objectparams.getPrimitive(i);
+               if (printcomma)
+                   output.print(", ");
+               printcomma=true;
+               if (temp.getType().isClass()||temp.getType().isArray())
+                   output.print("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol());
+               else
+                   output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
+           }
+           output.println(") {");
+       } else if (!GENERATEPRECISEGC) {
+           output.println("void * parameterarray[]) {");
+           for(int i=0;i<objectparams.numPrimitives();i++) {
+               TempDescriptor temp=objectparams.getPrimitive(i);
+               output.println("struct "+temp.getType().getSafeSymbol()+" * "+temp.getSafeSymbol()+"=parameterarray["+i+"];");
+           }
+           if (objectparams.numPrimitives()>maxtaskparams)
+               maxtaskparams=objectparams.numPrimitives();
+       } else output.println(" {");
     }
 
     public void generateFlatFlagActionNode(FlatMethod fm, FlatFlagActionNode ffan, PrintWriter output) {

diff --git a/Robust/src/Runtime/runtime.c b/Robust/src/Runtime/runtime.c
index 4272a0e9ef379c332718d944cc23f4ff132b1666..616754fc403fb3c8061d0c343bc1e0ca63b69755 100644 (file)
--- a/Robust/src/Runtime/runtime.c
+++ b/Robust/src/Runtime/runtime.c
@@ -3,25 +3,29 @@
 #include <string.h>
 
 extern int classsize[];
-#ifdef BOEHM_GC
-#include "gc.h"
-#define FREEMALLOC(x) GC_malloc(x)
-#else
-#define FREEMALLOC(x) calloc(1,x)
-#endif
+#include "mem.h"
 
 #ifdef TASK
-#include "tasks.h"
+#include "Queue.h"
+#include "SimpleHash.h"
+#include "task.h"
+struct SimpleHash * activetasks;
+struct parameterwrapper * objectqueues[NUMCLASSES];
 
 int main(int argc, char **argv) {
   int i;
   /* Allocate startup object */
   struct ___StartupObject___ *startupobject=(struct ___StartupObject___*) allocate_new(STARTUPTYPE);
+  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc); 
+
+  activetasks=allocateSimpleHash(50);
+
   /* Set flags */
+  processtasks();
   flagorand(startupobject,1,0xFFFFFFFF);
 
   /* Build array of strings */
-  struct ArrayObject * stringarray=allocate_newarray(STRINGARRAYTYPE, argc); 
+
   startupobject->___parameters___=stringarray;
 
   for(i=0;i<argc;i++) {
@@ -29,27 +33,92 @@ int main(int argc, char **argv) {
     struct ___String___ *newstring=NewString(argv[i],length);
     ((void **)(((char *)& stringarray->___length___)+sizeof(int)))[i]=newstring;
   }
-  processtasks();
+  executetasks();
 }
 
 void flagorand(void * ptr, int ormask, int andmask) {
-  ((int *)ptr)[1]|=ormask;
-  ((int *)ptr)[1]&=andmask;
+  int flag=((int *)ptr)[1];
+  struct QueueItem *flagptr=(struct QueueItem *)(((int*)ptr)[2]);
+  flag|=ormask;
+  flag&=andmask;
+  ((int*)ptr)[1]=flag;
+  /*Remove from all queues */
+  while(flagptr!=NULL) {
+    struct QueueItem * next=flagptr->nextqueue;
+    removeItem(flagptr->queue, flagptr);
+    flagptr=next;
+  }
+  
+  {
+    struct QueueItem *tmpptr;
+    struct parameterwrapper * parameter=objectqueues[((int *)ptr)[0]];
+    int i;
+    flagptr=NULL;
+    for(i=0;i<parameter->numberofterms;i++) {
+      int andmask=parameter->intarray[i*2];
+      int checkmask=parameter->intarray[i*2+1];
+      if ((flag&andmask)==checkmask) {
+       struct QueueItem * qitem=addNewItem(parameter->queue, ptr);
+       if (flagptr==NULL) {
+         flagptr=qitem;
+         tmpptr=flagptr;
+       } else {
+         tmpptr->nextqueue=qitem;
+         tmpptr=qitem;
+       }
+       SimpleHashadd(activetasks, (int)parameter->task, (int)parameter->task);
+       break;
+      }
+    }
+    ((struct QueueItem **)ptr)[2]=flagptr;
+  }
+}
+
+void executetasks() {
+  void * pointerarray[MAXTASKPARAMS];
+  while(1) {
+  newtask:
+    {
+    struct taskdescriptor * task=(struct taskdescriptor *) SimpleHashfirstkey(activetasks);
+    int i;
+    if (task==NULL)
+      break;
+    for(i=0;i<task->numParameters;i++) {
+      struct parameterwrapper * parameter=(struct parameterwrapper *) task->descriptorarray[i]->queue;
+      struct Queue * queue=parameter->queue;
+      if (isEmpty(queue)) {
+       SimpleHashremove(activetasks, (int)task, (int)task);
+       goto newtask;
+      }
+      pointerarray[i]=getTail(queue)->objectptr;
+    }
+    ((void (*) (void **)) task->taskptr)(pointerarray);
+    }
+  }
 }
 
 void processtasks() {
   int i;
-
   for(i=0;i<numtasks;i++) {
     struct taskdescriptor * task=taskarray[i];
     int j;
 
     for(j=0;j<task->numParameters;j++) {
       struct parameterdescriptor *param=task->descriptorarray[j];
-      
+      struct parameterwrapper * parameter=RUNMALLOC(sizeof(struct parameterwrapper));
+      struct parameterwrapper ** ptr=&objectqueues[param->type];
+
+      param->queue=parameter;
+      parameter->queue=createQueue();
+      parameter->numberofterms=param->numberterms;
+      parameter->intarray=param->intarray;
+      parameter->task=task;
+      /* Link new queue in */
+      while(*ptr!=NULL)
+       ptr=&((*ptr)->next);
+      (*ptr)=parameter;
     }
   }
-
 }
 #endif
 

diff --git a/Robust/src/Runtime/runtime.h b/Robust/src/Runtime/runtime.h
index c3d195279c60dd5cad7b1686bf2f7004b708abd0..9e5dc81c220d2aae6d2090d6ce8c2429b2a9ebb3 100644 (file)
--- a/Robust/src/Runtime/runtime.h
+++ b/Robust/src/Runtime/runtime.h
@@ -1,7 +1,5 @@
 #ifndef RUNTIME
 #define RUNTIME
-#include<stdlib.h>
-#include<stdio.h>
 
 
 void * allocate_new(int type);
@@ -10,7 +8,20 @@ struct ___String___ * NewString(char *str,int length);
 
 void failedboundschk();
 void failednullptr();
+
+#ifdef TASK
+#include "Queue.h"
 void flagorand(void * ptr, int ormask, int andmask);
+void executetasks();
+void processtasks();
 
+struct parameterwrapper {
+  struct parameterwrapper *next;
+  struct Queue * queue;
+  int numberofterms;
+  int * intarray;
+  struct taskdescriptor * task;
+}
+#endif
 
 #endif

diff --git a/Robust/src/buildscripttask b/Robust/src/buildscripttask
index fc37f883e960f501ed094368039f9c7b5294c5f5..ff598b7400e8b8344beda750c43c356edaf7146c 100755 (executable)
--- a/Robust/src/buildscripttask
+++ b/Robust/src/buildscripttask
@@ -4,4 +4,4 @@ MAINFILE=$1
 shift
 mkdir tmpbuilddirectory
 java -cp $ROBUSTROOT/../cup/:$ROBUSTROOT Main.Main -classlibrary $ROBUSTROOT/ClassLibrary/ -dir tmpbuilddirectory -task $@
-gcc -I$ROBUSTROOT/Runtime -Itmpbuilddirectory -O0 -DTASK -g tmpbuilddirectory/methods.c $ROBUSTROOT/Runtime/runtime.c -o $MAINFILE.bin
\ No newline at end of file
+gcc -I$ROBUSTROOT/Runtime -Itmpbuilddirectory -O0 -DTASK -g tmpbuilddirectory/methods.c $ROBUSTROOT/Runtime/runtime.c $ROBUSTROOT/Runtime/Queue.c $ROBUSTROOT/Runtime/SimpleHash.c -o $MAINFILE.bin
\ No newline at end of file