more changes

diff --git a/Robust/src/Runtime/bamboo/multicoregarbage.c b/Robust/src/Runtime/bamboo/multicoregarbage.c
index 667e7ec591b500040ead478304218b10f67efa17..5478e09e634b8ef47049532dc21a1825f12c907d 100644 (file)
--- a/Robust/src/Runtime/bamboo/multicoregarbage.c
+++ b/Robust/src/Runtime/bamboo/multicoregarbage.c
@@ -103,6 +103,16 @@ void initmulticoregcdata() {
   gccachestage = false;
 #endif 
 
+  if(STARTUPCORE == BAMBOO_NUM_OF_CORE) {
+    allocationinfo.blocktable=RUNMALLOC(sizeof(struct blockrecord)*GCNUMBLOCK);
+    for(int i=0; i<GCNUMBLOCK;i++) {
+      if (1==NUMCORES4GC)
+       allocationinfo.blocktable[i].corenum=0;
+      else
+       allocationinfo.blocktable[i].corenum=gc_block2core[(i%(NUMCORES4GC*2))];
+    }
+  }
+
   INIT_MULTICORE_GCPROFILE_DATA();
 }
 
@@ -112,6 +122,10 @@ void dismulticoregcdata() {
 
 void initGC() {
   if(STARTUPCORE == BAMBOO_NUM_OF_CORE) {
+    for(int i=0; i<GCNUMBLOCK;i++) {
+      allocationinfo.blocktable[i].status=BS_INIT;
+    }
+    allocationinfo.lowestfreeblock=NOFREEBLOCK;
     for(int i = 0; i < NUMCORES4GC; i++) {
       gccorestatus[i] = 1;
       gcnumsendobjs[0][i] = gcnumsendobjs[1][i] = 0;
@@ -147,14 +161,11 @@ void initGC() {
 } 
 
 bool gc_checkAllCoreStatus() {
-  BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
   for(int i = 0; i < NUMCORESACTIVE; i++) {
     if(gccorestatus[i] != 0) {
-      BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
       return false;
     }  
   }  
-  BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
   return true;
 }
 

diff --git a/Robust/src/Runtime/bamboo/multicoregarbage.h b/Robust/src/Runtime/bamboo/multicoregarbage.h
index 025148f71883bc3791d8430e4090ffbc9b783527..53847fc9b852d5ccf39bb13f65a4a27d44f5d153 100644 (file)
--- a/Robust/src/Runtime/bamboo/multicoregarbage.h
+++ b/Robust/src/Runtime/bamboo/multicoregarbage.h
@@ -1,4 +1,4 @@
-#ifndef BAMBOO_MULTICORE_GARBAGE_H
+m#ifndef BAMBOO_MULTICORE_GARBAGE_H
 #define BAMBOO_MULTICORE_GARBAGE_H
 #ifdef MULTICORE_GC
 #include "multicore.h"
@@ -25,10 +25,10 @@ typedef enum {
   COMPACTPHASE,            // 0x2
   SUBTLECOMPACTPHASE,      // 0x3
   MAPPHASE,                // 0x4
-  UPDATEPHASE,              // 0x5
+  UPDATEPHASE,             // 0x5
   CACHEPOLICYPHASE,        // 0x6
   PREFINISHPHASE,          // 0x7
-  FINISHPHASE              // 0x6/0x8
+  FINISHPHASE              // 0x8
 } GCPHASETYPE;
 
 typedef struct gc_status {
@@ -50,10 +50,10 @@ volatile unsigned int gccorestatus[NUMCORESACTIVE];//records status of each core
 volatile unsigned int gcnumsendobjs[2][NUMCORESACTIVE];//# of objects sent out
 volatile unsigned int gcnumreceiveobjs[2][NUMCORESACTIVE];//# of objects received
 volatile unsigned int gcnumsrobjs_index;//indicates which entry to record the  
-                                       // info received before phase 1 of the mark finish 
-                                                               // checking process
-                                                                           // the info received in phase 2 must be 
-                                                                           // recorded in the other entry
+                 // info received before phase 1 of the mark finish 
+                 // checking process
+                 // the info received in phase 2 must be 
+                 // recorded in the other entry
 
 unsigned int gcself_numsendobjs;
 unsigned int gcself_numreceiveobjs;
@@ -95,10 +95,32 @@ unsigned int bamboo_rmsp_size;
 //mark table....keep track of mark bits
 unsigned int * gcmarktbl;
 
+void * gcbaseva; // base va for shared memory without reserved sblocks
 
+/* Structure to keep track of free space in block */
+enum blockstatus {
+  /* BS_INIT indicates that we don't have information for this block yet */
+  BS_INIT,
+  /* BS_LARGEOBJECT indicates that the beginning of this block has a large object*/
+  BS_LARGEOBJECT,
+  /* BS_FREE indicates that the block is at least partially free */
+  BS_FREE
+};
 
-unsigned int gcnumblock; // number of total blocks in the shared mem
-void * gcbaseva; // base va for shared memory without reserved sblocks
+struct blockrecord {
+  enum blockstatus status;
+  unsigned INTPTR usedspace;
+  unsigned int corenum;
+
+};
+
+#define NOFREEBLOCK 0xffffffff
+struct allocrecord {
+  unsigned int lowestfreeblock;
+  struct blockrecord * blocktable;
+};
+
+struct allocrecord allocationinfo;
 
 #ifdef GC_CACHE_ADAPT
 void * gctopva; // top va for shared memory without reserved sblocks
@@ -114,15 +136,15 @@ int * gccachepolicytbl;
 unsigned int size_cachepolicytbl;
 #endif
 
-#define WAITFORGCPHASE(phase) while(gc_status_info.gcphase != phase) ;
-
-#define ISSHAREDOBJ(p) \
-  ((((unsigned int)p)>=gcbaseva)&&(((unsigned int)p)<(gcbaseva+(BAMBOO_SHARED_MEM_SIZE))))
+/* Total number of blocks in heap */
 
-#define MAXBLOCK 0x4fffffff //local block number that can never be reached...
+#define GCNUMBLOCK (NUMCORES4GC+(BAMBOO_SHARED_MEM_SIZE-BAMBOO_LARGE_SMEM_BOUND)/BAMBOO_SMEM_SIZE)
 
+/* This macro waits for the given gc phase */
+#define WAITFORGCPHASE(phase) while(gc_status_info.gcphase != phase) ;
 
-/* Number of bits used for each alignment unit */
+/* Local block number that can never be reached...*/
+#define MAXBLOCK 0x4fffffff 
 
 //Takes in pointer to heap object and converts to offset in alignment units
 #define OBJMAPPINGINDEX(p) ALIGNOBJSIZE((unsigned INTPTR)(p-gcbaseva))
@@ -145,7 +167,7 @@ unsigned int size_cachepolicytbl;
     }                                                                \
   }
 
-#define RESIDECORE(p, c) { \
+#define RESIDECORE(c, p) {     \
     if(1 == (NUMCORES4GC)) { \
       c = 0; \
     } else { \
@@ -157,8 +179,8 @@ unsigned int size_cachepolicytbl;
 
 INLINE static unsigned int hostcore(void * ptr) {
   // check the host core of ptr
-  unsigned int host = 0;
-  RESIDECORE(ptr, host);
+  unsigned int host;
+  RESIDECORE(host, ptr);
   return host;
 }
 

diff --git a/Robust/src/Runtime/bamboo/multicoregccompact.c b/Robust/src/Runtime/bamboo/multicoregccompact.c
index 8d9e62e5afbf751dae572d1f61177f696cd4d379..bc58392407f2a83e9f1bf4b6a5bc296acf743181 100644 (file)
--- a/Robust/src/Runtime/bamboo/multicoregccompact.c
+++ b/Robust/src/Runtime/bamboo/multicoregccompact.c
@@ -46,7 +46,7 @@ void getSpaceRemotely(struct moveHelper *to, unsigned int minimumbytes) {
   //set flag to wait for memory
   gctomove=false;
   //send request for memory
-  send_msg_4(STARTUPCORE,GCFINISHCOMPACT,BAMBOO_NUM_OF_CORE, to->ptr, minimumbytes);
+  send_msg_3(STARTUPCORE,GCFINISHCOMPACT,BAMBOO_NUM_OF_CORE, minimumbytes);
   //wait for flag to be set that we received message
   while(!gctomove) ;
 
@@ -71,7 +71,15 @@ void getSpace(struct moveHelper *to, unsigned int minimumbytes) {
 }
 
 void compacthelper(struct moveHelper * orig,struct moveHelper * to) {
+  bool senttopmessage=false;
   while(true) {
+    if ((gcheaptop < ((unsigned INTPTR)(to->bound-to->ptr)))&&!senttopmessage) {
+      //This block is the last for this core...let the startup know
+      send_msg_3(STARTUPCORE, GCRETURNMEM, BAMBOO_NUM_OF_CORE, to->ptr+gcheaptop);
+      //Only send the message once
+      senttopmessage=true;
+    }
+
     unsigned int minimumbytes=compactblocks(orig, to);
     if (orig->ptr==orig->bound) {
       //need more data to compact
@@ -87,8 +95,8 @@ void compacthelper(struct moveHelper * orig,struct moveHelper * to) {
       getSpace(to, minimumbytes);
     }
   }
-
-  send_msg_4(STARTUPCORE,GCFINISHCOMPACT,BAMBOO_NUM_OF_CORE, to->ptr, 0);
+  
+  send_msg_3(STARTUPCORE,GCFINISHCOMPACT,BAMBOO_NUM_OF_CORE, 0);
 }
 
 /* Should be invoked with interrupt turned off. */
@@ -131,7 +139,8 @@ bool gcfindSpareMem(unsigned int requiredmem,unsigned int requiredcore) {
 /* This function is performance critical...  spend more time optimizing it */
 
 unsigned int compactblocks(struct moveHelper * orig, struct moveHelper * to) {
-  void *toptr=to->ptr;
+  void *toptrinit=to->ptr;
+  void *toptr=toptr;
   void *tobound=to->bound;
   void *origptr=orig->ptr;
   void *origbound=orig->bound;
@@ -150,6 +159,7 @@ unsigned int compactblocks(struct moveHelper * orig, struct moveHelper * to) {
          origptr=origbound;
          to->ptr=toptr;
          orig->ptr=origptr;
+         gcheaptop-=(unsigned INTPTR)(toptr-toptrinit)
          return 0;
        }
       } while(!gcmarktbl[arrayoffset]);
@@ -163,8 +173,8 @@ unsigned int compactblocks(struct moveHelper * orig, struct moveHelper * to) {
       unsigned int length=ALIGNSIZETOBYTES(objlength);
       void *endtoptr=toptr+length;
       if (endtoptr>tobound) {
-       toptr=tobound;
-       to->ptr=toptr;
+       gcheaptop-=(unsigned INTPTR)(toptr-toptrinit)   
+       to->ptr=tobound;
        orig->ptr=origptr;
        return length;
       }

diff --git a/Robust/src/Runtime/bamboo/multicoregcmark.c b/Robust/src/Runtime/bamboo/multicoregcmark.c
index df1a692aa6cdc357d1a896f4ee27beca22f86af8..9d4d136e6426889b3ad59d846f6812be0e28ce3f 100644 (file)
--- a/Robust/src/Runtime/bamboo/multicoregcmark.c
+++ b/Robust/src/Runtime/bamboo/multicoregcmark.c
@@ -266,7 +266,7 @@ void mark(bool isfirst, struct garbagelist * stackptr) {
       unsigned int type = 0;
       bool islarge=isLarge(ptr, &type, &size);
       unsigned int iunits = ALIGNUNITS(size);
-
+      
       setLengthMarked(ptr,iunits);
        
       if(islarge) {

diff --git a/Robust/src/Runtime/bamboo/multicoregcprofile.h b/Robust/src/Runtime/bamboo/multicoregcprofile.h
index b2cbdf9d092a5e71afa81034cf782e6bd7201888..9b6c906e2a5493220e651019ee732f90ba0b3329 100644 (file)
--- a/Robust/src/Runtime/bamboo/multicoregcprofile.h
+++ b/Robust/src/Runtime/bamboo/multicoregcprofile.h
@@ -112,7 +112,7 @@ INLINE static void gc_profileEnd(void) {
   { \
     if(gc_profile_flag) { \
       gc_num_livespace = 0; \
-      for(int tmpi = 0; tmpi < gcnumblock; tmpi++) { \
+      for(int tmpi = 0; tmpi < GCNUMBLOCK; tmpi++) { \
         gc_num_livespace += bamboo_smemtbl[tmpi]; \
       } \
       gc_num_freespace = (BAMBOO_SHARED_MEM_SIZE) - gc_num_livespace; \
@@ -152,7 +152,7 @@ INLINE static void gc_profileEnd(void) {
 #define GCPROFILE_RECORD_SPACE() \
   { \
     gc_num_livespace = 0; \
-    for(int tmpi = 0; tmpi < gcnumblock; tmpi++) { \
+    for(int tmpi = 0; tmpi < GCNUMBLOCK; tmpi++) { \
       gc_num_livespace += bamboo_smemtbl[tmpi]; \
     } \
     gc_num_freespace = (BAMBOO_SHARED_MEM_SIZE) - gc_num_livespace; \

diff --git a/Robust/src/Runtime/bamboo/multicoremem.c b/Robust/src/Runtime/bamboo/multicoremem.c
index 86590cbad843833692f4ed907272c6de9f6a20e2..7deab55c01564e65769b0fd22744ceff80f2b056 100644 (file)
--- a/Robust/src/Runtime/bamboo/multicoremem.c
+++ b/Robust/src/Runtime/bamboo/multicoremem.c
@@ -75,7 +75,7 @@ void * fixedmalloc_I(int coren,
       continue;
     }
     tofindb=totest=gc_core2block[2*core2test[gccorenum][k]];
-    mem=searchBlock4Mem(&tofindb,&totest,core2test[gccorenum][k],isize,allocsize,(k==0)?0:((gcnumblock/NUMCORES4GC)>>LOCALMEMRESERVATION));
+    mem=searchBlock4Mem(&tofindb,&totest,core2test[gccorenum][k],isize,allocsize,(k==0)?0:((GCNUMBLOCK/NUMCORES4GC)>>LOCALMEMRESERVATION));
     if(mem!=NULL) {
       return mem;
     }
@@ -107,7 +107,7 @@ void * mixedmalloc_I(int coren,
       continue;
     }
     tofindb=totest=gc_core2block[2*core2test[gccorenum][k]];
-    mem=searchBlock4Mem(&tofindb,&totest,core2test[gccorenum][k],isize,allocsize,(k==0)?0:((gcnumblock/NUMCORES4GC)>>LOCALMEMRESERVATION));
+    mem=searchBlock4Mem(&tofindb,&totest,core2test[gccorenum][k],isize,allocsize,(k==0)?0:((GCNUMBLOCK/NUMCORES4GC)>>LOCALMEMRESERVATION));
     if(mem!=NULL) {
       return mem;
     }

diff --git a/Robust/src/Runtime/bamboo/multicoremsg.c b/Robust/src/Runtime/bamboo/multicoremsg.c
index 7e17de1f1b9409a0cf0ff76f4e9097c3545becef..c1520c8920bd8e037f7a361059f80577b91f47b6 100644 (file)
--- a/Robust/src/Runtime/bamboo/multicoremsg.c
+++ b/Robust/src/Runtime/bamboo/multicoremsg.c
@@ -36,7 +36,8 @@ int msgsizearray[] = {
   4, //GCFINISHPRE,           // 0xE7
   2, //GCFINISHINIT,          // 0xE8
   4, //GCFINISHMARK,          // 0xE9
-  4, //GCFINISHCOMPACT,       // 0xEa
+  3, //GCFINISHCOMPACT,       // 0xEa
+  3, //GCRETURNMEM,
   2, //GCFINISHUPDATE,         // 0xEb
   1, //GCFINISH,              // 0xEc
   1, //GCMARKCONFIRM,         // 0xEd
@@ -495,14 +496,25 @@ INLINE void processmsg_gcfinishmark_I() {
     gcnumreceiveobjs[entry_index][data1] = data3;
   }
 }
+ 
+void processmsg_returnmem_I() {
+  unsigned int cnum = msgdata[msgdataindex];
+  MSG_INDEXINC_I();  
+  void * heaptop = (void *) msgdata[msgdataindex];
+  MSG_INDEXINC_I();   
+  unsigned int blockindex;
+  BLOCKINDEX(blockindex, heaptop);
+  struct blockrecord * blockrecord=&allocationinfo.blocktable[blockindex];
+  if (cnum==blockrecord) {
+    //this is our own memory...need to clear our lower blocks
+  }
+}
 
 INLINE void processmsg_gcfinishcompact_I() {
   BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
 
   int cnum = msgdata[msgdataindex];
   MSG_INDEXINC_I();  
-  void * heaptop = (void *) msgdata[msgdataindex];
-  MSG_INDEXINC_I();   
   unsigned int bytesneeded = msgdata[msgdataindex];
   MSG_INDEXINC_I(); 
 
@@ -881,6 +893,11 @@ processmsg:
       break;
     }
 
+    case GCRETURNMEM: {
+      processmsg_returnmem_I();
+      break;
+    }
+
     case GCFINISHCOMPACT: {
       // received a compact phase finish msg
       processmsg_gcfinishcompact_I();

diff --git a/Robust/src/Runtime/bamboo/multicoremsg.h b/Robust/src/Runtime/bamboo/multicoremsg.h
index ea702bd72ef3bb745bcdcdf7b2699741ebdda27e..b18708a779c30cfa47de140223d5ee90ee8e65cf 100644 (file)
--- a/Robust/src/Runtime/bamboo/multicoremsg.h
+++ b/Robust/src/Runtime/bamboo/multicoremsg.h
@@ -180,6 +180,7 @@ typedef enum {
   GCFINISHINIT,          // 0xE8
   GCFINISHMARK,          // 0xE9
   GCFINISHCOMPACT,       // 0xEa
+  GCRETURNMEM,
   GCFINISHUPDATE,         // 0xEb
   GCFINISH,              // 0xEc
   GCMARKCONFIRM,         // 0xEd

diff --git a/Robust/src/Runtime/mem.c b/Robust/src/Runtime/mem.c
index 0ab608f1e4b09525efe8bd8482ea71d15f7667d6..972b96c18d3c0761095133385ef1281e69ff8af4 100644 (file)
--- a/Robust/src/Runtime/mem.c
+++ b/Robust/src/Runtime/mem.c
@@ -50,29 +50,16 @@ void * mycalloc_share(int size) {
 }
 #endif
 
-void * mycalloc(int size,
-                char * file,
-                int line) {
-  void * p = NULL;
-  int isize = size;
+void * mycalloc(int size, char * file, int line) {
   BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
-  p = BAMBOO_LOCAL_MEM_CALLOC(isize);
-
-  if(p == NULL) {
-    printf("mycalloc %s %d \n", file, line);
-    BAMBOO_EXIT();
-  }
+  void * p = mycalloc_i(size, file, line);
   BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
   return p;
 }
 
 
-void * mycalloc_i(int size,
-                  char * file,
-                  int line) {
-  void * p = NULL;
-  int isize = size;
-  p = BAMBOO_LOCAL_MEM_CALLOC(isize);
+void * mycalloc_i(int size, char * file, int line) {
+  void * p = BAMBOO_LOCAL_MEM_CALLOC(size);
   if(p == NULL) {
     tprintf("mycalloc_i %s %d \n", file, line);
     BAMBOO_EXIT();