Robust/src/Runtime/bamboo/pmc_refupdate.c

   1 #include <stdlib.h>
   2 #include "structdefs.h"
   3 #include "bambooalign.h"
   4 #include "multicoregc.h"
   5 #include "runtime_arch.h"
   6 #include "pmc_forward.h"
   7 #include "pmc_refupdate.h"
   8 #include "multicoremgc.h"
   9 #include "runtime.h"
  10 #include "thread.h"
  11
  12
  13 #define pmcupdateObj(objptr) ((void *)((struct ___Object___ *)objptr)->marked)
  14
  15 #define PMCUPDATEOBJ(obj) {void *updatetmpptr=obj; if (updatetmpptr!=NULL) {obj=pmcupdateObj(updatetmpptr);}}
  16 //if (obj==NULL) {tprintf("BAD REF UPDATE %x->%x in %u\n",updatetmpptr,obj,__LINE__);}}}
  17
  18 #define PMCUPDATEOBJNONNULL(obj) {void *updatetmpptr=obj; obj=pmcupdateObj(updatetmpptr);}
  19 //if (obj==NULL) {tprintf("BAD REF UPDATE in %x->%x %u\n",updatetmpptr,obj,__LINE__);}}
  20
  21 void pmc_updatePtrs(void *ptr, int type) {
  22   unsigned int * pointer=pointerarray[type];
  23   //tprintf("Updating pointers in %x\n", ptr);
  24   if (pointer==0) {
  25     /* Array of primitives */
  26   } else if (((unsigned int)pointer)==1) {
  27     /* Array of pointers */
  28     struct ArrayObject *ao=(struct ArrayObject *) ptr;
  29     int length=ao->___length___;
  30     for(int j=0; j<length; j++) {
  31       PMCUPDATEOBJ(((void **)(((char *)&ao->___length___)+sizeof(int)))[j]);
  32     }
  33   } else {
  34     unsigned int size=pointer[0];
  35
  36     for(int i=1; i<=size; i++) {
  37       unsigned int offset=pointer[i];
  38       PMCUPDATEOBJ(*((void **)(((char *)ptr)+offset)));
  39     }
  40   }
  41   //tprintf("done\n");
  42 }
  43
  44 void pmc_updategarbagelist(struct garbagelist *listptr) {
  45   for(;listptr!=NULL; listptr=listptr->next) {
  46     for(int i=0; i<listptr->size; i++) {
  47       PMCUPDATEOBJ(listptr->array[i]);
  48     }
  49   }
  50 }
  51
  52 void pmc_updateRuntimePtrs(struct garbagelist * stackptr) {
  53   // update current stack
  54   pmc_updategarbagelist(stackptr);
  55
  56   // update static pointers global_defs_p
  57   if(STARTUPCORE == BAMBOO_NUM_OF_CORE) {
  58     pmc_updategarbagelist((struct garbagelist *)global_defs_p);
  59   }
  60
  61 #ifdef TASK
  62   // update objectsets
  63   if(BAMBOO_NUM_OF_CORE < NUMCORESACTIVE) {
  64     for(int i=0; i<NUMCLASSES; i++) {
  65       struct parameterwrapper ** queues = objectqueues[BAMBOO_NUM_OF_CORE][i];
  66       int length = numqueues[BAMBOO_NUM_OF_CORE][i];
  67       for(int j = 0; j < length; ++j) {
  68         struct parameterwrapper * parameter = queues[j];
  69         struct ObjectHash * set=parameter->objectset;
  70         for(struct ObjectNode * ptr=set->listhead;ptr!=NULL;ptr=ptr->lnext) {
  71           PMCUPDATEOBJNONNULL(ptr->key);
  72         }
  73         ObjectHashrehash(set);
  74       }
  75     }
  76   }
  77
  78   // update current task descriptor
  79   if(currtpd != NULL) {
  80     for(int i=0; i<currtpd->numParameters; i++) {
  81       // the parameter can not be NULL
  82       PMCUPDATEOBJNONNULL(currtpd->parameterArray[i]);
  83     }
  84   }
  85
  86   // update active tasks
  87   if(activetasks != NULL) {
  88     for(struct genpointerlist * ptr=activetasks->list;ptr!=NULL;ptr=ptr->inext){
  89       struct taskparamdescriptor *tpd=ptr->src;
  90       for(int i=0; i<tpd->numParameters; i++) {
  91         // the parameter can not be NULL
  92         PMCUPDATEOBJNONNULL(tpd->parameterArray[i]);
  93       }
  94     }
  95     genrehash(activetasks);
  96   }
  97
  98   // update cached transferred obj
  99   for(struct QueueItem * tmpobjptr =  getHead(&objqueue);tmpobjptr != NULL;tmpobjptr = getNextQueueItem(tmpobjptr)) {
 100     struct transObjInfo * objInfo=(struct transObjInfo *)(tmpobjptr->objectptr);
 101     // the obj can not be NULL
 102     PMCUPDATEOBJNONNULL(objInfo->objptr);
 103   }
 104
 105   // update cached objs to be transferred
 106   for(struct QueueItem * item = getHead(totransobjqueue);item != NULL;item = getNextQueueItem(item)) {
 107     struct transObjInfo * totransobj = (struct transObjInfo *)(item->objectptr);
 108     // the obj can not be NULL
 109     PMCUPDATEOBJNONNULL(totransobj->objptr);
 110   }
 111
 112   // enqueue lock related info
 113   for(int i = 0; i < runtime_locklen; ++i) {
 114     PMCUPDATEOBJ(runtime_locks[i].redirectlock);
 115     PMCUPDATEOBJ(runtime_locks[i].value);
 116   }
 117 #endif
 118
 119 #ifdef MGC
 120   // update the bamboo_threadlocks
 121   for(int i = 0; i < bamboo_threadlocks.index; i++) {
 122     // the locked obj can not be NULL
 123     PMCUPDATEOBJNONNULL(bamboo_threadlocks.locks[i].object);
 124   }
 125
 126   // update the bamboo_current_thread
 127   PMCUPDATEOBJ(bamboo_current_thread);
 128
 129   // update global thread queue
 130   if(STARTUPCORE == BAMBOO_NUM_OF_CORE) {
 131     unsigned int thread_counter = *((unsigned int*)(bamboo_thread_queue+1));
 132     if(thread_counter > 0) {
 133       unsigned int start = *((unsigned int*)(bamboo_thread_queue+2));
 134       for(int i = thread_counter; i > 0; i--) {
 135         // the thread obj can not be NULL
 136         PMCUPDATEOBJNONNULL(*((void **)&bamboo_thread_queue[4+start]));
 137         start = (start+1)&bamboo_max_thread_num_mask;
 138       }
 139     }
 140     unlockthreadqueue();
 141   }
 142 #endif
 143 }
 144
 145
 146 void pmc_doreferenceupdate(struct garbagelist *stackptr) {
 147   struct pmc_region * region=&pmc_heapptr->regions[BAMBOO_NUM_OF_CORE];
 148   pmc_updateRuntimePtrs(stackptr);
 149   pmc_referenceupdate(region->startptr, region->endptr);
 150 }
 151
 152 void pmc_referenceupdate(void *bottomptr, void *topptr) {
 153   void *tmpptr=bottomptr;
 154   //tprintf("%x -- %x\n", bottomptr, topptr);
 155   while(tmpptr<topptr) {
 156     unsigned int type;
 157     unsigned int size;
 158     gettype_size(tmpptr, &type, &size);
 159     size=((size-1)&(~(ALIGNMENTSIZE-1)))+ALIGNMENTSIZE;
 160     if (!type) {
 161       tmpptr+=ALIGNMENTSIZE;
 162       continue;
 163     }
 164     //if marked we update the pointers
 165     if (((struct ___Object___ *) tmpptr)->marked) {
 166       pmc_updatePtrs(tmpptr, type);
 167     }
 168     tmpptr+=size;
 169   }
 170 }
 171
 172 void pmc_docompact() {
 173   struct pmc_region * region=&pmc_heapptr->regions[BAMBOO_NUM_OF_CORE];
 174   pmc_compact(region, !(BAMBOO_NUM_OF_CORE&1), region->startptr, region->endptr);
 175 }
 176
 177 void moveforward(void *dstptr, void *origptr, unsigned int length) {
 178   void *endtoptr=dstptr+length;
 179
 180   if(origptr < endtoptr&&dstptr < origptr+length) {
 181     unsigned int *sptr=origptr;
 182     unsigned int *dptr=dstptr;
 183     unsigned int len=length;
 184     //we will never have an object of size 0....
 185
 186     do {
 187       //#1
 188       unsigned int tmpptr0=*sptr;
 189       sptr++;
 190       *dptr=tmpptr0;
 191       dptr++;
 192
 193       //#2
 194       tmpptr0=*sptr;
 195       sptr++;
 196       *dptr=tmpptr0;
 197       dptr++;
 198
 199       //#3
 200       tmpptr0=*sptr;
 201       sptr++;
 202       *dptr=tmpptr0;
 203       dptr++;
 204
 205       //#4
 206       tmpptr0=*sptr;
 207       sptr++;
 208       *dptr=tmpptr0;
 209       dptr++;
 210
 211       //#5
 212       tmpptr0=*sptr;
 213       sptr++;
 214       *dptr=tmpptr0;
 215       dptr++;
 216
 217       //#6
 218       tmpptr0=*sptr;
 219       sptr++;
 220       *dptr=tmpptr0;
 221       dptr++;
 222
 223       //#7
 224       tmpptr0=*sptr;
 225       sptr++;
 226       *dptr=tmpptr0;
 227       dptr++;
 228
 229       //#8
 230       tmpptr0=*sptr;
 231       sptr++;
 232       *dptr=tmpptr0;
 233       dptr++;
 234
 235       len=len-32;
 236     } while(len);
 237     //memmove(dstptr, origptr, length);
 238   } else if (origptr!=dstptr) {
 239     //no need to copy if the source & dest are equal....
 240     memcpy(dstptr, origptr, length);
 241   }
 242 }
 243
 244 void movebackward(void *dstptr, void *origptr, unsigned int length) {
 245   void *endtoptr=dstptr+length;
 246
 247   if(origptr < endtoptr&&dstptr < origptr+length) {
 248     unsigned int *sptr=origptr+length;
 249     unsigned int *dptr=endtoptr;
 250     unsigned int len=length;
 251     //we will never have an object of size 0....
 252
 253     do {
 254       //#1
 255       unsigned int tmpptr0=*sptr;
 256       sptr--;
 257       *dptr=tmpptr0;
 258       dptr--;
 259
 260       //#2
 261       tmpptr0=*sptr;
 262       sptr--;
 263       *dptr=tmpptr0;
 264       dptr--;
 265
 266       //#3
 267       tmpptr0=*sptr;
 268       sptr--;
 269       *dptr=tmpptr0;
 270       dptr--;
 271
 272       //#4
 273       tmpptr0=*sptr;
 274       sptr--;
 275       *dptr=tmpptr0;
 276       dptr--;
 277
 278       //#5
 279       tmpptr0=*sptr;
 280       sptr--;
 281       *dptr=tmpptr0;
 282       dptr--;
 283
 284       //#6
 285       tmpptr0=*sptr;
 286       sptr--;
 287       *dptr=tmpptr0;
 288       dptr--;
 289
 290       //#7
 291       tmpptr0=*sptr;
 292       sptr--;
 293       *dptr=tmpptr0;
 294       dptr--;
 295
 296       //#8
 297       tmpptr0=*sptr;
 298       sptr--;
 299       *dptr=tmpptr0;
 300       dptr--;
 301
 302       len=len-32;
 303     } while(len);
 304     //memmove(dstptr, origptr, length);
 305   } else if (origptr!=dstptr) {
 306     //no need to copy if the source & dest are equal....
 307     memcpy(dstptr, origptr, length);
 308   }
 309 }
 310
 311
 312 void pmc_compact(struct pmc_region * region, int forward, void *bottomptr, void *topptr) {
 313   if (forward) {
 314     void *tmpptr=bottomptr;
 315     while(tmpptr<topptr) {
 316       unsigned int type;
 317       unsigned int size;
 318       gettype_size(tmpptr, &type, &size);
 319       size=((size-1)&(~(ALIGNMENTSIZE-1)))+ALIGNMENTSIZE;
 320       if (!type) {
 321         tmpptr+=ALIGNMENTSIZE;
 322         continue;
 323       }
 324       //if marked we update the pointers
 325       void *forwardptr=(void *)((struct ___Object___ *) tmpptr)->marked;
 326       ((struct ___Object___ *) tmpptr)->marked=NULL;
 327       if (forwardptr) {
 328         //tprintf("Compacting %x\n",tmpptr);
 329         //      memmove(forwardptr, tmpptr, size);
 330         memforward(forwardptr, tmpptr, size);
 331       }
 332       tmpptr+=size;
 333     }
 334   } else {
 335     struct ___Object___ *backward=region->lastobj;
 336     struct ___Object___ *lastobj=NULL;
 337     while(backward) {
 338       lastobj=backward;
 339       backward=backward->backward;
 340       unsigned int type;
 341       unsigned int size;
 342       gettype_size(lastobj, &type, &size);
 343       size=((size-1)&(~(ALIGNMENTSIZE-1)))+ALIGNMENTSIZE;
 344       void *forwardptr=(void *)((struct ___Object___ *) lastobj)->marked;
 345       ((struct ___Object___ *) lastobj)->marked=NULL;
 346       //tprintf("Compacting %x\n",lastobj);
 347       //memmove(forwardptr, lastobj, size);
 348       membackward(forwardptr, lastobj, size);
 349     }
 350   }
 351 }