more change for PMC

diff --git a/Robust/src/Runtime/bamboo/pmc_forward.c b/Robust/src/Runtime/bamboo/pmc_forward.c
index b4ec94e320a9613fe8a43cbc2e66fb011298714c..83a01b429298ae890e9dfe978a2cbd1ba4db7b34 100644 (file)
--- a/Robust/src/Runtime/bamboo/pmc_forward.c
+++ b/Robust/src/Runtime/bamboo/pmc_forward.c
@@ -1,8 +1,9 @@
+#include "multicoregc.h"
 #include "pmc_forward.h"
 #include "runtime_arch.h"
 #include "bambooalign.h"
 #include "pmc_garbage.h"
-#include "multicoregc.h"
+
 
 void pmc_count() {
   for(int i=0;i<NUMPMCUNITS;i++) {
@@ -10,7 +11,7 @@ void pmc_count() {
       //got lock
       void *unitbase=(i==0)?gcbaseva:pmc_heapptr->units[i-1].endptr;
       void *unittop=pmc_heapptr->units[i].endptr;
-      //tprintf("Cnt: %x - %x\n", unitbase, unittop);
+      tprintf("Cnt: %x - %x\n", unitbase, unittop);
       pmc_countbytes(&pmc_heapptr->units[i], unitbase, unittop);
     }
   }
@@ -23,6 +24,7 @@ void pmc_countbytes(struct pmc_unit * unit, void *bottomptr, void *topptr) {
   while(tmpptr<topptr) {
     unsigned int type;
     unsigned int size;
+    //tprintf("C:%x\n",tmpptr);
     gettype_size(tmpptr, &type, &size);
     if (!type) {
       tmpptr+=ALIGNMENTSIZE;
@@ -158,6 +160,6 @@ void pmc_forward(struct pmc_region *region, unsigned int totalbytes, void *botto
     }
     tmpptr+=size;
   }
-  //tprintf("forwardptr=%x\n",forwardptr);
+  tprintf("forwardptr=%x\n",forwardptr);
   region->lastobj=lastobj;
 }

diff --git a/Robust/src/Runtime/bamboo/pmc_garbage.c b/Robust/src/Runtime/bamboo/pmc_garbage.c
index 2e0a8fc1264c8a13383fe508b0df7217175c5e7e..915471462754a25c5a30b4e4cef61c64b5cc1ed3 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("%u endptr=%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,7 +62,7 @@ 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);
+      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_heapptr->units[index].endptr;
        if ((ptr>startptr)&&(ptr<=finishptr)) {
@@ -67,76 +70,61 @@ void pmc_init() {
          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);
+        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) {
-  if (BAMBOO_NUM_OF_CORE==STARTUPCORE)
-    tprintf("start GC\n");
+  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;
-    //    for(int i=0;i<NUMCORES4GC;i+=2) {
-    //      tprintf("%u %x %x\n",i, pmc_heapptr->regions[i].lastptr, pmc_heapptr->regions[i+1].lastptr);
-    //      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);
-    //      tprintf("%u %u %u %u\n", pmc_heapptr->regions[i].lowunit, pmc_heapptr->regions[i].highunit, pmc_heapptr->regions[i+1].lowunit, pmc_heapptr->regions[i+1].highunit);
-    //    }
-    //    for(int i=0;i<NUMPMCUNITS;i++) {
-    //      tprintf("%u %x %u\n",i, pmc_heapptr->units[i].endptr, pmc_heapptr->units[i].regionnum);
-    //    }
-  } else {
-    //start to listen for gcflags before we exit
-    gcflag=false;
-    tmc_spin_barrier_wait(&pmc_heapptr->barrier);
-  }
+  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);
+    tprintf("Padspace from %x to %x\n", ptr, ptr+length);
   if (length<sizeof(struct ArrayObject)) {
     BAMBOO_MEMSET_WH(ptr,0,length);
   } else {
@@ -149,8 +137,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];

diff --git a/Robust/src/Runtime/bamboo/pmc_garbage.h b/Robust/src/Runtime/bamboo/pmc_garbage.h
index ab0f449946581d0dba528cf11aec686d252bcef1..e6c26e54d2360b599546a7ab4dab07648cd0d007 100644 (file)
--- a/Robust/src/Runtime/bamboo/pmc_garbage.h
+++ b/Robust/src/Runtime/bamboo/pmc_garbage.h
@@ -39,6 +39,7 @@ struct pmc_heap {
 extern struct pmc_heap * pmc_heapptr;
 extern struct pmc_queue * pmc_localqueue;
 
+void gettype_size(void * ptr, unsigned int * ttype, unsigned int * tsize);
 void padspace(void *ptr, unsigned int length);
 void * pmc_unitend(unsigned int index);
 void incrementthreads();

diff --git a/Robust/src/Runtime/bamboo/pmc_mem.c b/Robust/src/Runtime/bamboo/pmc_mem.c
index 7da2af76d855fa28b808eb8bbb0724d33f65b462..40d7f437ed917b15b6cf2ae16694f0d116ded9fd 100644 (file)
--- a/Robust/src/Runtime/bamboo/pmc_mem.c
+++ b/Robust/src/Runtime/bamboo/pmc_mem.c
@@ -44,17 +44,15 @@ void * pmc_alloc(unsigned int * numbytesallocated, unsigned int minimumbytes) {
     }
   }
   if (BAMBOO_NUM_OF_CORE==STARTUPCORE) {
-    BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
     if (!gcflag) {
       gcflag = true;
-      for(int i=0;i<NUMCORESACTIVE;i++) {
+      for(int i=0;i<NUMCORES4GC;i++) {
        if (i!=STARTUPCORE)
          send_msg_1(i, GCSTARTPRE);
       }
     }
-    BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
   } else {
-    send_msg_1_I(STARTUPCORE,GCINVOKE);
+    send_msg_1(STARTUPCORE,GCINVOKE);
   }
   return NULL;
 }

diff --git a/Robust/src/Runtime/bamboo/pmc_queue.h b/Robust/src/Runtime/bamboo/pmc_queue.h
index e03490faae42d876a7c0c7e0d6942905a8c0ebb5..6721728c472e899d95a273f7c0b94dac31138b77 100644 (file)
--- a/Robust/src/Runtime/bamboo/pmc_queue.h
+++ b/Robust/src/Runtime/bamboo/pmc_queue.h
@@ -3,7 +3,7 @@
 #include "multicore.h"
 #include <tmc/spin.h>
 
-#define NUM_PMC_QUEUE_OBJECTS 500000
+#define NUM_PMC_QUEUE_OBJECTS 1500000
 
 struct pmc_queue {
   volatile void * objects[NUM_PMC_QUEUE_OBJECTS];

diff --git a/Robust/src/Runtime/bamboo/pmc_refupdate.c b/Robust/src/Runtime/bamboo/pmc_refupdate.c
index 7587b36c53c292482a2d6ad54ecaee3cebbd4bf5..100cb9ed5031a8df56b5ce399e72f0c23c3e2749 100644 (file)
--- a/Robust/src/Runtime/bamboo/pmc_refupdate.c
+++ b/Robust/src/Runtime/bamboo/pmc_refupdate.c
@@ -1,6 +1,7 @@
 #include <stdlib.h>
 #include "structdefs.h"
 #include "bambooalign.h"
+#include "multicoregc.h"
 #include "runtime_arch.h"
 #include "pmc_forward.h"
 #include "pmc_refupdate.h"
@@ -11,16 +12,13 @@
 
 #define pmcupdateObj(objptr) ((void *)((struct ___Object___ *)objptr)->marked)
 
-#define PMCUPDATEOBJ(obj) {void *updatetmpptr=obj; if (updatetmpptr!=NULL) {obj=pmcupdateObj(updatetmpptr);}}
+#define PMCUPDATEOBJ(obj) {void *updatetmpptr=obj; if (updatetmpptr!=NULL) {obj=pmcupdateObj(updatetmpptr);if (obj==NULL) {tprintf("BAD REF UPDATE %x->%x in %u\n",updatetmpptr,obj,__LINE__);}}}
 
-//if (obj==NULL) {tprintf("BAD REF UPDATE %x->%x in %u\n",updatetmpptr,obj,__LINE__);}}}
-
-#define PMCUPDATEOBJNONNULL(obj) {void *updatetmpptr=obj; obj=pmcupdateObj(updatetmpptr);}
-//if (obj==NULL) {tprintf("BAD REF UPDATE in %x->%x %u\n",updatetmpptr,obj,__LINE__);}}
+#define PMCUPDATEOBJNONNULL(obj) {void *updatetmpptr=obj; obj=pmcupdateObj(updatetmpptr);if (obj==NULL) {tprintf("BAD REF UPDATE in %x->%x %u\n",updatetmpptr,obj,__LINE__);}}
 
 void pmc_updatePtrs(void *ptr, int type) {
   unsigned int * pointer=pointerarray[type];
-  //tprintf("Updating pointers in %x\n", ptr);
+  tprintf("Updating pointers in %x\n", ptr);
   if (pointer==0) {
     /* Array of primitives */
   } else if (((unsigned int)pointer)==1) {
@@ -38,7 +36,7 @@ void pmc_updatePtrs(void *ptr, int type) {
       PMCUPDATEOBJ(*((void **)(((char *)ptr)+offset)));
     }
   }
-  //tprintf("done\n");
+  tprintf("done\n");
 }
 
 void pmc_updategarbagelist(struct garbagelist *listptr) {
@@ -151,7 +149,7 @@ void pmc_doreferenceupdate(struct garbagelist *stackptr) {
 
 void pmc_referenceupdate(void *bottomptr, void *topptr) {
   void *tmpptr=bottomptr;
-  //tprintf("%x -- %x\n", bottomptr, topptr);
+  tprintf("%x -- %x\n", bottomptr, topptr);
   while(tmpptr<topptr) {
     unsigned int type;
     unsigned int size;