1 #include "checkpoint.h"
3 #include "structdefs.h"
8 extern void * curr_heapbase;
9 extern void * curr_heapptr;
10 extern void * curr_heapgcpoint;
11 extern void * curr_heaptop;
13 extern void * to_heapbase;
14 extern void * to_heapptr;
15 extern void * to_heaptop;
18 #define MALLOCSIZE 20*1024
21 struct malloclist *next;
26 struct malloclist * top=NULL;
29 void * cpmalloc(int size) {
30 int endoffset=offset+size;
31 if (top==NULL||endoffset>top->size) {
32 int basesize=MALLOCSIZE;
33 struct malloclist *tmp;
36 tmp=RUNMALLOC(sizeof(struct malloclist)+basesize);
44 return &top->space[tmpoffset];
49 struct malloclist *next=top->next;
55 void checkvalid(void * ptr) {
56 if (ptr>=curr_heapbase&&ptr<=curr_heaptop) {
61 void validitycheck(struct RuntimeHash *forward, struct RuntimeHash *reverse) {
62 struct RuntimeIterator rit;
63 RuntimeHashiterator(forward, &rit);
64 while(RunhasNext(&rit)) {
65 struct ___Object___ * data=(struct ___Object___*) Runnext(&rit);
67 unsigned int * pointer=pointerarray[type];
70 if (pointer!=0&&((int)pointer)!=1) {
72 for(i=1;i<=size;i++) {
73 int offset=pointer[i];
74 void * ptr=*(void **) (((int) data) + offset);
75 if (ptr!=NULL&&!RuntimeHashcontainskey(reverse, (int) ptr)) {
83 RuntimeHashiterator(reverse, &rit);
84 while(RunhasNext(&rit)) {
85 struct ___Object___ * data=(struct ___Object___*) Runkey(&rit);
88 unsigned int * pointer=pointerarray[type];
91 if (pointer!=0&&((int)pointer)!=1) {
93 for(i=1;i<=size;i++) {
94 int offset=pointer[i];
95 void * ptr=*(void **) (((int) data) + offset);
96 if (ptr!=NULL&&!RuntimeHashcontainskey(reverse, (int) ptr)) {
107 void ** makecheckpoint(int numparams, void ** srcpointer, struct RuntimeHash * forward, struct RuntimeHash * reverse) {
109 void **newarray=cpmalloc(sizeof(void *)*numparams);
111 void **newarray=RUNMALLOC(sizeof(void *)*numparams);
113 struct RuntimeHash *todo=allocateRuntimeHash(100);
116 for(i=0;i<numparams;i++) {
117 void * objptr=srcpointer[i];
118 if (RuntimeHashcontainskey(forward, (int) objptr))
119 RuntimeHashget(forward,(int) objptr,(int *) &newarray[i]);
121 void * copy=createcopy(objptr);
122 RuntimeHashadd(forward, (int) objptr, (int)copy);
123 RuntimeHashadd(reverse, (int) copy, (int) objptr);
124 RuntimeHashadd(todo, (int) objptr, (int) objptr);
128 while(RuntimeHashcountset(todo)!=0) {
129 void * ptr=(void *) RuntimeHashfirstkey(todo);
130 int type=((int *)ptr)[0];
131 RuntimeHashremove(todo, (int) ptr, (int) ptr);
134 RuntimeHashget(forward, (int) ptr, (int *) &cpy);
136 unsigned int * pointer=pointerarray[type];
139 void *objptr=((struct ___TagDescriptor___*)ptr)->flagptr;
141 if (!RuntimeHashcontainskey(forward, (int) objptr)) {
142 void *copy=createcopy(objptr);
143 RuntimeHashadd(forward, (int) objptr, (int) copy);
144 RuntimeHashadd(reverse, (int) copy, (int) objptr);
145 RuntimeHashadd(todo, (int) objptr, (int) objptr);
146 ((struct ___TagDescriptor___*)cpy)->flagptr=copy;
148 RuntimeHashget(forward, (int) objptr, (int *) &(((struct ___TagDescriptor___*) cpy)->flagptr));
154 /* Array of primitives */
156 } else if (((int)pointer)==1) {
157 /* Array of pointers */
158 struct ArrayObject *ao=(struct ArrayObject *) ptr;
159 struct ArrayObject *ao_cpy=(struct ArrayObject *) cpy;
160 int length=ao->___length___;
162 for(i=0;i<length;i++) {
163 void *objptr=((void **)(((char *)& ao->___length___)+sizeof(int)))[i];
165 ((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]=NULL;
166 } else if (RuntimeHashcontainskey(forward, (int) objptr))
167 RuntimeHashget(forward,(int) objptr,(int *) &((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]);
169 void * copy=createcopy(objptr);
170 RuntimeHashadd(forward, (int) objptr, (int)copy);
171 RuntimeHashadd(reverse, (int) copy, (int) objptr);
172 RuntimeHashadd(todo, (int) objptr, (int) objptr);
173 ((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]=copy;
179 for(i=1;i<=size;i++) {
180 int offset=pointer[i];
181 void * objptr=*((void **)(((int)ptr)+offset));
183 *((void **) (((int)cpy)+offset))=NULL;
184 } else if (RuntimeHashcontainskey(forward, (int) objptr))
185 RuntimeHashget(forward, (int) objptr, (int *) &(((char *)cpy)[offset]));
187 void * copy=createcopy(objptr);
188 RuntimeHashadd(forward, (int) objptr, (int) copy);
189 RuntimeHashadd(reverse, (int) copy, (int) objptr);
190 RuntimeHashadd(todo, (int) objptr, (int) objptr);
191 *((void **) (((int)cpy)+offset))=copy;
197 freeRuntimeHash(todo);
201 void * createcopy(void * orig) {
205 int type=((int *)orig)[0];
206 if (type<NUMCLASSES) {
207 /* We have a normal object */
208 int size=classsize[type];
210 void *newobj=cpmalloc(size);
212 void *newobj=RUNMALLOC(size);
214 memcpy(newobj, orig, size);
217 /* We have an array */
218 struct ArrayObject *ao=(struct ArrayObject *)orig;
219 int elementsize=classsize[type];
220 int length=ao->___length___;
221 int size=sizeof(struct ArrayObject)+length*elementsize;
223 void *newobj=cpmalloc(size);
225 void *newobj=RUNMALLOC(size);
227 memcpy(newobj, orig, size);
233 void restorecheckpoint(int numparams, void ** original, void ** checkpoint, struct RuntimeHash *forward, struct RuntimeHash * reverse) {
234 struct RuntimeHash *todo=allocateRuntimeHash(100);
235 struct RuntimeHash *visited=allocateRuntimeHash(100);
238 for(i=0;i<numparams;i++) {
239 if (checkpoint[i]!=NULL) {
240 RuntimeHashadd(todo, (int) checkpoint[i], (int) checkpoint[i]);
241 RuntimeHashadd(visited, (int) checkpoint[i], (int) checkpoint[i]);
245 while(RuntimeHashcountset(todo)!=0) {
246 void * ptr=(void *) RuntimeHashfirstkey(todo);
247 int type=((int *)ptr)[0];
248 RuntimeHashremove(todo, (int) ptr, (int) ptr);
252 unsigned int *pointer;
254 RuntimeHashget(reverse, (int) ptr, (int *) &cpy);
255 pointer=pointerarray[type];
256 size=classsize[type];
259 void *objptr=((struct ___TagDescriptor___*)ptr)->flagptr;
260 memcpy(cpy, ptr, size);
262 if (!RuntimeHashcontainskey(visited, (int) objptr)) {
263 RuntimeHashadd(visited, (int) objptr, (int) objptr);
264 RuntimeHashadd(todo, (int) objptr, (int) objptr);
266 RuntimeHashget(reverse, (int) objptr, (int *) & (((struct ___TagDescriptor___ *)cpy)->flagptr));
271 /* Array of primitives */
272 struct ArrayObject *ao=(struct ArrayObject *) ptr;
273 int length=ao->___length___;
274 int cpysize=sizeof(struct ArrayObject)+length*size;
275 memcpy(cpy, ptr, cpysize);
276 } else if ((int)pointer==1) {
277 /* Array of pointers */
278 struct ArrayObject *ao=(struct ArrayObject *) ptr;
279 struct ArrayObject *ao_cpy=(struct ArrayObject *) cpy;
280 int length=ao->___length___;
282 int cpysize=sizeof(struct ArrayObject)+length*size;
283 memcpy(ao_cpy, ao, cpysize);
285 for(i=0;i<length;i++) {
286 void *objptr=((void **)(((char *)& ao->___length___)+sizeof(int)))[i];
288 ((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]=NULL;
290 if (!RuntimeHashcontainskey(visited, (int) objptr)) {
291 RuntimeHashadd(visited, (int) objptr, (int) objptr);
292 RuntimeHashadd(todo, (int) objptr, (int) objptr);
294 RuntimeHashget(reverse, (int) objptr, (int *) &((void **)(((char *)& ao_cpy->___length___)+sizeof(int)))[i]);
298 int numptr=pointer[0];
303 if (hasflags[type]) {
304 flagptr=(void *) (((int *)cpy)[2]);
305 oldflag=(((int *)cpy)[1]);
306 currflag=(((int *)ptr)[1]);
308 memcpy(cpy, ptr, size);
309 for(i=1;i<=numptr;i++) {
310 int offset=pointer[i];
311 void * objptr=*((void **)(((int)ptr)+offset));
313 *((void **) (((int)cpy)+offset))=NULL;
315 if (!RuntimeHashcontainskey(visited, (int) objptr)) {
316 RuntimeHashadd(visited, (int) objptr, (int) objptr);
317 RuntimeHashadd(todo, (int) objptr, (int) objptr);
319 RuntimeHashget(reverse, (int) objptr, (int *) &(((char *)cpy)[offset]));
322 if (hasflags[type]) {
323 (((void **)cpy)[2])=flagptr;
324 if (currflag!=oldflag) {
325 flagorandinit(cpy, 0, 0xFFFFFFFF);
327 enqueueObject(cpy, NULL,0); //TODO
336 freeRuntimeHash(todo);
337 freeRuntimeHash(visited);