version runs specJBB...finally...

[IRC.git] / Robust / src / Runtime / bamboo / pmc_garbage.c

diff --git a/Robust/src/Runtime/bamboo/pmc_garbage.c b/Robust/src/Runtime/bamboo/pmc_garbage.c
index f56043d930668e473a4883d49b41cea04776a2dd..c0cde4adfb6e921a915a6d69644cd3fc72e57851 100644 (file)
--- a/Robust/src/Runtime/bamboo/pmc_garbage.c
+++ b/Robust/src/Runtime/bamboo/pmc_garbage.c
@@ -2,6 +2,9 @@
 #include "multicoreruntime.h"
 #include "pmc_garbage.h"
 #include "runtime_arch.h"
+#include "pmc_mark.h"
+#include "pmc_forward.h"
+#include "pmc_refupdate.h"
 
 struct pmc_heap * pmc_heapptr;
 struct pmc_queue * pmc_localqueue;
@@ -30,7 +33,7 @@ void pmc_onceInit() {
     tmc_spin_barrier_init(&pmc_heapptr->barrier, NUMCORES4GC);
     for(int i=0;i<NUMPMCUNITS;i++) {
       pmc_heapptr->units[i].endptr=pmc_unitend(i);
-      tprintf("%u endptr=%x\n", i, pmc_heapptr->units[i].endptr);
+      //tprintf("Ch5: %u-> %x\n", i, pmc_heapptr->units[i].endptr);
     }
     
     for(int i=0;i<NUMCORES4GC;i+=2) {
@@ -44,9 +47,9 @@ void pmc_onceInit() {
       pmc_heapptr->regions[i+1].lowunit=4*(i+1);
       pmc_heapptr->regions[i+1].highunit=4*(i+2);
     }
-    for(int i=0;i<NUMCORES4GC;i++) {
-      tprintf("%u lastptr=%x\n", i, pmc_heapptr->regions[i].lastptr);
-    }
+    //for(int i=0;i<NUMCORES4GC;i++) {
+      //tprintf("%u lastptr=%x\n", i, pmc_heapptr->regions[i].lastptr);
+    //}
   }
 }
 
@@ -59,76 +62,78 @@ void pmc_init() {
       struct pmc_region *region=&pmc_heapptr->regions[i];
       unsigned int startindex=region->lowunit;
       unsigned int endindex=pmc_heapptr->regions[i+1].highunit;
-
+      //tprintf("Free space in partition %u from %x to %x\n", i, startptr, finishptr);
       for(unsigned int index=startindex;index<endindex;index++) {
-       void *ptr=pmc_unitend(index);
+       void *ptr=pmc_heapptr->units[index].endptr;
        if ((ptr>startptr)&&(ptr<=finishptr)) {
-         pmc_heapptr->units[index].endptr=ptr;
          padspace(startptr, (unsigned int)(ptr-startptr));
          startptr=ptr;
        }
        if (ptr>finishptr) {
-         void *prevunitptr=pmc_heapptr->units[index-1].endptr;
-         padspace(startptr, finishptr-startptr);
+         padspace(startptr, (unsigned int) (finishptr-startptr));
          break;
        }
       }
     }
   }
   if (bamboo_smem_size) {
+    //tprintf("Left over alloc space from %x to %x\n", bamboo_cur_msp, bamboo_cur_msp+bamboo_smem_size);
     padspace(bamboo_cur_msp, bamboo_smem_size);  
   }
   tmc_spin_barrier_wait(&pmc_heapptr->barrier);
 }
 
 void gc(struct garbagelist *gl) {
-  tprintf("%x\n", pmc_heapptr);
-  tprintf("init\n");
+  if (BAMBOO_NUM_OF_CORE==STARTUPCORE)
+    tprintf("start GC\n");
   pmc_init();
   //mark live objects
-  tprintf("mark\n");
+  //tprintf("mark\n");
   pmc_mark(gl);
   //count live objects per unit
   tmc_spin_barrier_wait(&pmc_heapptr->barrier);
-  tprintf("count\n");
+  //tprintf("count\n");
   pmc_count();
   tmc_spin_barrier_wait(&pmc_heapptr->barrier);
   //divide up work
-  tprintf("divide\n");
+  //tprintf("divide\n");
   if (BAMBOO_NUM_OF_CORE==STARTUPCORE) {
     pmc_processunits();
   }
   tmc_spin_barrier_wait(&pmc_heapptr->barrier);
   //set up forwarding pointers
-  tprintf("forward\n");
+  //tprintf("forward\n");
   pmc_doforward();
   tmc_spin_barrier_wait(&pmc_heapptr->barrier);
   //update pointers
-  tprintf("updaterefs\n");
+  //tprintf("updaterefs\n");
   pmc_doreferenceupdate(gl);
   tmc_spin_barrier_wait(&pmc_heapptr->barrier);
   //compact data
-  tprintf("compact\n");
+  //tprintf("compact\n");
   pmc_docompact();
   //reset memory allocation
   bamboo_cur_msp=NULL;
   bamboo_smem_size=0;
-  tprintf("done\n");
+  //tprintf("done\n");
 
-  if (BAMBOO_NUM_OF_CORE==STARTUPCORE) {
-    tmc_spin_barrier_wait(&pmc_heapptr->barrier);
-    //people will resend...no need to get gcflag so quickly
-    gcflag=false;
-  } else {
-    //start to listen for gcflags before we exit
-    gcflag=false;
-    tmc_spin_barrier_wait(&pmc_heapptr->barrier);
-  }
+  //if (BAMBOO_NUM_OF_CORE==STARTUPCORE) {
+    //    for(int i=0;i<NUMCORES4GC;i+=2) {
+    //      void *startptr=pmc_heapptr->regions[i].lastptr;
+    //      void *finishptr=pmc_heapptr->regions[i+1].lastptr;
+    //      tprintf("Partition %u from %x to %x\n", i, startptr, finishptr);
+    //      tprintf("%x %x %x %x\n", pmc_heapptr->regions[i].startptr, pmc_heapptr->regions[i].endptr, pmc_heapptr->regions[i+1].startptr, pmc_heapptr->regions[i+1].endptr);
+    //    }
+  //  }
+
+  gcflag=false;
+  tmc_spin_barrier_wait(&pmc_heapptr->barrier);
+
+  //tprintf("exit GC\n");
 }
 
 void padspace(void *ptr, unsigned int length) {
   //zero small blocks
-  tprintf("Padspace from %x to %x\n", ptr, ptr+length);
   if (length<sizeof(struct ArrayObject)) {
     BAMBOO_MEMSET_WH(ptr,0,length);
   } else {
@@ -141,8 +146,12 @@ void padspace(void *ptr, unsigned int length) {
   }
 }
 
-void gettype_size(void * ptr, int * ttype, unsigned int * tsize) {
+void gettype_size(void * ptr, unsigned int * ttype, unsigned int * tsize) {
   int type = ((int *)ptr)[0];
+  //  if (type>TOTALNUMCLASSANDARRAY) {
+  //    tprintf("ptr=%x type=%u\n", ptr, type);
+  //  }
+
   if(type < NUMCLASSES) {
     // a normal object
     *tsize = classsize[type];