2 #include "multicoremsg.h"
4 #include "multicoreruntime.h"
5 #include "multicoregarbage.h"
6 #include "multicoretaskprofile.h"
7 #include "runtime_arch.h"
13 int msgsizearray[] = {
17 -1, //TRANSOBJ, // 0xD1
18 4, //TRANSTALL, // 0xD2
19 5, //LOCKREQUEST, // 0xD3
20 4, //LOCKGROUNT, // 0xD4
21 4, //LOCKDENY, // 0xD5
22 4, //LOCKRELEASE, // 0xD6
23 2, //PROFILEOUTPUT, // 0xD7
24 1, //PROFILEFINISH, // 0xD8
25 6, //REDIRECTLOCK, // 0xD9
26 4, //REDIRECTGROUNT, // 0xDa
27 4, //REDIRECTDENY, // 0xDb
28 4, //REDIRECTRELEASE, // 0xDc
29 1, //STATUSCONFIRM, // 0xDd
30 5, //STATUSREPORT, // 0xDe
31 1, //TERMINATE, // 0xDf
32 3, //MEMREQUEST, // 0xE0
33 3, //MEMRESPONSE, // 0xE1
36 1, //GCSTARTPRE, // 0xE2
37 1, //GCSTARTINIT, // 0xE3
39 2, //GCSTARTCOMPACT, // 0xE5
40 1, //GCSTARTUPDATE, // 0xE6
41 4, //GCFINISHPRE, // 0xE7
42 2, //GCFINISHINIT, // 0xE8
43 4, //GCFINISHMARK, // 0xE9
44 4, //GCFINISHCOMPACT, // 0xEa
46 2, //GCFINISHUPDATE, // 0xEb
47 1, //GCFINISH, // 0xEc
48 1, //GCMARKCONFIRM, // 0xEd
49 5, //GCMARKREPORT, // 0xEe
50 2, //GCMARKEDOBJ, // 0xEf
51 2, //GCMOVESTART, // 0xF0
52 1, //GCLOBJREQUEST, // 0xF1
55 -1, //GCLOBJINFO, // 0xF2
57 4, //GCPROFILES, // 0xF3
60 1, //GCSTARTCACHEPOLICY // 0xF4
61 2, //GCFINISHCACHEPOLICY // 0xF5
62 1, //GCSTARTPREF, // 0xF6
63 2, //GCFINISHPREF, // 0xF7
64 #endif // GC_CACHE_ADAPT
65 #endif // MULTICORE_GC
69 unsigned int checkMsgLength_I(unsigned int realtype) {
70 #if (defined(TASK)||defined(MULTICORE_GC))
71 unsigned int type = realtype & 0xff;
73 unsigned int type = realtype;
75 BAMBOO_ASSERT(type<=MSGEND);
77 #if defined(MULTICORE_GC)
78 if(type==TRANSOBJ||type==GCLOBJINFO) {
82 #elif defined(MULTICORE_GC)
83 if (type==GCLOBJINFO) {
85 #if (defined(TASK)||defined(MULTICORE_GC))
89 return msgsizearray[type];
93 void processmsg_transobj_I(int msglength) {
94 struct transObjInfo * transObj=RUNMALLOC_I(sizeof(struct transObjInfo));
95 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
97 // store the object and its corresponding queue info, enqueue it later
98 transObj->objptr = (void *)msgdata[msgdataindex];
100 transObj->length = (msglength - 2) / 2;
101 transObj->queues = RUNMALLOC_I(sizeof(int)*(msglength - 3));
102 for(int k = 0; k < transObj->length; k++) {
103 transObj->queues[2*k] = msgdata[msgdataindex];
105 transObj->queues[2*k+1] = msgdata[msgdataindex];
108 // check if there is an existing duplicate item
109 struct QueueItem * prev = NULL;
110 for(struct QueueItem * qitem = getHead(&objqueue);qitem != NULL;qitem=(prev==NULL)?getHead(&objqueue):getNextQueueItem(prev)) {
111 struct transObjInfo * tmpinfo = (struct transObjInfo *)(qitem->objectptr);
112 if(tmpinfo->objptr == transObj->objptr) {
113 // the same object, remove outdate one
114 RUNFREE_I(tmpinfo->queues);
116 removeItem(&objqueue, qitem);
122 addNewItem_I(&objqueue, (void *)transObj);
124 self_numreceiveobjs++;
126 if(gc_status_info.gcprocessing) {
127 if(STARTUPCORE == BAMBOO_NUM_OF_CORE) {
128 // set the gcprecheck to enable checking again
131 // send a update pregc information msg to the master core
132 if(BAMBOO_CHECK_SEND_MODE()) {
133 cache_msg_4_I(STARTUPCORE,GCFINISHPRE,BAMBOO_NUM_OF_CORE,self_numsendobjs,self_numreceiveobjs);
135 send_msg_4_I(STARTUPCORE,GCFINISHPRE,BAMBOO_NUM_OF_CORE,self_numsendobjs, self_numreceiveobjs);
143 void processmsg_transtall_I() {
144 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
146 int num_core = msgdata[msgdataindex];
148 int data2 = msgdata[msgdataindex];
150 int data3 = msgdata[msgdataindex];
152 if(num_core < NUMCORESACTIVE) {
153 corestatus[num_core] = 0;
154 numsendobjs[num_core] = data2;
155 numreceiveobjs[num_core] = data3;
159 #if !defined(MULTICORE_GC)&&!defined(PMC_GC)
160 void processmsg_lockrequest_I() {
161 // check to see if there is a lock exist for the required obj
162 // msgdata[1] -> lock type
163 int locktype = msgdata[msgdataindex];
165 int data2 = msgdata[msgdataindex]; // obj pointer
167 int data3 = msgdata[msgdataindex]; // lock
169 int data4 = msgdata[msgdataindex]; // request core
171 // -1: redirected, 0: approved, 1: denied
172 int deny=processlockrequest(locktype, data3, data2, data4, data4, true);
175 // for 32 bit machine, the size is always 4 words, cache the msg first
176 int tmp = deny==1 ? LOCKDENY : LOCKGROUNT;
177 if(BAMBOO_CHECK_SEND_MODE()) {
178 cache_msg_4_I(data4,tmp,locktype,data2,data3);
180 send_msg_4_I(data4,tmp,locktype,data2,data3);
185 void processmsg_lockgrount_I() {
187 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
188 int data2 = msgdata[msgdataindex];
190 int data3 = msgdata[msgdataindex];
192 BAMBOO_ASSERT((lockobj == data2) && (lock2require == data3));
200 void processmsg_lockdeny_I() {
202 int data2 = msgdata[msgdataindex];
204 int data3 = msgdata[msgdataindex];
206 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
207 BAMBOO_ASSERT((lockobj == data2) && (lock2require == data3));
215 void processmsg_lockrelease_I() {
216 int data1 = msgdata[msgdataindex];
218 int data2 = msgdata[msgdataindex];
220 int data3 = msgdata[msgdataindex];
222 // receive lock release msg
223 processlockrelease(data1, data2, 0, false);
226 void processmsg_redirectlock_I() {
227 // check to see if there is a lock exist for the required obj
228 int data1 = msgdata[msgdataindex];
229 MSG_INDEXINC_I(); // lock type
230 int data2 = msgdata[msgdataindex];
231 MSG_INDEXINC_I(); // obj pointer
232 int data3 = msgdata[msgdataindex];
233 MSG_INDEXINC_I(); // redirect lock
234 int data4 = msgdata[msgdataindex];
235 MSG_INDEXINC_I(); // root request core
236 int data5 = msgdata[msgdataindex];
237 MSG_INDEXINC_I(); // request core
238 int deny = processlockrequest_I(data1, data3, data2, data5, data4, true);
241 // for 32 bit machine, the size is always 4 words, cache the msg first
242 if(BAMBOO_CHECK_SEND_MODE()) {
243 cache_msg_4_I(data4,deny==1?REDIRECTDENY:REDIRECTGROUNT,data1,data2,data3);
245 send_msg_4_I(data4,deny==1?REDIRECTDENY:REDIRECTGROUNT,data1,data2,data3);
250 void processmsg_redirectgrount_I() {
252 int data2 = msgdata[msgdataindex];
254 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
255 BAMBOO_ASSERT(lockobj == data2, 0xe207);
256 int data3 = msgdata[msgdataindex];
260 RuntimeHashadd_I(objRedirectLockTbl, lockobj, data3);
266 void processmsg_redirectdeny_I() {
268 int data2 = msgdata[msgdataindex];
270 int data3 = msgdata[msgdataindex];
272 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
273 BAMBOO_ASSERT(lockobj == data2);
281 void processmsg_redirectrelease_I() {
282 int data1 = msgdata[msgdataindex];
284 int data2 = msgdata[msgdataindex];
286 int data3 = msgdata[msgdataindex];
288 processlockrelease_I(data1, data2, data3, true);
290 #endif // #ifndef MULTICORE_GC
293 void processmsg_profileoutput_I() {
294 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE != STARTUPCORE);
296 totalexetime = msgdata[msgdataindex];
302 // cache the msg first
303 if(BAMBOO_CHECK_SEND_MODE()) {
304 cache_msg_1_I(STARTUPCORE,PROFILEFINISH);
306 send_msg_1_I(STARTUPCORE,PROFILEFINISH);
310 void processmsg_profilefinish_I() {
311 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
316 void processmsg_statusconfirm_I() {
317 BAMBOO_ASSERT(((BAMBOO_NUM_OF_CORE != STARTUPCORE) && (BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1)));
319 // cache the msg first
320 if(BAMBOO_CHECK_SEND_MODE()) {
321 cache_msg_5_I(STARTUPCORE,STATUSREPORT,busystatus?1:0,BAMBOO_NUM_OF_CORE,self_numsendobjs,self_numreceiveobjs);
323 send_msg_5_I(STARTUPCORE,STATUSREPORT,busystatus?1:0,BAMBOO_NUM_OF_CORE,self_numsendobjs,self_numreceiveobjs);
327 void processmsg_statusreport_I() {
328 int data1 = msgdata[msgdataindex];
330 int data2 = msgdata[msgdataindex];
332 int data3 = msgdata[msgdataindex];
334 int data4 = msgdata[msgdataindex];
336 // receive a status confirm info
337 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
341 corestatus[data2] = data1;
342 numsendobjs[data2] = data3;
343 numreceiveobjs[data2] = data4;
346 void processmsg_terminate_I() {
349 #ifdef GC_CACHE_ADAPT
350 bamboo_mask_timer_intr(); // disable the TILE_TIMER interrupt
356 void processmsg_memrequest_I() {
357 int data1 = msgdata[msgdataindex];
359 int data2 = msgdata[msgdataindex];
361 // receive a shared memory request msg
362 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
364 if(!gc_status_info.gcprocessing || !gcflag) {
365 // either not doing GC or the master core has decided to stop GC but
366 // // still sending msgs to other cores to inform them to stop the GC
368 unsigned INTPTR allocsize = 0;
369 void * mem = smemalloc_I(data2, data1, &allocsize);
371 // send the start_va to request core, cache the msg first
372 if(BAMBOO_CHECK_SEND_MODE()) {
373 cache_msg_3_I(data2,MEMRESPONSE,(unsigned INTPTR) mem,allocsize);
375 send_msg_3_I(data2,MEMRESPONSE,(unsigned INTPTR) mem,allocsize);
377 } //else if mem == NULL, the gcflag of the startup core has been set
378 // and all the other cores have been informed to start gc
384 void processmsg_memresponse_I() {
385 void * memptr =(void *) msgdata[msgdataindex];
387 unsigned int numbytes = msgdata[msgdataindex];
389 // receive a shared memory response msg
391 // if is currently doing gc, dump this msg
392 if(!gc_status_info.gcprocessing) {
396 bamboo_smem_zero_top = NULL;
398 bamboo_smem_size = 0;
399 bamboo_cur_msp = NULL;
402 bamboo_smem_size = numbytes;
403 bamboo_cur_msp = memptr;
405 bamboo_smem_size = numbytes;
406 bamboo_cur_msp =memptr;
416 void processmsg_gcinvoke_I() {
417 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE==STARTUPCORE);
418 if(!gc_status_info.gcprocessing && !gcflag) {
421 for(int i = 0; i < NUMCORESACTIVE; i++) {
422 // reuse the gcnumsendobjs & gcnumreceiveobjs
423 gcnumsendobjs[0][i] = 0;
424 gcnumreceiveobjs[0][i] = 0;
426 for(int i = 0; i < NUMCORES4GC; i++) {
427 if(i != STARTUPCORE) {
428 if(BAMBOO_CHECK_SEND_MODE()) {
429 cache_msg_1_I(i,GCSTARTPRE);
431 send_msg_1_I(i,GCSTARTPRE);
438 void processmsg_gcstartpre_I() {
439 // the first time to be informed to start gc
443 void processmsg_gcstartinit_I() {
444 gc_status_info.gcphase = INITPHASE;
447 void processmsg_gcstart_I() {
449 gc_status_info.gcphase = MARKPHASE;
452 void processmsg_gcstartcompact_I() {
453 gcblock2fill = msgdata[msgdataindex];
455 BAMBOO_ASSERT(!gc_status_info.gcbusystatus);
456 gc_status_info.gcphase = COMPACTPHASE;
459 void processmsg_gcstartupdate_I() {
460 gc_status_info.gcphase = UPDATEPHASE;
463 void processmsg_gcfinishpre_I() {
464 int data1 = msgdata[msgdataindex];
466 int data2 = msgdata[msgdataindex];
468 int data3 = msgdata[msgdataindex];
470 // received a init phase finish msg
471 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
473 // All cores should do init GC
475 gccorestatus[data1] = 0;
476 gcnumsendobjs[0][data1] = data2;
477 gcnumreceiveobjs[0][data1] = data3;
480 void processmsg_gcfinishinit_I() {
481 int data1 = msgdata[msgdataindex];
483 // received a init phase finish msg
484 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
486 // All cores should do init GC
487 if(data1 < NUMCORESACTIVE) {
488 gccorestatus[data1] = 0;
492 void processmsg_reqblock_I() {
493 int cnum=msgdata[msgdataindex];
495 void * topptr= (void *)msgdata[msgdataindex];
497 if (topptr<=update_origblockptr) {
499 if(BAMBOO_CHECK_SEND_MODE()) {
500 cache_msg_1_I(cnum,GCGRANTBLOCK);
502 send_msg_1_I(cnum,GCGRANTBLOCK);
506 origblockarray[cnum]=topptr;
511 void processmsg_grantblock_I() {
516 void processmsg_gcfinishmark_I() {
517 int cnum = msgdata[msgdataindex];
519 int nsend = msgdata[msgdataindex];
521 int nrecv = msgdata[msgdataindex];
523 // received a mark phase finish msg
524 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
525 BAMBOO_ASSERT(gc_status_info.gcphase == MARKPHASE);
527 // all cores should do mark
528 if(cnum < NUMCORESACTIVE) {
529 gccorestatus[cnum] = 0;
533 entry_index = (gcnumsrobjs_index == 0) ? 1 : 0;
536 entry_index = gcnumsrobjs_index;
538 gcnumsendobjs[entry_index][cnum] = nsend;
539 gcnumreceiveobjs[entry_index][cnum] = nrecv;
543 void processmsg_returnmem_I() {
544 unsigned int cnum = msgdata[msgdataindex];
546 void * heaptop = (void *) msgdata[msgdataindex];
549 handleReturnMem_I(cnum, heaptop);
552 void * handlegcfinishcompact_I(int cnum, unsigned int bytesneeded, unsigned int maxbytesneeded) {
553 if(bytesneeded > 0) {
555 return gcfindSpareMem_I(bytesneeded, maxbytesneeded, cnum);
557 //done with compacting
558 gccorestatus[cnum] = 0;
563 void processmsg_gcfinishcompact_I() {
564 int cnum = msgdata[msgdataindex];
566 unsigned int bytesneeded = msgdata[msgdataindex];
568 unsigned int maxbytesneeded = msgdata[msgdataindex];
571 void * startaddr=handlegcfinishcompact_I(cnum, bytesneeded, maxbytesneeded);
573 if(BAMBOO_CHECK_SEND_MODE()) {
574 cache_msg_2_I(cnum,GCMOVESTART,(unsigned INTPTR)startaddr);
576 send_msg_2_I(cnum,GCMOVESTART,(unsigned INTPTR)startaddr);
581 void processmsg_gcfinishupdate_I() {
582 int data1 = msgdata[msgdataindex];
584 // received a update phase finish msg
585 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
587 // all cores should do update
588 if(data1 < NUMCORESACTIVE) {
589 gccorestatus[data1] = 0;
593 void processmsg_gcfinish_I() {
594 // received a GC finish msg
595 gc_status_info.gcphase = FINISHPHASE;
596 gc_status_info.gcprocessing = false;
599 void processmsg_gcmarkconfirm_I() {
600 BAMBOO_ASSERT(((BAMBOO_NUM_OF_CORE!=STARTUPCORE)&&(BAMBOO_NUM_OF_CORE<=NUMCORESACTIVE-1)));
601 // send response msg, cahce the msg first
602 if(BAMBOO_CHECK_SEND_MODE()) {
603 cache_msg_5_I(STARTUPCORE,GCMARKREPORT,BAMBOO_NUM_OF_CORE,gc_status_info.gcbusystatus,gcself_numsendobjs,gcself_numreceiveobjs);
605 send_msg_5_I(STARTUPCORE,GCMARKREPORT,BAMBOO_NUM_OF_CORE,gc_status_info.gcbusystatus,gcself_numsendobjs,gcself_numreceiveobjs);
609 void processmsg_gcmarkreport_I() {
610 int data1 = msgdata[msgdataindex];
612 int data2 = msgdata[msgdataindex];
614 int data3 = msgdata[msgdataindex];
616 int data4 = msgdata[msgdataindex];
618 // received a marked phase finish confirm response msg
619 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
621 BAMBOO_ASSERT(waitconfirm);
625 entry_index = (gcnumsrobjs_index == 0) ? 1 : 0;
626 gccorestatus[data1] = data2;
627 gcnumsendobjs[entry_index][data1] = data3;
628 gcnumreceiveobjs[entry_index][data1] = data4;
632 void processmsg_gcmarkedobj_I() {
633 void * objptr = (void *) msgdata[msgdataindex];
636 // received a markedObj msg
637 if(!checkMark(objptr)) {
638 // this is the first time that this object is discovered,
639 // set the flag as DISCOVERED
642 gc_enqueue_I(objptr);
644 gcself_numreceiveobjs++;
645 gc_status_info.gcbusystatus = true;
648 void processmsg_gcmovestart_I() {
650 gcmovestartaddr = msgdata[msgdataindex];
654 void processmsg_gclobjinfo_I(unsigned int msglength) {
656 int cnum = msgdata[msgdataindex];
658 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORES4GC - 1);
660 // store the mark result info
661 gcloads[cnum] = msgdata[msgdataindex];
664 // large obj info here
665 for(int k = 3; k < msglength; k+=2) {
666 void * lobj = (void *) msgdata[msgdataindex];
668 int length = msgdata[msgdataindex];
670 gc_lobjenqueue_I(lobj, length, cnum);
675 void processmsg_gcprofiles_I() {
676 int data1 = msgdata[msgdataindex];
678 int data2 = msgdata[msgdataindex];
680 int data3 = msgdata[msgdataindex];
683 if(gc_profile_flag) {
686 gc_num_liveobj += data2;
687 gc_num_forwardobj += data3;
695 #ifdef GC_CACHE_ADAPT
696 void processmsg_gcstartcachepolicy_I() {
697 gc_status_info.gcphase = CACHEPOLICYPHASE;
700 void processmsg_gcfinishcachepolicy_I() {
701 int data1 = msgdata[msgdataindex];
703 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
705 // all cores should do update
706 if(data1 < NUMCORESACTIVE) {
707 gccorestatus[data1] = 0;
711 void processmsg_gcstartpref_I() {
712 gc_status_info.gcphase = PREFINISHPHASE;
715 void processmsg_gcfinishpref_I() {
716 int data1 = msgdata[msgdataindex];
718 // received a update phase finish msg
719 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
721 // all cores should do update
722 if(data1 < NUMCORESACTIVE) {
723 gccorestatus[data1] = 0;
726 #endif // GC_CACHE_ADAPT
727 #endif // #ifdef MULTICORE_GC
729 void processmsg_req_notify_start() {
731 if(BAMBOO_CHECK_SEND_MODE()) {
732 cache_msg_1_I(STARTUPCORE,NOTIFYSTART);
734 send_msg_1_I(STARTUPCORE,NOTIFYSTART);
738 void processmsg_notify_start() {
742 // receive object transferred from other cores
743 // or the terminate message from other cores
744 // Should be invoked in critical sections!!
745 // NOTICE: following format is for threadsimulate version only
746 // RAW version please see previous description
747 // format: type + object
748 // type: -1--stall msg
750 // return value: 0--received an object
751 // 1--received nothing
752 // 2--received a Stall Msg
753 // 3--received a lock Msg
754 // RAW version: -1 -- received nothing
755 // otherwise -- received msg type
756 int receiveObject_I() {
757 PROFILE_INTERRUPT_START();
759 // get the incoming msgs
761 if((msgdataindex == msgdatalast) && (!msgdatafull)) {
764 if(BAMBOO_CHECK_SEND_MODE()) {
765 // during send, don't process the msg now
769 // processing received msgs
771 MSG_REMAINSIZE_I(size);
774 // have new coming msg
775 if((BAMBOO_MSG_AVAIL() != 0) && !msgdatafull) {
782 //we only ever read the first word
783 unsigned int realtype = msgdata[msgdataindex];
784 unsigned int msglength = checkMsgLength_I(realtype);
786 #if (defined(TASK)||defined(MULTICORE_GC))
787 unsigned int type = realtype & 0xff;
789 unsigned int type = realtype;
792 if(msglength <= size) {
793 // have some whole msg
798 case REQNOTIFYSTART: {
799 processmsg_req_notify_start();
804 processmsg_notify_start();
810 // receive a object transfer msg
811 processmsg_transobj_I(msglength);
816 // receive a stall msg
817 processmsg_transtall_I();
822 // GC version have no lock msgs
825 // receive lock request msg, handle it right now
826 processmsg_lockrequest_I();
830 // receive lock grount msg
831 processmsg_lockgrount_I();
835 // receive lock deny msg
836 processmsg_lockdeny_I();
840 processmsg_lockrelease_I();
846 case PROFILEOUTPUT: {
847 // receive an output profile data request msg
848 processmsg_profileoutput_I();
851 case PROFILEFINISH: {
852 // receive a profile output finish msg
853 processmsg_profilefinish_I();
858 // GC version has no lock msgs
861 // receive a redirect lock request msg, handle it right now
862 processmsg_redirectlock_I();
866 case REDIRECTGROUNT: {
867 // receive a lock grant msg with redirect info
868 processmsg_redirectgrount_I();
873 // receive a lock deny msg with redirect info
874 processmsg_redirectdeny_I();
878 case REDIRECTRELEASE: {
879 // receive a lock release msg with redirect info
880 processmsg_redirectrelease_I();
882 } // case REDIRECTRELEASE
886 case STATUSCONFIRM: {
887 // receive a status confirm info
888 processmsg_statusconfirm_I();
893 processmsg_statusreport_I();
898 // receive a terminate msg
899 processmsg_terminate_I();
904 processmsg_memrequest_I();
909 processmsg_memresponse_I();
916 processmsg_gcinvoke_I();
921 processmsg_gcstartpre_I();
926 processmsg_gcstartinit_I();
931 // receive a start GC msg
932 processmsg_gcstart_I();
936 case GCSTARTCOMPACT: {
937 // a compact phase start msg
938 processmsg_gcstartcompact_I();
942 case GCSTARTUPDATE: {
943 // received a update phase start msg
944 processmsg_gcstartupdate_I();
949 processmsg_gcfinishpre_I();
954 processmsg_gcfinishinit_I();
959 processmsg_gcfinishmark_I();
964 processmsg_returnmem_I();
968 case GCFINISHCOMPACT: {
969 // received a compact phase finish msg
970 processmsg_gcfinishcompact_I();
974 case GCFINISHUPDATE: {
975 processmsg_gcfinishupdate_I();
980 processmsg_gcfinish_I();
984 case GCMARKCONFIRM: {
985 // received a marked phase finish confirm request msg
986 // all cores should do mark
987 processmsg_gcmarkconfirm_I();
992 processmsg_gcmarkreport_I();
997 processmsg_gcmarkedobj_I();
1002 // received a start moving objs msg
1003 processmsg_gcmovestart_I();
1007 case GCLOBJREQUEST: {
1008 // received a large objs info request msg
1009 transferMarkResults_I();
1014 processmsg_reqblock_I();
1018 case GCGRANTBLOCK: {
1019 processmsg_grantblock_I();
1024 // received a large objs info response msg
1025 processmsg_gclobjinfo_I(msglength);
1031 // received a gcprofiles msg
1032 processmsg_gcprofiles_I();
1035 #endif // GC_PROFILE
1037 #ifdef GC_CACHE_ADAPT
1038 case GCSTARTCACHEPOLICY: {
1039 // received a gcstartcachepolicy msg
1040 processmsg_gcstartcachepolicy_I();
1044 case GCFINISHCACHEPOLICY: {
1045 // received a gcfinishcachepolicy msg
1046 processmsg_gcfinishcachepolicy_I();
1051 // received a gcstartpref msg
1052 processmsg_gcstartpref_I();
1056 case GCFINISHPREF: {
1057 // received a gcfinishpref msg
1058 processmsg_gcfinishpref_I();
1068 if((msgdataindex != msgdatalast) || (msgdatafull)) {
1069 // still have available msg
1073 // have new coming msg
1074 if(BAMBOO_MSG_AVAIL() != 0) {
1078 PROFILE_INTERRUPT_END();