check in checkpoint code

diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 069043b0c93462c929f216cd6a56842bc2dd96e3..94f6e620f7626c1a1407d65dad5858bed318bd60 100644 (file)
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -22,6 +22,8 @@ public class BuildCode {
     Virtual virtualcalls;
     TypeUtil typeutil;
     private int maxtaskparams=0;
+    ClassDescriptor[] cdarray;
+    TypeDescriptor[] arraytable;
 
     public BuildCode(State st, Hashtable temptovar, TypeUtil typeutil) {
        state=st;
@@ -153,9 +155,13 @@ public class BuildCode {
        outmethod.println("#include \"virtualtable.h\"");
        outmethod.println("#include <runtime.h>");
        outclassdefs.println("extern int classsize[];");
+       outclassdefs.println("extern int * pointerarray[];");
 
        //Store the sizes of classes & array elements
        generateSizeArray(outmethod);
+       
+       //Store the layout of classes
+       generateLayoutStructs(outmethod);
 
        /* Generate code for methods */
        Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
@@ -344,7 +350,7 @@ public class BuildCode {
     private void generateSizeArray(PrintWriter outclassdefs) {
        outclassdefs.print("int classsize[]={");
        Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
-       ClassDescriptor[] cdarray=new ClassDescriptor[state.numClasses()];
+       cdarray=new ClassDescriptor[state.numClasses()];
        while(it.hasNext()) {
            ClassDescriptor cd=(ClassDescriptor)it.next();
            cdarray[cd.getId()]=cd;
@@ -357,19 +363,19 @@ public class BuildCode {
            needcomma=true;
        }
 
-       TypeDescriptor[] sizetable=new TypeDescriptor[state.numArrays()];
+       arraytable=new TypeDescriptor[state.numArrays()];
 
        Iterator arrayit=state.getArrayIterator();
        while(arrayit.hasNext()) {
            TypeDescriptor td=(TypeDescriptor)arrayit.next();
            int id=state.getArrayNumber(td);
-           sizetable[id]=td;
+           arraytable[id]=td;
        }
        
        for(int i=0;i<state.numArrays();i++) {
            if (needcomma)
                outclassdefs.print(", ");
-           TypeDescriptor tdelement=sizetable[i].dereference();
+           TypeDescriptor tdelement=arraytable[i].dereference();
            if (tdelement.isArray()||tdelement.isClass())
                outclassdefs.print("sizeof(void *)");
            else
@@ -397,7 +403,7 @@ public class BuildCode {
        for(int i=0;i<fm.numParameters();i++) {
            TempDescriptor temp=fm.getParameter(i);
            TypeDescriptor type=temp.getType();
-           if (type.isPtr()&&GENERATEPRECISEGC)
+           if ((type.isPtr()||type.isArray())&&GENERATEPRECISEGC)
                objectparams.addPtr(temp);
            else
                objectparams.addPrim(temp);
@@ -415,7 +421,7 @@ public class BuildCode {
            for(int i=0;i<writes.length;i++) {
                TempDescriptor temp=writes[i];
                TypeDescriptor type=temp.getType();
-               if (type.isPtr()&&GENERATEPRECISEGC)
+               if ((type.isPtr()||type.isArray())&&GENERATEPRECISEGC)
                    objecttemps.addPtr(temp);
                else
                    objecttemps.addPrim(temp);
@@ -423,6 +429,55 @@ public class BuildCode {
        }
     }
     
+    private void generateLayoutStructs(PrintWriter output) {
+       Iterator it=state.getClassSymbolTable().getDescriptorsIterator();
+       while(it.hasNext()) {
+           ClassDescriptor cn=(ClassDescriptor)it.next();
+           output.println("int "+cn.getSafeSymbol()+"_pointers[]={");
+           Iterator allit=cn.getFieldTable().getAllDescriptorsIterator();
+           int count=0;
+           while(allit.hasNext()) {
+               FieldDescriptor fd=(FieldDescriptor)allit.next();
+               TypeDescriptor type=fd.getType();
+               if (type.isPtr()||type.isArray())
+                   count++;
+           }
+           output.print(count);
+           allit=cn.getFieldTable().getAllDescriptorsIterator();
+           while(allit.hasNext()) {
+               FieldDescriptor fd=(FieldDescriptor)allit.next();
+               TypeDescriptor type=fd.getType();
+               if (type.isPtr()||type.isArray()) {
+                   output.println(",");
+                   output.print("((int)&(((struct "+cn.getSafeSymbol() +" *)0)->"+fd.getSafeSymbol()+"))");
+               }
+           }
+           output.println("};");
+       }
+       output.println("int * pointerarray[]={");
+       boolean needcomma=false;
+       for(int i=0;i<state.numClasses();i++) {
+           ClassDescriptor cn=cdarray[i];
+           if (needcomma)
+               output.println(",");
+           needcomma=true;
+           output.print(cn.getSafeSymbol()+"_pointers");
+       }
+
+       for(int i=0;i<state.numArrays();i++) {
+           if (needcomma)
+               output.println(",");
+           TypeDescriptor tdelement=arraytable[i].dereference();
+           if (tdelement.isArray()||tdelement.isClass())
+               output.print("((int *)1)");
+           else
+               output.print("0");
+           needcomma=true;
+       }
+       
+       output.println("};");
+    }
+
     /* Force consistent field ordering between inherited classes. */
 
     private void printClassStruct(ClassDescriptor cn, PrintWriter classdefout) {
@@ -484,6 +539,7 @@ public class BuildCode {
        }
     }
 
+
     /** This function outputs (1) structures that parameters are
      * passed in (when PRECISE GC is enabled) and (2) function
      * prototypes for the methods */

diff --git a/Robust/src/IR/Tree/SemanticCheck.java b/Robust/src/IR/Tree/SemanticCheck.java
index 5892bb6e9b04c384adabeba7afaf95ce351844db..04b115b8a15b4a6e014b0901bd83e286cc178310 100644 (file)
--- a/Robust/src/IR/Tree/SemanticCheck.java
+++ b/Robust/src/IR/Tree/SemanticCheck.java
@@ -690,8 +690,8 @@ public class SemanticCheck {
                if (!(ltd.isBoolean()&&rtd.isBoolean()))
                    throw new Error();
                righttype=lefttype=new TypeDescriptor(TypeDescriptor.BOOLEAN);
-           } else if (ltd.isPtr()||rtd.isPtr()) {
-               if (!(ltd.isPtr()&&rtd.isPtr()))
+           } else if (ltd.isPtr()||ltd.isArray()||rtd.isPtr()||rtd.isArray()) {
+               if (!((ltd.isPtr()||ltd.isArray())&&(rtd.isPtr()||rtd.isArray())))
                    throw new Error();
                righttype=rtd;
                lefttype=ltd;

diff --git a/Robust/src/Runtime/checkpoint.c b/Robust/src/Runtime/checkpoint.c
new file mode 100644 (file)
index 0000000..0dceb86
--- /dev/null
+++ b/Robust/src/Runtime/checkpoint.c
@@ -0,0 +1,123 @@
+#include "checkpoint.h"
+#include "runtime.h"
+#include "structdefs.h"
+#include <string.h>
+
+void ** makecheckpoint(int numparams, void ** pointerarray, struct SimpleHash * forward, struct SimpleHash * reverse) {
+  void **newarray=RUNMALLOC(sizeof(void *)*numparams);
+  struct SimpleHash *todo=allocateSimpleHash(100);
+  int i;
+  for(i=0;i<numparams;i++) {
+    SimpleHashadd(todo, (int) pointerarray[i], (int) pointerarray[i]);
+  }
+  while(SimpleHashcountset(todo)!=0) {
+    void * ptr=(void *) SimpleHashfirstkey(todo);
+    int type=((int *)ptr)[0];
+    SimpleHashremove(todo, (int) ptr, (int) ptr);
+    {
+      void *cpy;
+      SimpleHashget(forward, (int) ptr, (int *) &cpy);
+      int * pointer=pointerarray[type];
+      if (pointer==0) {
+       /* Array of primitives */
+       /* Do nothing */
+      } else if (((int)pointer)==1) {
+       /* Array of pointers */
+       struct ArrayObject *ao=(struct ArrayObject *) ptr;
+       int length=ao->___length___;
+       int i;
+       for(i=0;i<length;i++) {
+         void *objptr=((void **)(((char *)& ao->___length___)+sizeof(int)))[i];
+         if (SimpleHashcontainskey(forward, (int) objptr))
+           SimpleHashget(forward,(int) objptr,(int *) &((void **)(((char *)& ao->___length___)+sizeof(int)))[i]);
+         else {
+           void * copy=createcopy(objptr);
+           SimpleHashadd(forward, (int) objptr, (int)copy);
+           SimpleHashadd(reverse, (int) copy, (int) objptr);
+           SimpleHashadd(todo, (int) objptr, (int) objptr);
+           ((void **)(((char *)& ao->___length___)+sizeof(int)))[i]=copy;
+         }
+       }
+      } else {
+       int size=pointer[0];
+       int i;
+       for(i=1;i<=size;i++) {
+         int offset=pointer[i];
+         void * objptr=*((void **)(((int)ptr)+offset));
+         if (SimpleHashcontainskey(forward, (int) objptr))
+           SimpleHashget(forward, (int) objptr, (int *) &(((char *)cpy)[offset]));
+         else {
+           void * copy=createcopy(objptr);
+           SimpleHashadd(forward, (int) objptr, (int) copy);
+           SimpleHashadd(reverse, (int) copy, (int) objptr);
+           SimpleHashadd(todo, (int) objptr, (int) objptr);
+           *((void **) ((int)cpy)+offset)=copy;
+         }
+       }
+      }
+    }
+  }
+}
+
+void * createcopy(void * orig) {
+  int type=((int *)orig)[0];
+  if (type<NUMCLASSES) {
+    /* We have a normal object */
+    int size=classsize[type];
+    void *newobj=RUNMALLOC(size);
+    memcpy(newobj, orig, size);
+    return newobj;
+  } else {
+    /* We have an array */
+    struct ArrayObject *ao=(struct ArrayObject *)orig;
+    int elementsize=classsize[type];
+    int length=ao->___length___;
+    int size=sizeof(struct ArrayObject)+length*elementsize;
+    void *newobj=RUNMALLOC(size);
+    memcpy(newobj, orig, size);
+    return newobj;
+  }
+}
+
+void restorecheckpoint(int numparams, void ** original, void ** checkpoint, struct SimpleHash *forward, struct SimpleHash * reverse) {
+  struct SimpleHash *todo=allocateSimpleHash(100);
+  int i;
+
+  for(i=0;i<numparams;i++) {
+    SimpleHashadd(todo, (int) checkpoint[i], (int) checkpoint[i]);
+  }
+
+  while(SimpleHashcountset(todo)!=0) {
+    void * ptr=(void *) SimpleHashfirstkey(todo);
+    int type=((int *)ptr)[0];
+    SimpleHashremove(todo, (int) ptr, (int) ptr);
+    {
+      void *cpy;
+      SimpleHashget(reverse, (int) ptr, (int *) &cpy);
+      int * pointer=pointerarray[type];
+      if (pointer==0) {
+       /* Array of primitives */
+       /* Do nothing */
+      } else if ((int)pointer==1) {
+       /* Array of pointers */
+       struct ArrayObject *ao=(struct ArrayObject *) ptr;
+       int length=ao->___length___;
+       int i;
+       for(i=0;i<length;i++) {
+         void *objptr=((void **)(((char *)& ao->___length___)+sizeof(int)))[i];
+         SimpleHashget(reverse, (int) objptr, (int *) &((void **)(((char *)& ao->___length___)+sizeof(int)))[i]);
+       }
+      } else {
+       int size=pointer[0];
+       int i;
+       for(i=1;i<=size;i++) {
+         int offset=pointer[i];
+         void * objptr=*((void **)(((int)ptr)+offset));
+         SimpleHashget(reverse, (int) objptr, (int *) &(((char *)cpy)[offset]));
+       }
+      }
+    }
+  }
+}
+
+

diff --git a/Robust/src/Runtime/checkpoint.h b/Robust/src/Runtime/checkpoint.h
new file mode 100644 (file)
index 0000000..80006a6
--- /dev/null
+++ b/Robust/src/Runtime/checkpoint.h
@@ -0,0 +1,11 @@
+#ifndef CHECKPOINT_H
+#define CHECKPOINT_H
+#include "SimpleHash.h"
+
+void ** makecheckpoint(int numparams, void ** pointerarray, struct SimpleHash * forward, struct SimpleHash * reverse);
+
+void restorecheckpoint(int numparams, void ** original, void ** checkpoint, struct SimpleHash *forward, struct SimpleHash * reverse);
+
+void * createcopy(void * orig);
+
+#endif

diff --git a/Robust/src/buildscripttask b/Robust/src/buildscripttask
index 07cb3d6daf74703d38fac49677aec26f14c462b7..fdf88dd3b0d8220a11e5b15ea2e87eedc23fefe2 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 tmpbuilddirectory/taskdefs.c $ROBUSTROOT/Runtime/runtime.c $ROBUSTROOT/Runtime/Queue.c $ROBUSTROOT/Runtime/SimpleHash.c -o $MAINFILE.bin
\ No newline at end of file
+gcc -I$ROBUSTROOT/Runtime -Itmpbuilddirectory -O0 -DTASK -g tmpbuilddirectory/methods.c tmpbuilddirectory/taskdefs.c $ROBUSTROOT/Runtime/runtime.c $ROBUSTROOT/Runtime/Queue.c $ROBUSTROOT/Runtime/SimpleHash.c $ROBUSTROOT/Runtime/checkpoint.c -o $MAINFILE.bin
\ No newline at end of file