Robust/src/Runtime/checkpoint.c

   1 #include "checkpoint.h"
   2 #include "runtime.h"
   3 #include "structdefs.h"
   4 #include <string.h>
   5
   6 void ** makecheckpoint(int numparams, void ** srcpointer, struct SimpleHash * forward, struct SimpleHash * reverse) {
   7   void **newarray=RUNMALLOC(sizeof(void *)*numparams);
   8   struct SimpleHash *todo=allocateSimpleHash(100);
   9   int i;
  10   for(i=0;i<numparams;i++) {
  11     void * objptr=srcpointer[i];
  12     if (SimpleHashcontainskey(forward, (int) objptr))
  13       SimpleHashget(forward,(int) objptr,(int *) &newarray[i]);
  14     else {
  15       void * copy=createcopy(objptr);
  16       SimpleHashadd(forward, (int) objptr, (int)copy);
  17       SimpleHashadd(reverse, (int) copy, (int) objptr);
  18       SimpleHashadd(todo, (int) objptr, (int) objptr);
  19       newarray[i]=copy;
  20     }
  21   }
  22   while(SimpleHashcountset(todo)!=0) {
  23     void * ptr=(void *) SimpleHashfirstkey(todo);
  24     int type=((int *)ptr)[0];
  25     SimpleHashremove(todo, (int) ptr, (int) ptr);
  26     {
  27       void *cpy;
  28       SimpleHashget(forward, (int) ptr, (int *) &cpy);
  29       int * pointer=pointerarray[type];
  30       if (pointer==0) {
  31         /* Array of primitives */
  32         /* Do nothing */
  33       } else if (((int)pointer)==1) {
  34         /* Array of pointers */
  35         struct ArrayObject *ao=(struct ArrayObject *) ptr;
  36         int length=ao->___length___;
  37         int i;
  38         for(i=0;i<length;i++) {
  39           void *objptr=((void **)(((char *)& ao->___length___)+sizeof(int)))[i];
  40           if (SimpleHashcontainskey(forward, (int) objptr))
  41             SimpleHashget(forward,(int) objptr,(int *) &((void **)(((char *)& ao->___length___)+sizeof(int)))[i]);
  42           else {
  43             void * copy=createcopy(objptr);
  44             SimpleHashadd(forward, (int) objptr, (int)copy);
  45             SimpleHashadd(reverse, (int) copy, (int) objptr);
  46             SimpleHashadd(todo, (int) objptr, (int) objptr);
  47             ((void **)(((char *)& ao->___length___)+sizeof(int)))[i]=copy;
  48           }
  49         }
  50       } else {
  51         int size=pointer[0];
  52         int i;
  53         for(i=1;i<=size;i++) {
  54           int offset=pointer[i];
  55           void * objptr=*((void **)(((int)ptr)+offset));
  56           if (SimpleHashcontainskey(forward, (int) objptr))
  57             SimpleHashget(forward, (int) objptr, (int *) &(((char *)cpy)[offset]));
  58           else {
  59             void * copy=createcopy(objptr);
  60             SimpleHashadd(forward, (int) objptr, (int) copy);
  61             SimpleHashadd(reverse, (int) copy, (int) objptr);
  62             SimpleHashadd(todo, (int) objptr, (int) objptr);
  63             *((void **) ((int)cpy)+offset)=copy;
  64           }
  65         }
  66       }
  67     }
  68   }
  69   return newarray;
  70 }
  71
  72 void * createcopy(void * orig) {
  73   if (orig==0)
  74     return 0;
  75   else {
  76     int type=((int *)orig)[0];
  77     if (type<NUMCLASSES) {
  78       /* We have a normal object */
  79       int size=classsize[type];
  80       void *newobj=RUNMALLOC(size);
  81       memcpy(newobj, orig, size);
  82       return newobj;
  83     } else {
  84       /* We have an array */
  85       struct ArrayObject *ao=(struct ArrayObject *)orig;
  86       int elementsize=classsize[type];
  87       int length=ao->___length___;
  88       int size=sizeof(struct ArrayObject)+length*elementsize;
  89       void *newobj=RUNMALLOC(size);
  90       memcpy(newobj, orig, size);
  91       return newobj;
  92     }
  93   }
  94 }
  95
  96 void restorecheckpoint(int numparams, void ** original, void ** checkpoint, struct SimpleHash *forward, struct SimpleHash * reverse) {
  97   struct SimpleHash *todo=allocateSimpleHash(100);
  98   int i;
  99
 100   for(i=0;i<numparams;i++) {
 101     SimpleHashadd(todo, (int) checkpoint[i], (int) checkpoint[i]);
 102   }
 103
 104   while(SimpleHashcountset(todo)!=0) {
 105     void * ptr=(void *) SimpleHashfirstkey(todo);
 106     int type=((int *)ptr)[0];
 107     SimpleHashremove(todo, (int) ptr, (int) ptr);
 108     {
 109       void *cpy;
 110       SimpleHashget(reverse, (int) ptr, (int *) &cpy);
 111       int * pointer=pointerarray[type];
 112       if (pointer==0) {
 113         /* Array of primitives */
 114         /* Do nothing */
 115       } else if ((int)pointer==1) {
 116         /* Array of pointers */
 117         struct ArrayObject *ao=(struct ArrayObject *) ptr;
 118         int length=ao->___length___;
 119         int i;
 120         for(i=0;i<length;i++) {
 121           void *objptr=((void **)(((char *)& ao->___length___)+sizeof(int)))[i];
 122           SimpleHashget(reverse, (int) objptr, (int *) &((void **)(((char *)& ao->___length___)+sizeof(int)))[i]);
 123         }
 124       } else {
 125         int size=pointer[0];
 126         int i;
 127         for(i=1;i<=size;i++) {
 128           int offset=pointer[i];
 129           void * objptr=*((void **)(((int)ptr)+offset));
 130           SimpleHashget(reverse, (int) objptr, (int *) &(((char *)cpy)[offset]));
 131         }
 132       }
 133     }
 134   }
 135 }
 136
 137