#include "multicoreruntime.h"
#include "multicoregarbage.h"
#include "multicoretaskprofile.h"
+#include "runtime_arch.h"
+#ifdef MULTICORE_GC
#include "gcqueue.h"
+#include "markbit.h"
+#endif
+#ifdef PERFCOUNT
+#include "bme_perf_counter.h"
+#endif
int msgsizearray[] = {
0, //MSGSTART,
+ 1, //REQNOTIFYSTART
+ 1, //NOTIFYSTART
-1, //TRANSOBJ, // 0xD1
4, //TRANSTALL, // 0xD2
5, //LOCKREQUEST, // 0xD3
1, //TERMINATE, // 0xDf
3, //MEMREQUEST, // 0xE0
3, //MEMRESPONSE, // 0xE1
-#ifdef MULTICORE_GC
+#ifdef PERFCOUNT
+ 1,
+ 1,
+#endif
+#if defined(MULTICORE_GC)||defined(PMC_GC)
+ 1, //GCINVOKE
1, //GCSTARTPRE, // 0xE2
+#endif
+#ifdef MULTICORE_GC
1, //GCSTARTINIT, // 0xE3
1, //GCSTART, // 0xE4
2, //GCSTARTCOMPACT, // 0xE5
- 1, //GCSTARTFLUSH, // 0xE6
+ 1, //GCSTARTUPDATE, // 0xE6
4, //GCFINISHPRE, // 0xE7
2, //GCFINISHINIT, // 0xE8
4, //GCFINISHMARK, // 0xE9
- 6, //GCFINISHCOMPACT, // 0xEa
- 2, //GCFINISHFLUSH, // 0xEb
+ 4, //GCFINISHCOMPACT, // 0xEa
+ 3, //GCRETURNMEM,
+ 2, //GCFINISHUPDATE, // 0xEb
1, //GCFINISH, // 0xEc
1, //GCMARKCONFIRM, // 0xEd
5, //GCMARKREPORT, // 0xEe
2, //GCMARKEDOBJ, // 0xEf
- 4, //GCMOVESTART, // 0xF0
- 1, //GCLOBJREQUEST, // 0xF1
- -1, //GCLOBJINFO, // 0xF2
+ 2, //GCMOVESTART, // 0xF0
+ 1, //GCLOBJREQUEST, // 0xF1
+ 3, //GCREQBLOCK,
+ 1, //GCGRANTBLOCK,
+ -1, //GCLOBJINFO, // 0xF2
#ifdef GC_PROFILE
- 4, //GCPROFILES, // 0xF3
+ 3, //GCPROFILES, // 0xF3
#endif // GC_PROFILE
#ifdef GC_CACHE_ADAPT
1, //GCSTARTCACHEPOLICY // 0xF4
-1 //MSGEND
};
-INLINE unsigned int checkMsgLength_I(unsigned int realtype) {
+unsigned int checkMsgLength_I(unsigned int realtype) {
#if (defined(TASK)||defined(MULTICORE_GC))
unsigned int type = realtype & 0xff;
#else
#endif
BAMBOO_ASSERT(type<=MSGEND);
#ifdef TASK
-#ifdef MULTICORE_GC
+#if defined(MULTICORE_GC)
if(type==TRANSOBJ||type==GCLOBJINFO) {
#else
if(type==TRANSOBJ) {
#endif
-#elif MULTICORE_GC
+#elif defined(MULTICORE_GC)
if (type==GCLOBJINFO) {
#endif
#if (defined(TASK)||defined(MULTICORE_GC))
}
#ifdef TASK
-INLINE void processmsg_transobj_I(int msglength) {
+void processmsg_transobj_I(int msglength) {
struct transObjInfo * transObj=RUNMALLOC_I(sizeof(struct transObjInfo));
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
}
#endif
-INLINE void processmsg_transtall_I() {
+void processmsg_transtall_I() {
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
int num_core = msgdata[msgdataindex];
}
}
-#ifndef MULTICORE_GC
-INLINE void processmsg_lockrequest_I() {
+#if !defined(MULTICORE_GC)&&!defined(PMC_GC)
+void processmsg_lockrequest_I() {
// check to see if there is a lock exist for the required obj
// msgdata[1] -> lock type
int locktype = msgdata[msgdataindex];
}
}
-INLINE void processmsg_lockgrount_I() {
+void processmsg_lockgrount_I() {
MSG_INDEXINC_I();
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
int data2 = msgdata[msgdataindex];
#endif
}
-INLINE void processmsg_lockdeny_I() {
+void processmsg_lockdeny_I() {
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
MSG_INDEXINC_I();
#endif
}
-INLINE void processmsg_lockrelease_I() {
+void processmsg_lockrelease_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
processlockrelease(data1, data2, 0, false);
}
-INLINE void processmsg_redirectlock_I() {
+void processmsg_redirectlock_I() {
// check to see if there is a lock exist for the required obj
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I(); // lock type
}
}
-INLINE void processmsg_redirectgrount_I() {
+void processmsg_redirectgrount_I() {
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
MSG_INDEXINC_I();
#endif
}
-INLINE void processmsg_redirectdeny_I() {
+void processmsg_redirectdeny_I() {
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
MSG_INDEXINC_I();
#endif
}
-INLINE void processmsg_redirectrelease_I() {
+void processmsg_redirectrelease_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
#endif // #ifndef MULTICORE_GC
#ifdef PROFILE
-INLINE void processmsg_profileoutput_I() {
+void processmsg_profileoutput_I() {
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE != STARTUPCORE);
stall = true;
totalexetime = msgdata[msgdataindex];
MSG_INDEXINC_I();
-#ifdef RT_TEST
-#else
+#if !defined(RT_TEST)
outputProfileData();
#endif
// cache the msg first
}
}
-INLINE void processmsg_profilefinish_I() {
+void processmsg_profilefinish_I() {
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
numconfirm--;
}
#endif // PROFILE
-INLINE void processmsg_statusconfirm_I() {
+void processmsg_statusconfirm_I() {
BAMBOO_ASSERT(((BAMBOO_NUM_OF_CORE != STARTUPCORE) && (BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1)));
// send response msg
// cache the msg first
}
}
-INLINE void processmsg_statusreport_I() {
+void processmsg_statusreport_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
numreceiveobjs[data2] = data4;
}
-INLINE void processmsg_terminate_I() {
+void processmsg_terminate_I() {
disruntimedata();
-#ifdef MULTICORE_GC
-#ifdef GC_CACHE_ADAPT
+#if defined(MULTICORE_GC)&&defined(GC_CACHE_ADAPT)&&defined(GC_CACHE_SAMPLING)&&(defined(GC_CACHE_ADAPT_POLICY4)||defined(GC_CACHE_ADAPT_POLICY3))
bamboo_mask_timer_intr(); // disable the TILE_TIMER interrupt
-#endif
#endif
BAMBOO_EXIT_APP(0);
}
-INLINE void processmsg_memrequest_I() {
+#ifndef PMC_GC
+void processmsg_memrequest_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
MSG_INDEXINC_I();
// receive a shared memory request msg
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
- int allocsize = 0;
- void * mem = NULL;
#ifdef MULTICORE_GC
if(!gc_status_info.gcprocessing || !gcflag) {
// either not doing GC or the master core has decided to stop GC but
// // still sending msgs to other cores to inform them to stop the GC
#endif
- mem = smemalloc_I(data2, data1, &allocsize);
+ unsigned INTPTR allocsize = 0;
+ void * mem = smemalloc_I(data2, data1, &allocsize);
if(mem != NULL) {
// send the start_va to request core, cache the msg first
if(BAMBOO_CHECK_SEND_MODE()) {
- cache_msg_3_I(data2,MEMRESPONSE,mem,allocsize);
+ cache_msg_3_I(data2,MEMRESPONSE,(unsigned INTPTR) mem,allocsize);
} else {
- send_msg_3_I(data2,MEMRESPONSE,mem,allocsize);
+ send_msg_3_I(data2,MEMRESPONSE,(unsigned INTPTR) mem,allocsize);
}
} //else if mem == NULL, the gcflag of the startup core has been set
// and all the other cores have been informed to start gc
#endif
}
-INLINE void processmsg_memresponse_I() {
- int data1 = msgdata[msgdataindex];
+void processmsg_memresponse_I() {
+ void * memptr =(void *) msgdata[msgdataindex];
MSG_INDEXINC_I();
- int data2 = msgdata[msgdataindex];
+ unsigned int numbytes = msgdata[msgdataindex];
MSG_INDEXINC_I();
// receive a shared memory response msg
#ifdef MULTICORE_GC
// if is currently doing gc, dump this msg
if(!gc_status_info.gcprocessing) {
#endif
- if(data2 == 0) {
+ if(numbytes == 0) {
#ifdef MULTICORE_GC
- // Zero out the remaining memory here because for the GC_CACHE_ADAPT
- // version, we need to make sure during the gcinit phase the shared heap
- // is not touched. Otherwise, there would be problem when adapt the cache
- // strategy.
- BAMBOO_CLOSE_CUR_MSP();
bamboo_smem_zero_top = NULL;
#endif
bamboo_smem_size = 0;
- bamboo_cur_msp = 0;
+ bamboo_cur_msp = NULL;
} else {
#ifdef MULTICORE_GC
- CLOSEBLOCK(data1, data2);
- bamboo_smem_size = data2 - BAMBOO_CACHE_LINE_SIZE;
- bamboo_cur_msp = data1 + BAMBOO_CACHE_LINE_SIZE;
- bamboo_smem_zero_top = bamboo_cur_msp;
+ bamboo_smem_size = numbytes;
+ bamboo_cur_msp = memptr;
#else
- bamboo_smem_size = data2;
- bamboo_cur_msp =(void*)(data1);
+ bamboo_smem_size = numbytes;
+ bamboo_cur_msp =memptr;
#endif
}
smemflag = true;
}
#endif
}
+#endif //ifndef PMCGC
+
+#if defined(MULTICORE_GC)||defined(PMC_GC)
+void processmsg_gcinvoke_I() {
+ BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE==STARTUPCORE);
#ifdef MULTICORE_GC
-INLINE void processmsg_gcstartpre_I() {
- // the first time to be informed to start gc
- gcflag = true;
- if(!smemflag) {
- // Zero out the remaining memory here because for the GC_CACHE_ADAPT
- // version, we need to make sure during the gcinit phase the shared heap
- // is not touched. Otherwise, there would be problem when adapt the cache
- // strategy.
- BAMBOO_CLOSE_CUR_MSP();
- bamboo_smem_size = 0;
- bamboo_cur_msp = NULL;
- smemflag = true;
- bamboo_smem_zero_top = NULL;
+ if(!gc_status_info.gcprocessing && !gcflag) {
+ gcflag = true;
+ gcprecheck = true;
+ for(int i = 0; i < NUMCORESACTIVE; i++) {
+ // reuse the gcnumsendobjs & gcnumreceiveobjs
+ gcnumsendobjs[0][i] = 0;
+ gcnumreceiveobjs[0][i] = 0;
+ }
+#endif
+#ifdef PMC_GC
+ if(!gcflag) {
+ gcflag = true;
+#endif
+ for(int i = 0; i < NUMCORES4GC; i++) {
+ if(i != STARTUPCORE) {
+ if(BAMBOO_CHECK_SEND_MODE()) {
+ cache_msg_1_I(i,GCSTARTPRE);
+ } else {
+ send_msg_1_I(i,GCSTARTPRE);
+ }
+ }
+ }
}
}
-INLINE void processmsg_gcstartinit_I() {
+void processmsg_gcstartpre_I() {
+ // the first time to be informed to start gc
+ gcflag = true;
+}
+#endif
+#ifdef MULTICORE_GC
+void processmsg_gcstartinit_I() {
gc_status_info.gcphase = INITPHASE;
}
-INLINE void processmsg_gcstart_I() {
+void processmsg_gcstart_I() {
// set the GC flag
gc_status_info.gcphase = MARKPHASE;
}
-INLINE void processmsg_gcstartcompact_I() {
+void processmsg_gcstartcompact_I() {
gcblock2fill = msgdata[msgdataindex];
MSG_INDEXINC_I();
+ BAMBOO_ASSERT(!gc_status_info.gcbusystatus);
gc_status_info.gcphase = COMPACTPHASE;
}
-INLINE void processmsg_gcstartflush_I() {
- gc_status_info.gcphase = FLUSHPHASE;
+void processmsg_gcstartupdate_I() {
+ gc_status_info.gcphase = UPDATEPHASE;
}
-INLINE void processmsg_gcfinishpre_I() {
+void processmsg_gcfinishpre_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
gcnumreceiveobjs[0][data1] = data3;
}
-INLINE void processmsg_gcfinishinit_I() {
+void processmsg_gcfinishinit_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
// received a init phase finish msg
}
}
-INLINE void processmsg_gcfinishmark_I() {
- int data1 = msgdata[msgdataindex];
+void processmsg_reqblock_I() {
+ int cnum=msgdata[msgdataindex];
MSG_INDEXINC_I();
- int data2 = msgdata[msgdataindex];
+ void * topptr= (void *)msgdata[msgdataindex];
MSG_INDEXINC_I();
- int data3 = msgdata[msgdataindex];
+ if (topptr<=update_origblockptr) {
+ //send message
+ if(BAMBOO_CHECK_SEND_MODE()) {
+ cache_msg_1_I(cnum,GCGRANTBLOCK);
+ } else {
+ send_msg_1_I(cnum,GCGRANTBLOCK);
+ }
+ } else {
+ //store message
+ origblockarray[cnum]=topptr;
+ origarraycount++;
+ }
+}
+
+void processmsg_grantblock_I() {
+ blockgranted=true;
+}
+
+
+void processmsg_gcfinishmark_I() {
+ int cnum = msgdata[msgdataindex];
+ MSG_INDEXINC_I();
+ int nsend = msgdata[msgdataindex];
+ MSG_INDEXINC_I();
+ int nrecv = msgdata[msgdataindex];
MSG_INDEXINC_I();
// received a mark phase finish msg
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
+ BAMBOO_ASSERT(gc_status_info.gcphase == MARKPHASE);
// all cores should do mark
- if(data1 < NUMCORESACTIVE) {
- gccorestatus[data1] = 0;
+ if(cnum < NUMCORESACTIVE) {
+ gccorestatus[cnum] = 0;
int entry_index = 0;
if(waitconfirm) {
// phase 2
// phase 1
entry_index = gcnumsrobjs_index;
}
- gcnumsendobjs[entry_index][data1] = data2;
- gcnumreceiveobjs[entry_index][data1] = data3;
+ gcnumsendobjs[entry_index][cnum] = nsend;
+ gcnumreceiveobjs[entry_index][cnum] = nrecv;
}
}
+
+void processmsg_returnmem_I() {
+ unsigned int cnum = msgdata[msgdataindex];
+ MSG_INDEXINC_I();
+ void * heaptop = (void *) msgdata[msgdataindex];
+ MSG_INDEXINC_I();
+
+ handleReturnMem_I(cnum, heaptop);
+}
-INLINE void processmsg_gcfinishcompact_I() {
- BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
+void * handlegcfinishcompact_I(int cnum, unsigned int bytesneeded, unsigned int maxbytesneeded) {
+ if(bytesneeded > 0) {
+ // ask for more mem
+ return gcfindSpareMem_I(bytesneeded, maxbytesneeded, cnum);
+ } else {
+ //done with compacting
+ gccorestatus[cnum] = 0;
+ return NULL;
+ }
+}
+void processmsg_gcfinishcompact_I() {
int cnum = msgdata[msgdataindex];
MSG_INDEXINC_I();
- bool loadbalancemove = msgdata[msgdataindex];
- MSG_INDEXINC_I();
- int filledblocks = msgdata[msgdataindex];
- MSG_INDEXINC_I();
- int heaptop = msgdata[msgdataindex];
- MSG_INDEXINC_I();
- int data4 = msgdata[msgdataindex];
+ unsigned int bytesneeded = msgdata[msgdataindex];
MSG_INDEXINC_I();
- // only gc cores need to do compact
- if(cnum < NUMCORES4GC) {
- if(!loadbalancemove && (COMPACTPHASE == gc_status_info.gcphase)) {
- gcfilledblocks[cnum] = filledblocks;
- gcloads[cnum] = heaptop;
- }
- if(data4 > 0) {
- // ask for more mem
- int startaddr = 0;
- int tomove = 0;
- int dstcore = 0;
- if(gcfindSpareMem_I(&startaddr, &tomove, &dstcore, data4, cnum)) {
- // cache the msg first
- if(BAMBOO_CHECK_SEND_MODE()) {
- cache_msg_4_I(cnum,GCMOVESTART,dstcore,startaddr,tomove);
- } else {
- send_msg_4_I(cnum,GCMOVESTART,dstcore,startaddr,tomove);
- }
- }
+ unsigned int maxbytesneeded = msgdata[msgdataindex];
+ MSG_INDEXINC_I();
+
+ void * startaddr=handlegcfinishcompact_I(cnum, bytesneeded, maxbytesneeded);
+ if (startaddr) {
+ if(BAMBOO_CHECK_SEND_MODE()) {
+ cache_msg_2_I(cnum,GCMOVESTART,(unsigned INTPTR)startaddr);
} else {
- gccorestatus[cnum] = 0;
- }
- }
+ send_msg_2_I(cnum,GCMOVESTART,(unsigned INTPTR)startaddr);
+ }
+ }
}
-INLINE void processmsg_gcfinishflush_I() {
+void processmsg_gcfinishupdate_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
- // received a flush phase finish msg
+ // received a update phase finish msg
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
- // all cores should do flush
+ // all cores should do update
if(data1 < NUMCORESACTIVE) {
gccorestatus[data1] = 0;
}
}
-INLINE void processmsg_gcfinish_I() {
+void processmsg_gcfinish_I() {
// received a GC finish msg
gc_status_info.gcphase = FINISHPHASE;
gc_status_info.gcprocessing = false;
}
-INLINE void processmsg_gcmarkconfirm_I() {
+void processmsg_gcmarkconfirm_I() {
BAMBOO_ASSERT(((BAMBOO_NUM_OF_CORE!=STARTUPCORE)&&(BAMBOO_NUM_OF_CORE<=NUMCORESACTIVE-1)));
- gc_status_info.gcbusystatus = gc_moreItems2_I();
// send response msg, cahce the msg first
if(BAMBOO_CHECK_SEND_MODE()) {
cache_msg_5_I(STARTUPCORE,GCMARKREPORT,BAMBOO_NUM_OF_CORE,gc_status_info.gcbusystatus,gcself_numsendobjs,gcself_numreceiveobjs);
}
}
-INLINE void processmsg_gcmarkreport_I() {
+void processmsg_gcmarkreport_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
}
-INLINE void processmsg_gcmarkedobj_I() {
- int data1 = msgdata[msgdataindex];
+void processmsg_gcmarkedobj_I() {
+ void * objptr = (void *) msgdata[msgdataindex];
MSG_INDEXINC_I();
- BAMBOO_ASSERT(ISSHAREDOBJ(data1));
-
+
// received a markedObj msg
- if(((struct ___Object___ *)data1)->marked == INIT) {
+ if(!checkMark(objptr)) {
// this is the first time that this object is discovered,
// set the flag as DISCOVERED
- ((struct ___Object___ *)data1)->marked = DISCOVERED;
- gc_enqueue_I(data1);
+
+ setMark_I(objptr);
+ gc_enqueue_I(objptr);
}
gcself_numreceiveobjs++;
gc_status_info.gcbusystatus = true;
}
-INLINE void processmsg_gcmovestart_I() {
+void processmsg_gcmovestart_I() {
gctomove = true;
- gcdstcore = msgdata[msgdataindex];
- MSG_INDEXINC_I();
gcmovestartaddr = msgdata[msgdataindex];
MSG_INDEXINC_I();
- gcblock2fill = msgdata[msgdataindex];
- MSG_INDEXINC_I();
}
-INLINE void processmsg_gclobjinfo_I(unsigned int data1) {
+void processmsg_gclobjinfo_I(unsigned int msglength) {
numconfirm--;
- int data2 = msgdata[msgdataindex];
+ int cnum = msgdata[msgdataindex];
MSG_INDEXINC_I();
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORES4GC - 1);
// store the mark result info
- int cnum = data2;
gcloads[cnum] = msgdata[msgdataindex];
MSG_INDEXINC_I();
- int data4 = msgdata[msgdataindex];
- MSG_INDEXINC_I();
- if(gcheaptop < data4) {
- gcheaptop = data4;
- }
+
// large obj info here
- for(int k = 4; k < data1; k+=2) {
- int lobj = msgdata[msgdataindex];
+ for(int k = 3; k < msglength; k+=2) {
+ void * lobj = (void *) msgdata[msgdataindex];
MSG_INDEXINC_I();
int length = msgdata[msgdataindex];
MSG_INDEXINC_I();
gc_lobjenqueue_I(lobj, length, cnum);
- gcnumlobjs++;
}
}
#ifdef GC_PROFILE
-INLINE void processmsg_gcprofiles_I() {
+void processmsg_gcprofiles_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
int data2 = msgdata[msgdataindex];
MSG_INDEXINC_I();
- int data3 = msgdata[msgdataindex];
- MSG_INDEXINC_I();
#ifdef MGC_SPEC
if(gc_profile_flag) {
#endif
- gc_num_obj += data1;
- gc_num_liveobj += data2;
- gc_num_forwardobj += data3;
+ gc_num_liveobj += data1;
+ gc_num_forwardobj += data2;
#ifdef MGC_SPEC
}
#endif
#endif // GC_PROFILE
#ifdef GC_CACHE_ADAPT
-INLINE void processmsg_gcstartcachepolicy_I() {
+void processmsg_gcstartcachepolicy_I() {
gc_status_info.gcphase = CACHEPOLICYPHASE;
}
-INLINE void processmsg_gcfinishcachepolicy_I() {
+void processmsg_gcfinishcachepolicy_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
- // all cores should do flush
+ // all cores should do update
if(data1 < NUMCORESACTIVE) {
gccorestatus[data1] = 0;
}
}
-INLINE void processmsg_gcstartpref_I() {
+void processmsg_gcstartpref_I() {
gc_status_info.gcphase = PREFINISHPHASE;
}
-INLINE void processmsg_gcfinishpref_I() {
+void processmsg_gcfinishpref_I() {
int data1 = msgdata[msgdataindex];
MSG_INDEXINC_I();
- // received a flush phase finish msg
+ // received a update phase finish msg
BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
- // all cores should do flush
+ // all cores should do update
if(data1 < NUMCORESACTIVE) {
gccorestatus[data1] = 0;
}
#endif // GC_CACHE_ADAPT
#endif // #ifdef MULTICORE_GC
+void processmsg_req_notify_start() {
+ startflag=true;
+ if(BAMBOO_CHECK_SEND_MODE()) {
+ cache_msg_1_I(STARTUPCORE,NOTIFYSTART);
+ } else {
+ send_msg_1_I(STARTUPCORE,NOTIFYSTART);
+ }
+}
+
+void processmsg_notify_start() {
+ numconfirm--;
+}
+
// receive object transferred from other cores
// or the terminate message from other cores
// Should be invoked in critical sections!!
}
processmsg:
// processing received msgs
- int size = 0;
- MSG_REMAINSIZE_I(&size);
+ int size;
+ MSG_REMAINSIZE_I(size);
if(size == 0) {
// not a whole msg
// have new coming msg
// have some whole msg
MSG_INDEXINC_I();
msgdatafull = false;
+
switch(type) {
+ case REQNOTIFYSTART: {
+ processmsg_req_notify_start();
+ break;
+ }
+
+ case NOTIFYSTART: {
+ processmsg_notify_start();
+ break;
+ }
+
#ifdef TASK
case TRANSOBJ: {
// receive a object transfer msg
processmsg_terminate_I();
break;
}
-
+#ifndef PMC_GC
case MEMREQUEST: {
processmsg_memrequest_I();
break;
processmsg_memresponse_I();
break;
}
-
-#ifdef MULTICORE_GC
+#endif
+#ifdef PERFCOUNT
+ case MSGPERFCOUNT: {
+ profile_stop();
+ if(BAMBOO_CHECK_SEND_MODE()) {
+ cache_msg_1_I(STARTUPCORE, MSGPERFRESPONSE);
+ } else {
+ send_msg_1_I(STARTUPCORE, MSGPERFRESPONSE);
+ }
+ break;
+ }
+ case MSGPERFRESPONSE: {
+ coreperfcount--;
+ break;
+ }
+#endif
+#if defined(MULTICORE_GC)||defined(PMC_GC)
// GC msgs
+ case GCINVOKE: {
+ processmsg_gcinvoke_I();
+ break;
+ }
+
case GCSTARTPRE: {
processmsg_gcstartpre_I();
break;
}
-
+#endif
+#ifdef MULTICORE_GC
case GCSTARTINIT: {
processmsg_gcstartinit_I();
break;
break;
}
- case GCSTARTFLUSH: {
- // received a flush phase start msg
- processmsg_gcstartflush_I();
+ case GCSTARTUPDATE: {
+ // received a update phase start msg
+ processmsg_gcstartupdate_I();
break;
}
break;
}
+ case GCRETURNMEM: {
+ processmsg_returnmem_I();
+ break;
+ }
+
case GCFINISHCOMPACT: {
// received a compact phase finish msg
processmsg_gcfinishcompact_I();
break;
}
- case GCFINISHFLUSH: {
- processmsg_gcfinishflush_I();
+ case GCFINISHUPDATE: {
+ processmsg_gcfinishupdate_I();
break;
}
break;
}
+ case GCREQBLOCK: {
+ processmsg_reqblock_I();
+ break;
+ }
+
+ case GCGRANTBLOCK: {
+ processmsg_grantblock_I();
+ break;
+ }
+
case GCLOBJINFO: {
// received a large objs info response msg
processmsg_gclobjinfo_I(msglength);
projects / IRC.git / blobdiff