From: bdemsky <bdemsky>
Date: Thu, 16 Jun 2011 21:21:01 +0000 (+0000)
Subject: more of my changes
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=eef174ffb26aec94b28425fe8e28a5626d2aa367;p=IRC.git

more of my changes
---

diff --git a/Robust/src/Runtime/bamboo/gcqueue.c b/Robust/src/Runtime/bamboo/gcqueue.c
index 3e51f265..3eb36108 100644
--- a/Robust/src/Runtime/bamboo/gcqueue.c
+++ b/Robust/src/Runtime/bamboo/gcqueue.c
@@ -4,14 +4,10 @@ struct pointerblock *gchead=NULL;
 int gcheadindex=0;
 struct pointerblock *gctail=NULL;
 int gctailindex=0;
-struct pointerblock *gctail2=NULL;
-int gctailindex2=0;
 struct pointerblock *gcspare=NULL;
 
 struct lobjpointerblock *gclobjhead=NULL;
 int gclobjheadindex=0;
 struct lobjpointerblock *gclobjtail=NULL;
 int gclobjtailindex=0;
-struct lobjpointerblock *gclobjtail2=NULL;
-int gclobjtailindex2=0;
 struct lobjpointerblock *gclobjspare=NULL;
diff --git a/Robust/src/Runtime/bamboo/gcqueue.h b/Robust/src/Runtime/bamboo/gcqueue.h
index f0761c7f..5aa15f47 100644
--- a/Robust/src/Runtime/bamboo/gcqueue.h
+++ b/Robust/src/Runtime/bamboo/gcqueue.h
@@ -27,37 +27,32 @@ extern struct pointerblock *gchead;
 extern int gcheadindex;
 extern struct pointerblock *gctail;
 extern int gctailindex;
-extern struct pointerblock *gctail2;
-extern int gctailindex2;
 extern struct pointerblock *gcspare;
 
 extern struct lobjpointerblock *gclobjhead;
 extern int gclobjheadindex;
 extern struct lobjpointerblock *gclobjtail;
 extern int gclobjtailindex;
-extern struct lobjpointerblock *gclobjtail2;
-extern int gclobjtailindex2;
 extern struct lobjpointerblock *gclobjspare;
 
 static void gc_queueinit() {
   // initialize queue
   if (gchead==NULL) {
     gcheadindex=gctailindex=gctailindex2 = 0;
-    gchead=gctail=gctail2=RUNMALLOC(sizeof(struct pointerblock));
+    gchead=gctail=RUNMALLOC(sizeof(struct pointerblock));
   } else {
-    gctailindex=gctailindex2=gcheadindex=0;
-    gctail=gctail2=gchead;
+    gctailindex=gcheadindex=0;
+    gctail=gchead;
   }
   gchead->next=NULL;
   // initialize the large obj queues
   if (gclobjhead==NULL) {
     gclobjheadindex=0;
     gclobjtailindex=0;
-    gclobjtailindex2=0;
-    gclobjhead=gclobjtail=gclobjtail2=RUNMALLOC(sizeof(struct lobjpointerblock));
+    gclobjhead=gclobjtail=RUNMALLOC(sizeof(struct lobjpointerblock));
   } else {
-    gclobjtailindex=gclobjtailindex2=gclobjheadindex=0;
-    gclobjtail=gclobjtail2=gclobjhead;
+    gclobjtailindex=gclobjheadindex=0;
+    gclobjtail=gclobjhead;
   }
   gclobjhead->next=gclobjhead->prev=NULL;
 }
@@ -98,23 +93,10 @@ static void * gc_dequeue_I() {
   return gctail->ptrs[gctailindex++];
 } 
 
-// dequeue and do not destroy the queue
-static void * gc_dequeue2_I() {
-  if (gctailindex2==NUMPTRS) {
-    gctail2=gctail2->next;
-    gctailindex2=0;
-  } 
-  return gctail2->ptrs[gctailindex2++];
-}
-
 static int gc_moreItems_I() {
   return !((gchead==gctail)&&(gctailindex==gcheadindex));
 } 
 
-static int gc_moreItems2_I() {
-  return !((gchead==gctail2)&&(gctailindex2==gcheadindex));
-} 
-
 // should be invoked with interruption closed 
 // enqueue a large obj: start addr & length
 static void gc_lobjenqueue_I(void * ptr,
@@ -169,58 +151,6 @@ static int gc_lobjmoreItems_I() {
   return !((gclobjhead==gclobjtail)&&(gclobjtailindex==gclobjheadindex));
 } 
 
-// dequeue and don't destroy the queue
-static void gc_lobjdequeue2_I() {
-  if (gclobjtailindex2==NUMLOBJPTRS) {
-    gclobjtail2=gclobjtail2->next;
-    gclobjtailindex2=1;
-  } else {
-    gclobjtailindex2++;
-  }  
-}
-
-static int gc_lobjmoreItems2_I() {
-  return !((gclobjhead==gclobjtail2)&&(gclobjtailindex2==gclobjheadindex));
-} 
-
-// 'reversly' dequeue and don't destroy the queue
-static void gc_lobjdequeue3_I() {
-  if (gclobjtailindex2==0) {
-    gclobjtail2=gclobjtail2->prev;
-    gclobjtailindex2=NUMLOBJPTRS-1;
-  } else {
-    gclobjtailindex2--;
-  }  
-}
-
-static int gc_lobjmoreItems3_I() {
-  return !((gclobjtail==gclobjtail2)&&(gclobjtailindex2==gclobjtailindex));
-} 
-
-static void gc_lobjqueueinit4_I() {
-  gclobjtail2 = gclobjtail;
-  gclobjtailindex2 = gclobjtailindex;
-} 
-
-static void * gc_lobjdequeue4_I(unsigned int * length,
-                                      unsigned int * host) {
-  if (gclobjtailindex2==NUMLOBJPTRS) {
-    gclobjtail2=gclobjtail2->next;
-    gclobjtailindex2=0;
-  } 
-  if(length != NULL) {
-    *length = gclobjtail2->lengths[gclobjtailindex2];
-  }
-  if(host != NULL) {
-    *host = (unsigned int)(gclobjtail2->hosts[gclobjtailindex2]);
-  }
-  return gclobjtail2->lobjs[gclobjtailindex2++];
-} 
-
-static int gc_lobjmoreItems4_I() {
-  return !((gclobjhead==gclobjtail2)&&(gclobjtailindex2==gclobjheadindex));
-}
-
 ////////////////////////////////////////////////////////////////////
 // functions that can be invoked in normal places
 ////////////////////////////////////////////////////////////////////
@@ -268,25 +198,6 @@ static int gc_moreItems() {
   return r;
 }
 
-// dequeue and do not destroy the queue
-static void * gc_dequeue2() {
-  BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
-  if (gctailindex2==NUMPTRS) {
-    gctail2=gctail2->next;
-    gctailindex2=0;
-  } 
-  void * r = gctail2->ptrs[gctailindex2++];
-  BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
-  return r;
-}
-
-static int gc_moreItems2() {
-  BAMBOO_ENTER_RUNTIME_MODE_FROM_CLIENT();
-  int r = !((gchead==gctail2)&&(gctailindex2==gcheadindex));
-  BAMBOO_ENTER_CLIENT_MODE_FROM_RUNTIME();
-  return r;
-}
-
 static void gc_lobjenqueue(void * ptr,
                            unsigned int length,
                            unsigned int host) {
diff --git a/Robust/src/Runtime/bamboo/markbit.h b/Robust/src/Runtime/bamboo/markbit.h
index 740403e5..93eddbac 100644
--- a/Robust/src/Runtime/bamboo/markbit.h
+++ b/Robust/src/Runtime/bamboo/markbit.h
@@ -11,7 +11,19 @@ extern unsigned int revmarkmappingarray[];
 #define OBJMASK 0x40000000  //set towhatever smallest object mark is
 #define MARKMASK 0xc0000000  //set towhatever smallest object mark is
 
-
+/* 
+   The bitmap mark array uses 2 mark bits per alignment unit.
+
+   The clever trick is that we encode the length of the object (in
+   units of alignment units) using just these two bits.  The basic
+   idea is to generate a variable length encoding of the length in
+   which the length of the encoding is shorter than number of mark
+   bits taken up by the object.
+
+   To make this efficient, it is table driven for objects that are
+   less than 16 alignment units in length.  For larger objects, we
+   just use addition.
+*/
 
 /* Return length in units of ALIGNSIZE */
 
diff --git a/Robust/src/Runtime/bamboo/multicoregarbage.c b/Robust/src/Runtime/bamboo/multicoregarbage.c
index 98123fef..eff4fb25 100644
--- a/Robust/src/Runtime/bamboo/multicoregarbage.c
+++ b/Robust/src/Runtime/bamboo/multicoregarbage.c
@@ -730,56 +730,6 @@ void master_getlargeobjs() {
   BAMBOO_ASSERTMSG(cacheLObjs(), "Not enough space to cache large objects\n");
 }
 
-void master_compact() {
-  // predict number of blocks to fill for each core
-  void * tmpheaptop = 0;
-  int numpbc = loadbalance(&tmpheaptop);
-  //tprintf("numpbc: %d \n", numpbc);
-
-  numpbc = BAMBOO_SHARED_MEM_SIZE/BAMBOO_SMEM_SIZE;
-  GC_PRINTF("mark phase finished \n");
-  
-  tmpheaptop = gcbaseva + BAMBOO_SHARED_MEM_SIZE;
-  for(int i = 0; i < NUMCORES4GC; i++) {
-    unsigned int tmpcoreptr = 0;
-    BASEPTR(i, numpbc, &tmpcoreptr);
-    // init some data strutures for compact phase
-    gcloads[i] = NULL;
-    gcfilledblocks[i] = 0;
-    gcrequiredmems[i] = 0;
-    gccorestatus[i] = 1;
-    //send start compact messages to all cores
-    //TODO bug here, do not know if the direction is positive or negtive?
-    //if (tmpcoreptr < tmpheaptop) {
-      gcstopblock[i] = numpbc+1;
-      if(i != STARTUPCORE) {
-        send_msg_2(i, GCSTARTCOMPACT, numpbc+1);
-      } else {
-        gcblock2fill = numpbc+1;
-      }
-    /*} else {
-      gcstopblock[i] = numpbc;
-      if(i != STARTUPCORE) {
-        send_msg_2(i, GCSTARTCOMPACT, numpbc);
-      } else {
-        gcblock2fill = numpbc;
-      }
-    }*/
-  }
-  BAMBOO_CACHE_MF();
-  GCPROFILE_ITEM();
-  // compact phase
-  struct moveHelper * orig = (struct moveHelper *)RUNMALLOC(sizeof(struct moveHelper));
-  struct moveHelper * to = (struct moveHelper *)RUNMALLOC(sizeof(struct moveHelper));
-  compact_master(orig, to); 
-  GCPROFILE_ITEM();
-  GC_PRINTF("prepare to move large objs \n");
-  // move largeObjs
-  moveLObjs();
-  GC_PRINTF("compact phase finished \n");
-  RUNFREE(orig);
-  RUNFREE(to);
-}
 
 void master_updaterefs(struct garbagelist * stackptr) {
   gc_status_info.gcphase = FLUSHPHASE;
diff --git a/Robust/src/Runtime/bamboo/multicoregarbage.h b/Robust/src/Runtime/bamboo/multicoregarbage.h
index 88c8dbc1..8cdd75dd 100644
--- a/Robust/src/Runtime/bamboo/multicoregarbage.h
+++ b/Robust/src/Runtime/bamboo/multicoregarbage.h
@@ -43,7 +43,7 @@ extern volatile bool gcflag;
 extern gc_status_t gc_status_info;
 volatile bool gcprecheck; // indicates if there are updated pregc information
 
-unsigned int gccurr_heaptop;
+unsigned INTPTR gccurr_heaptop;
 struct MGCHash * gcforwardobjtbl; // cache forwarded objs in mark phase
 // for mark phase termination
 volatile unsigned int gccorestatus[NUMCORESACTIVE];//records status of each core
@@ -131,32 +131,13 @@ unsigned int size_cachepolicytbl;
 #define ALIGNMENTSHIFT 5
 
 /* Number of bits used for each alignment unit */
-#define BITSPERALIGNMENT 2
+
 #define ALIGNOBJSIZE(x) (x>>ALIGNMENTSHIFT)
 #define OBJMAPPINGINDEX(p) ALIGNOBJSIZE((unsigned INTPTR)(p-gcbaseva))
+#define ALIGNUNITS(s) (((s-1)>>ALIGNMENTSHIFT)+1)
 
-//There are two bits per object
-//00 means not marked
-//11 means first block of object
-//10 means marked block
-
-#define UNMARKED 0
-#define MARKEDFIRST 3
-#define MARKEDLATER 2
-
-//sets y to the marked status of x
-#define GETMARKED(y,x) { unsigned INTPTR offset=ALIGNOBJSIZE((unsigned INTPTR)(x-gcbaseva)); \
-    y=(gcmarktbl[offset>>4]>>((offset&15)<<1))&3; }
-
-//sets the marked status of x to y (assumes zero'd)
-#define SETMARKED(y,x) { unsigned INTPTR offset=ALIGNOBJSIZE((unsigned INTPTR)(x-gcbaseva)); \
-    gcmarktbl[offset>>4]|=y<<((offset&15)<<1); }
-
-//sets the marked status of x to y (assumes zero'd)
-#define RESETMARKED(x) { unsigned INTPTR offset=ALIGNOBJSIZE((unsigned INTPTR)(x-gcbaseva)); \
-    gcmarktbl[offset>>4]&=~(3<<((offset&15)<<1)); }
 
-#define ALIGNSIZE(s, as) (*((unsigned int*)as))=((((unsigned int)(s-1))&(~(BAMBOO_CACHE_LINE_MASK)))+(BAMBOO_CACHE_LINE_SIZE))
+#define ALIGNSIZE(s) ((((unsigned int)(s-1))&~(ALIGNMENTBYTES-1))+ALIGNMENTBYTES)
 
 
 // mapping of pointer to block # (start from 0), here the block # is
diff --git a/Robust/src/Runtime/bamboo/multicoregccompact.c b/Robust/src/Runtime/bamboo/multicoregccompact.c
index d5783af9..1fdbdfdf 100644
--- a/Robust/src/Runtime/bamboo/multicoregccompact.c
+++ b/Robust/src/Runtime/bamboo/multicoregccompact.c
@@ -524,38 +524,74 @@ bool compacthelper(struct moveHelper * orig,struct moveHelper * to,int * filledb
       CACHEADAPT_SAMPLING_DATA_REVISE_INIT(orig, to);
     } else
       return true;
-}
+  }
 }
 
 void compact() {
   BAMBOO_ASSERT(COMPACTPHASE == gc_status_info.gcphase);
   BAMBOO_CACHE_MF();
   
-  // initialize pointers for comapcting
-  struct moveHelper * orig = (struct moveHelper *)RUNMALLOC(sizeof(struct moveHelper));
-  struct moveHelper * to = (struct moveHelper *)RUNMALLOC(sizeof(struct moveHelper));
-  if(!initOrig_Dst(orig, to)) {
+  // initialize structs for compacting
+  struct moveHelper orig={0,NULL,NULL,0,NULL,0,0,0,0};
+  struct moveHelper to={0,NULL,NULL,0,NULL,0,0,0,0};
+  if(!initOrig_Dst(&orig, &to)) {
     // no available data to compact
     // send compact finish msg to STARTUP core
-    send_msg_6(STARTUPCORE,GCFINISHCOMPACT,BAMBOO_NUM_OF_CORE,false,0,to->base,0);
-    RUNFREE(orig);
-    RUNFREE(to);
+    send_msg_6(STARTUPCORE,GCFINISHCOMPACT,BAMBOO_NUM_OF_CORE,false,0,to.base,0);
   } else {
     CACHEADAPT_SAMPLING_DATA_REVISE_INIT(orig, to);
 
     unsigned int filledblocks = 0;
     void * heaptopptr = NULL;
     bool localcompact = true;
-    compacthelper(orig, to, &filledblocks, &heaptopptr, &localcompact, false);
-    RUNFREE(orig);
-    RUNFREE(to);
+    compacthelper(&orig, &to, &filledblocks, &heaptopptr, &localcompact, false);
   }
 } 
 
-void compact_master(struct moveHelper * orig, struct moveHelper * to) {
-  // initialize pointers for comapcting
-  initOrig_Dst(orig, to);
-  CACHEADAPT_SAMPLING_DATA_REVISE_INIT(orig, to);
+void master_compact() {
+  // predict number of blocks to fill for each core
+  void * tmpheaptop = 0;
+  int numpbc = loadbalance(&tmpheaptop);
+
+  numpbc = BAMBOO_SHARED_MEM_SIZE/BAMBOO_SMEM_SIZE;
+  GC_PRINTF("mark phase finished \n");
+  
+  tmpheaptop = gcbaseva + BAMBOO_SHARED_MEM_SIZE;
+  for(int i = 0; i < NUMCORES4GC; i++) {
+    unsigned int tmpcoreptr = 0;
+    BASEPTR(i, numpbc, &tmpcoreptr);
+    // init some data strutures for compact phase
+    gcloads[i] = NULL;
+    gcfilledblocks[i] = 0;
+    gcrequiredmems[i] = 0;
+    gccorestatus[i] = 1;
+    //send start compact messages to all cores
+    gcstopblock[i] = numpbc+1;
+    if(i != STARTUPCORE) {
+      send_msg_2(i, GCSTARTCOMPACT, numpbc+1);
+    } else {
+      gcblock2fill = numpbc+1;
+    }
+  }
+  BAMBOO_CACHE_MF();
+  GCPROFILE_ITEM();
+  // compact phase
+  compact_master();
+  GCPROFILE_ITEM();
+  GC_PRINTF("prepare to move large objs \n");
+  // move largeObjs
+  moveLObjs();
+  GC_PRINTF("compact phase finished \n");
+}
+
+
+void compact_master() {
+  // initialize pointers for compacting
+  struct moveHelper orig={0,NULL,NULL,0,NULL,0,0,0,0};
+  struct moveHelper to={0,NULL,NULL,0,NULL,0,0,0,0};
+
+  initOrig_Dst(&orig, &to);
+  CACHEADAPT_SAMPLING_DATA_REVISE_INIT(&orig, &to);
   int filledblocks = 0;
   void * heaptopptr = NULL;
   bool finishcompact = false;
@@ -564,7 +600,7 @@ void compact_master(struct moveHelper * orig, struct moveHelper * to) {
   bool lbmove = false;
   while((COMPACTPHASE == gc_status_info.gcphase) || (SUBTLECOMPACTPHASE == gc_status_info.gcphase)) {
     if((!finishcompact) && iscontinue) {
-      finishcompact = compacthelper(orig,to,&filledblocks,&heaptopptr,&localcompact, lbmove);
+      finishcompact = compacthelper(&orig,&to,&filledblocks,&heaptopptr,&localcompact, lbmove);
     }
     
     if(gc_checkCoreStatus()) {
@@ -582,16 +618,16 @@ void compact_master(struct moveHelper * orig, struct moveHelper * to) {
 
     if(gctomove) {
       BAMBOO_CACHE_MF();
-      to->ptr = gcmovestartaddr;
-      to->numblocks = gcblock2fill - 1;
-      to->bound = BLOCKBOUND(to->numblocks);
-      BASEPTR(gcdstcore, to->numblocks, &(to->base));
-      to->offset = to->ptr - to->base;
-      to->top = (to->numblocks==0)?(to->offset):(to->bound-BAMBOO_SMEM_SIZE+to->offset);
-      to->base = to->ptr;
-      to->offset = BAMBOO_CACHE_LINE_SIZE;
-      to->ptr += to->offset;  // for header
-      to->top += to->offset;
+      to.ptr = gcmovestartaddr;
+      to.numblocks = gcblock2fill - 1;
+      to.bound = BLOCKBOUND(to.numblocks);
+      BASEPTR(gcdstcore, to.numblocks, &(to.base));
+      to.offset = to.ptr - to.base;
+      to.top = (to.numblocks==0)?(to.offset):(to.bound-BAMBOO_SMEM_SIZE+to.offset);
+      to.base = to.ptr;
+      to.offset = BAMBOO_CACHE_LINE_SIZE;
+      to.ptr += to.offset;  // for header
+      to.top += to.offset;
       localcompact = (gcdstcore == BAMBOO_NUM_OF_CORE);
       gctomove = false;
       iscontinue = true;
diff --git a/Robust/src/Runtime/bamboo/multicoregcmark.c b/Robust/src/Runtime/bamboo/multicoregcmark.c
index a24ff69d..d349f085 100644
--- a/Robust/src/Runtime/bamboo/multicoregcmark.c
+++ b/Robust/src/Runtime/bamboo/multicoregcmark.c
@@ -48,7 +48,7 @@ INLINE bool isLarge(void * ptr, int * ttype, unsigned int * tsize) {
   unsigned INTPTR blocksize = (((unsigned INTPTR)(ptr-gcbaseva)) < BAMBOO_LARGE_SMEM_BOUND)? BAMBOO_SMEM_SIZE_L:BAMBOO_SMEM_SIZE;
 
   // ptr is a start of a block  OR it crosses the boundary of current block
-  return *tsize > blocksize;
+  return (*tsize) > blocksize;
 }
 
 INLINE unsigned int hostcore(void * ptr) {
@@ -73,16 +73,14 @@ INLINE unsigned int hostcore(void * ptr) {
 #define MARKOBJNONNULL(objptr, ii) {markObj(objptr);}
 
 // NOTE: the objptr should not be NULL and should be a shared obj
-INLINE void markObj(void * objptr) {
+void markObj(void * objptr) {
   unsigned int host = hostcore(objptr);
   if(BAMBOO_NUM_OF_CORE == host) {
-    int markedbit;
-    GETMARKED(markedbit, objptr);
     // on this core
-    if(markedbit == UNMARKED) {
+    if(!checkMark(objptr)) {
       // this is the first time that this object is discovered,
       // set the flag as DISCOVERED
-      SETMARKED(MARKEDFIRST, objptr);
+      setMark(objptr);
       gc_enqueue(objptr);
     }
   } else {
@@ -94,7 +92,7 @@ INLINE void markObj(void * objptr) {
       gcself_numsendobjs++;
     }
   }
-} 
+}
 
 INLINE void markgarbagelist(struct garbagelist * listptr) {
   for(;listptr!=NULL;listptr=listptr->next) {
@@ -202,7 +200,7 @@ INLINE void tomark(struct garbagelist * stackptr) {
   }
 
   // enqueue the bamboo_current_thread
-  MARKOBJ((void *)bamboo_current_thread, 0);
+  MARKOBJ(bamboo_current_thread, 0);
 #endif
 }
 
@@ -250,7 +248,7 @@ INLINE void scanPtrsInObj(void * ptr, int type) {
   }
 }
 
-INLINE void mark(bool isfirst, struct garbagelist * stackptr) {
+void mark(bool isfirst, struct garbagelist * stackptr) {
   if(isfirst) {
     // enqueue root objs
     tomark(stackptr);
@@ -263,29 +261,32 @@ INLINE void mark(bool isfirst, struct garbagelist * stackptr) {
   // mark phase
   while(MARKPHASE == gc_status_info.gcphase) {
     int counter = 0;
+
     while(gc_moreItems2()) {
       sendStall = false;
       gc_status_info.gcbusystatus = true;
-      unsigned int ptr = gc_dequeue2();
+      void * ptr = gc_dequeue2();
 
       unsigned int size = 0;
       unsigned int type = 0;
+      bool islarge=isLarge(ptr, &type, &size);
+      unsigned int iunits = ALIGNUNITS(size);
 
-      if(isLarge(ptr, &type, &size)) {
+      setLengthMarked(ptr,iunits);
+	
+      if(islarge) {
         // ptr is a large object and not marked or enqueued
         gc_lobjenqueue(ptr, size, BAMBOO_NUM_OF_CORE);
         gcnumlobjs++;
       } else {
         // ptr is an unmarked active object on this core
-	unsigned int isize = 0;
-        ALIGNSIZE(size, &isize);
+	unsigned int isize=iunits<<ALIGNMENTSHIFT;
         gccurr_heaptop += isize;
-
-        if((unsigned int)(ptr + size) > (unsigned int)gcmarkedptrbound) {
-          gcmarkedptrbound = (unsigned int)(ptr + size);
-        }
+	void *top=ptr+isize;
+	if (top>gcmarkedptrbound)
+	  gcmarkedptrbound=top;
       }
-
+      
       // scan the pointers in object
       scanPtrsInObj(ptr, type);
     }
diff --git a/Robust/src/Runtime/bamboo/multicoregcmark.h b/Robust/src/Runtime/bamboo/multicoregcmark.h
index dcac595d..1dac20a8 100644
--- a/Robust/src/Runtime/bamboo/multicoregcmark.h
+++ b/Robust/src/Runtime/bamboo/multicoregcmark.h
@@ -3,5 +3,14 @@
 #ifdef MULTICORE_GC
 #include "multicore.h"
 
+INLINE void gettype_size(void * ptr, int * ttype, unsigned int * tsize);
+INLINE bool isLarge(void * ptr, int * ttype, unsigned int * tsize);
+INLINE unsigned int hostcore(void * ptr);
+INLINE void markgarbagelist(struct garbagelist * listptr);
+INLINE void tomark(struct garbagelist * stackptr);
+INLINE void scanPtrsInObj(void * ptr, int type);
+void markObj(void * objptr);
+void mark(bool isfirst, struct garbagelist * stackptr);
+
 #endif // MULTICORE_GC
 #endif // BAMBOO_MULTICORE_GC_MARK_H
diff --git a/Robust/src/Runtime/bamboo/multicoremgc.h b/Robust/src/Runtime/bamboo/multicoremgc.h
index a783596d..1783f17b 100644
--- a/Robust/src/Runtime/bamboo/multicoremgc.h
+++ b/Robust/src/Runtime/bamboo/multicoremgc.h
@@ -16,6 +16,6 @@
 // data structures for threads
 unsigned int * bamboo_thread_queue;
 unsigned int bamboo_max_thread_num_mask;
-unsigned int bamboo_current_thread;
+void * bamboo_current_thread;
 #endif // MGC
 #endif // BAMBOO_MULTICORE_MGC_H
diff --git a/Robust/src/Runtime/bamboo/multicoremsg.c b/Robust/src/Runtime/bamboo/multicoremsg.c
index 8bdddcb1..cf3cdaec 100644
--- a/Robust/src/Runtime/bamboo/multicoremsg.c
+++ b/Robust/src/Runtime/bamboo/multicoremsg.c
@@ -596,15 +596,12 @@ INLINE void processmsg_gcmarkedobj_I() {
   void * data1 = (void *) msgdata[msgdataindex];
   MSG_INDEXINC_I();
   BAMBOO_ASSERT(ISSHAREDOBJ(data1));
-
+  
   // received a markedObj msg
-  int markedbit;
-  GETMARKED(markedbit, data1);
-
-  if(markedbit==UNMARKED) {
+  if(!checkMark(objptr)) {
     // this is the first time that this object is discovered,
     // set the flag as DISCOVERED
-    SETMARKED(MARKEDFIRST, data1);
+    setMark(data1);
     gc_enqueue_I(data1);
   }
   gcself_numreceiveobjs++;
diff --git a/Robust/src/Runtime/bamboo/multicoreruntime.c b/Robust/src/Runtime/bamboo/multicoreruntime.c
index 036bb827..3d9ddb31 100644
--- a/Robust/src/Runtime/bamboo/multicoreruntime.c
+++ b/Robust/src/Runtime/bamboo/multicoreruntime.c
@@ -622,7 +622,7 @@ INLINE void initruntimedata() {
 
 #ifdef MGC
   initializethreads();
-  bamboo_current_thread = 0;
+  bamboo_current_thread = NULL;
 #endif // MGC
 
   INITTASKDATA();