2 #include "multicoremsg.h"
4 #include "multicoreruntime.h"
5 #include "multicoregarbage.h"
6 #include "multicoretaskprofile.h"
7 #include "runtime_arch.h"
13 #include "bme_perf_counter.h"
16 int msgsizearray[] = {
20 -1, //TRANSOBJ, // 0xD1
21 4, //TRANSTALL, // 0xD2
22 5, //LOCKREQUEST, // 0xD3
23 4, //LOCKGROUNT, // 0xD4
24 4, //LOCKDENY, // 0xD5
25 4, //LOCKRELEASE, // 0xD6
26 2, //PROFILEOUTPUT, // 0xD7
27 1, //PROFILEFINISH, // 0xD8
28 6, //REDIRECTLOCK, // 0xD9
29 4, //REDIRECTGROUNT, // 0xDa
30 4, //REDIRECTDENY, // 0xDb
31 4, //REDIRECTRELEASE, // 0xDc
32 1, //STATUSCONFIRM, // 0xDd
33 5, //STATUSREPORT, // 0xDe
34 1, //TERMINATE, // 0xDf
35 3, //MEMREQUEST, // 0xE0
36 3, //MEMRESPONSE, // 0xE1
41 #if defined(MULTICORE_GC)||defined(PMC_GC)
43 1, //GCSTARTPRE, // 0xE2
46 1, //GCSTARTINIT, // 0xE3
48 2, //GCSTARTCOMPACT, // 0xE5
49 1, //GCSTARTUPDATE, // 0xE6
50 4, //GCFINISHPRE, // 0xE7
51 2, //GCFINISHINIT, // 0xE8
52 4, //GCFINISHMARK, // 0xE9
53 4, //GCFINISHCOMPACT, // 0xEa
55 2, //GCFINISHUPDATE, // 0xEb
56 1, //GCFINISH, // 0xEc
57 1, //GCMARKCONFIRM, // 0xEd
58 5, //GCMARKREPORT, // 0xEe
59 2, //GCMARKEDOBJ, // 0xEf
60 2, //GCMOVESTART, // 0xF0
61 1, //GCLOBJREQUEST, // 0xF1
64 -1, //GCLOBJINFO, // 0xF2
66 3, //GCPROFILES, // 0xF3
69 1, //GCSTARTCACHEPOLICY // 0xF4
70 2, //GCFINISHCACHEPOLICY // 0xF5
71 1, //GCSTARTPREF, // 0xF6
72 2, //GCFINISHPREF, // 0xF7
73 #endif // GC_CACHE_ADAPT
74 #endif // MULTICORE_GC
78 unsigned int checkMsgLength_I(unsigned int realtype) {
79 #if (defined(TASK)||defined(MULTICORE_GC))
80 unsigned int type = realtype & 0xff;
82 unsigned int type = realtype;
84 BAMBOO_ASSERT(type<=MSGEND);
86 #if defined(MULTICORE_GC)
87 if(type==TRANSOBJ||type==GCLOBJINFO) {
91 #elif defined(MULTICORE_GC)
92 if (type==GCLOBJINFO) {
94 #if (defined(TASK)||defined(MULTICORE_GC))
98 return msgsizearray[type];
102 void processmsg_transobj_I(int msglength) {
103 struct transObjInfo * transObj=RUNMALLOC_I(sizeof(struct transObjInfo));
104 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
106 // store the object and its corresponding queue info, enqueue it later
107 transObj->objptr = (void *)msgdata[msgdataindex];
109 transObj->length = (msglength - 2) / 2;
110 transObj->queues = RUNMALLOC_I(sizeof(int)*(msglength - 3));
111 for(int k = 0; k < transObj->length; k++) {
112 transObj->queues[2*k] = msgdata[msgdataindex];
114 transObj->queues[2*k+1] = msgdata[msgdataindex];
117 // check if there is an existing duplicate item
118 struct QueueItem * prev = NULL;
119 for(struct QueueItem * qitem = getHead(&objqueue);qitem != NULL;qitem=(prev==NULL)?getHead(&objqueue):getNextQueueItem(prev)) {
120 struct transObjInfo * tmpinfo = (struct transObjInfo *)(qitem->objectptr);
121 if(tmpinfo->objptr == transObj->objptr) {
122 // the same object, remove outdate one
123 RUNFREE_I(tmpinfo->queues);
125 removeItem(&objqueue, qitem);
131 addNewItem_I(&objqueue, (void *)transObj);
133 self_numreceiveobjs++;
135 if(gc_status_info.gcprocessing) {
136 if(STARTUPCORE == BAMBOO_NUM_OF_CORE) {
137 // set the gcprecheck to enable checking again
140 // send a update pregc information msg to the master core
141 if(BAMBOO_CHECK_SEND_MODE()) {
142 cache_msg_4_I(STARTUPCORE,GCFINISHPRE,BAMBOO_NUM_OF_CORE,self_numsendobjs,self_numreceiveobjs);
144 send_msg_4_I(STARTUPCORE,GCFINISHPRE,BAMBOO_NUM_OF_CORE,self_numsendobjs, self_numreceiveobjs);
152 void processmsg_transtall_I() {
153 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
155 int num_core = msgdata[msgdataindex];
157 int data2 = msgdata[msgdataindex];
159 int data3 = msgdata[msgdataindex];
161 if(num_core < NUMCORESACTIVE) {
162 corestatus[num_core] = 0;
163 numsendobjs[num_core] = data2;
164 numreceiveobjs[num_core] = data3;
168 #if !defined(MULTICORE_GC)&&!defined(PMC_GC)
169 void processmsg_lockrequest_I() {
170 // check to see if there is a lock exist for the required obj
171 // msgdata[1] -> lock type
172 int locktype = msgdata[msgdataindex];
174 int data2 = msgdata[msgdataindex]; // obj pointer
176 int data3 = msgdata[msgdataindex]; // lock
178 int data4 = msgdata[msgdataindex]; // request core
180 // -1: redirected, 0: approved, 1: denied
181 int deny=processlockrequest(locktype, data3, data2, data4, data4, true);
184 // for 32 bit machine, the size is always 4 words, cache the msg first
185 int tmp = deny==1 ? LOCKDENY : LOCKGROUNT;
186 if(BAMBOO_CHECK_SEND_MODE()) {
187 cache_msg_4_I(data4,tmp,locktype,data2,data3);
189 send_msg_4_I(data4,tmp,locktype,data2,data3);
194 void processmsg_lockgrount_I() {
196 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
197 int data2 = msgdata[msgdataindex];
199 int data3 = msgdata[msgdataindex];
201 BAMBOO_ASSERT((lockobj == data2) && (lock2require == data3));
209 void processmsg_lockdeny_I() {
211 int data2 = msgdata[msgdataindex];
213 int data3 = msgdata[msgdataindex];
215 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
216 BAMBOO_ASSERT((lockobj == data2) && (lock2require == data3));
224 void processmsg_lockrelease_I() {
225 int data1 = msgdata[msgdataindex];
227 int data2 = msgdata[msgdataindex];
229 int data3 = msgdata[msgdataindex];
231 // receive lock release msg
232 processlockrelease(data1, data2, 0, false);
235 void processmsg_redirectlock_I() {
236 // check to see if there is a lock exist for the required obj
237 int data1 = msgdata[msgdataindex];
238 MSG_INDEXINC_I(); // lock type
239 int data2 = msgdata[msgdataindex];
240 MSG_INDEXINC_I(); // obj pointer
241 int data3 = msgdata[msgdataindex];
242 MSG_INDEXINC_I(); // redirect lock
243 int data4 = msgdata[msgdataindex];
244 MSG_INDEXINC_I(); // root request core
245 int data5 = msgdata[msgdataindex];
246 MSG_INDEXINC_I(); // request core
247 int deny = processlockrequest_I(data1, data3, data2, data5, data4, true);
250 // for 32 bit machine, the size is always 4 words, cache the msg first
251 if(BAMBOO_CHECK_SEND_MODE()) {
252 cache_msg_4_I(data4,deny==1?REDIRECTDENY:REDIRECTGROUNT,data1,data2,data3);
254 send_msg_4_I(data4,deny==1?REDIRECTDENY:REDIRECTGROUNT,data1,data2,data3);
259 void processmsg_redirectgrount_I() {
261 int data2 = msgdata[msgdataindex];
263 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
264 BAMBOO_ASSERT(lockobj == data2, 0xe207);
265 int data3 = msgdata[msgdataindex];
269 RuntimeHashadd_I(objRedirectLockTbl, lockobj, data3);
275 void processmsg_redirectdeny_I() {
277 int data2 = msgdata[msgdataindex];
279 int data3 = msgdata[msgdataindex];
281 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
282 BAMBOO_ASSERT(lockobj == data2);
290 void processmsg_redirectrelease_I() {
291 int data1 = msgdata[msgdataindex];
293 int data2 = msgdata[msgdataindex];
295 int data3 = msgdata[msgdataindex];
297 processlockrelease_I(data1, data2, data3, true);
299 #endif // #ifndef MULTICORE_GC
302 void processmsg_profileoutput_I() {
303 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE != STARTUPCORE);
305 totalexetime = msgdata[msgdataindex];
307 #if !defined(RT_TEST)
310 // cache the msg first
311 if(BAMBOO_CHECK_SEND_MODE()) {
312 cache_msg_1_I(STARTUPCORE,PROFILEFINISH);
314 send_msg_1_I(STARTUPCORE,PROFILEFINISH);
318 void processmsg_profilefinish_I() {
319 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
324 void processmsg_statusconfirm_I() {
325 BAMBOO_ASSERT(((BAMBOO_NUM_OF_CORE != STARTUPCORE) && (BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1)));
327 // cache the msg first
328 if(BAMBOO_CHECK_SEND_MODE()) {
329 cache_msg_5_I(STARTUPCORE,STATUSREPORT,busystatus?1:0,BAMBOO_NUM_OF_CORE,self_numsendobjs,self_numreceiveobjs);
331 send_msg_5_I(STARTUPCORE,STATUSREPORT,busystatus?1:0,BAMBOO_NUM_OF_CORE,self_numsendobjs,self_numreceiveobjs);
335 void processmsg_statusreport_I() {
336 int data1 = msgdata[msgdataindex];
338 int data2 = msgdata[msgdataindex];
340 int data3 = msgdata[msgdataindex];
342 int data4 = msgdata[msgdataindex];
344 // receive a status confirm info
345 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
349 corestatus[data2] = data1;
350 numsendobjs[data2] = data3;
351 numreceiveobjs[data2] = data4;
354 void processmsg_terminate_I() {
356 #if defined(MULTICORE_GC)&&defined(GC_CACHE_ADAPT)&&defined(GC_CACHE_SAMPLING)&&(defined(GC_CACHE_ADAPT_POLICY4)||defined(GC_CACHE_ADAPT_POLICY3))
357 bamboo_mask_timer_intr(); // disable the TILE_TIMER interrupt
363 void processmsg_memrequest_I() {
364 int data1 = msgdata[msgdataindex];
366 int data2 = msgdata[msgdataindex];
368 // receive a shared memory request msg
369 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
371 if(!gc_status_info.gcprocessing || !gcflag) {
372 // either not doing GC or the master core has decided to stop GC but
373 // // still sending msgs to other cores to inform them to stop the GC
375 unsigned INTPTR allocsize = 0;
376 void * mem = smemalloc_I(data2, data1, &allocsize);
378 // send the start_va to request core, cache the msg first
379 if(BAMBOO_CHECK_SEND_MODE()) {
380 cache_msg_3_I(data2,MEMRESPONSE,(unsigned INTPTR) mem,allocsize);
382 send_msg_3_I(data2,MEMRESPONSE,(unsigned INTPTR) mem,allocsize);
384 } //else if mem == NULL, the gcflag of the startup core has been set
385 // and all the other cores have been informed to start gc
391 void processmsg_memresponse_I() {
392 void * memptr =(void *) msgdata[msgdataindex];
394 unsigned int numbytes = msgdata[msgdataindex];
396 // receive a shared memory response msg
398 // if is currently doing gc, dump this msg
399 if(!gc_status_info.gcprocessing) {
403 bamboo_smem_zero_top = NULL;
405 bamboo_smem_size = 0;
406 bamboo_cur_msp = NULL;
409 bamboo_smem_size = numbytes;
410 bamboo_cur_msp = memptr;
412 bamboo_smem_size = numbytes;
413 bamboo_cur_msp =memptr;
421 #endif //ifndef PMCGC
424 #if defined(MULTICORE_GC)||defined(PMC_GC)
425 void processmsg_gcinvoke_I() {
426 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE==STARTUPCORE);
428 if(!gc_status_info.gcprocessing && !gcflag) {
431 for(int i = 0; i < NUMCORESACTIVE; i++) {
432 // reuse the gcnumsendobjs & gcnumreceiveobjs
433 gcnumsendobjs[0][i] = 0;
434 gcnumreceiveobjs[0][i] = 0;
441 for(int i = 0; i < NUMCORES4GC; i++) {
442 if(i != STARTUPCORE) {
443 if(BAMBOO_CHECK_SEND_MODE()) {
444 cache_msg_1_I(i,GCSTARTPRE);
446 send_msg_1_I(i,GCSTARTPRE);
453 void processmsg_gcstartpre_I() {
454 // the first time to be informed to start gc
459 void processmsg_gcstartinit_I() {
460 gc_status_info.gcphase = INITPHASE;
463 void processmsg_gcstart_I() {
465 gc_status_info.gcphase = MARKPHASE;
468 void processmsg_gcstartcompact_I() {
469 gcblock2fill = msgdata[msgdataindex];
471 BAMBOO_ASSERT(!gc_status_info.gcbusystatus);
472 gc_status_info.gcphase = COMPACTPHASE;
475 void processmsg_gcstartupdate_I() {
476 gc_status_info.gcphase = UPDATEPHASE;
479 void processmsg_gcfinishpre_I() {
480 int data1 = msgdata[msgdataindex];
482 int data2 = msgdata[msgdataindex];
484 int data3 = msgdata[msgdataindex];
486 // received a init phase finish msg
487 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
489 // All cores should do init GC
491 gccorestatus[data1] = 0;
492 gcnumsendobjs[0][data1] = data2;
493 gcnumreceiveobjs[0][data1] = data3;
496 void processmsg_gcfinishinit_I() {
497 int data1 = msgdata[msgdataindex];
499 // received a init phase finish msg
500 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
502 // All cores should do init GC
503 if(data1 < NUMCORESACTIVE) {
504 gccorestatus[data1] = 0;
508 void processmsg_reqblock_I() {
509 int cnum=msgdata[msgdataindex];
511 void * topptr= (void *)msgdata[msgdataindex];
513 if (topptr<=update_origblockptr) {
515 if(BAMBOO_CHECK_SEND_MODE()) {
516 cache_msg_1_I(cnum,GCGRANTBLOCK);
518 send_msg_1_I(cnum,GCGRANTBLOCK);
522 origblockarray[cnum]=topptr;
527 void processmsg_grantblock_I() {
532 void processmsg_gcfinishmark_I() {
533 int cnum = msgdata[msgdataindex];
535 int nsend = msgdata[msgdataindex];
537 int nrecv = msgdata[msgdataindex];
539 // received a mark phase finish msg
540 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
541 BAMBOO_ASSERT(gc_status_info.gcphase == MARKPHASE);
543 // all cores should do mark
544 if(cnum < NUMCORESACTIVE) {
545 gccorestatus[cnum] = 0;
549 entry_index = (gcnumsrobjs_index == 0) ? 1 : 0;
552 entry_index = gcnumsrobjs_index;
554 gcnumsendobjs[entry_index][cnum] = nsend;
555 gcnumreceiveobjs[entry_index][cnum] = nrecv;
559 void processmsg_returnmem_I() {
560 unsigned int cnum = msgdata[msgdataindex];
562 void * heaptop = (void *) msgdata[msgdataindex];
565 handleReturnMem_I(cnum, heaptop);
568 void * handlegcfinishcompact_I(int cnum, unsigned int bytesneeded, unsigned int maxbytesneeded) {
569 if(bytesneeded > 0) {
571 return gcfindSpareMem_I(bytesneeded, maxbytesneeded, cnum);
573 //done with compacting
574 gccorestatus[cnum] = 0;
579 void processmsg_gcfinishcompact_I() {
580 int cnum = msgdata[msgdataindex];
582 unsigned int bytesneeded = msgdata[msgdataindex];
584 unsigned int maxbytesneeded = msgdata[msgdataindex];
587 void * startaddr=handlegcfinishcompact_I(cnum, bytesneeded, maxbytesneeded);
589 if(BAMBOO_CHECK_SEND_MODE()) {
590 cache_msg_2_I(cnum,GCMOVESTART,(unsigned INTPTR)startaddr);
592 send_msg_2_I(cnum,GCMOVESTART,(unsigned INTPTR)startaddr);
597 void processmsg_gcfinishupdate_I() {
598 int data1 = msgdata[msgdataindex];
600 // received a update phase finish msg
601 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
603 // all cores should do update
604 if(data1 < NUMCORESACTIVE) {
605 gccorestatus[data1] = 0;
609 void processmsg_gcfinish_I() {
610 // received a GC finish msg
611 gc_status_info.gcphase = FINISHPHASE;
612 gc_status_info.gcprocessing = false;
615 void processmsg_gcmarkconfirm_I() {
616 BAMBOO_ASSERT(((BAMBOO_NUM_OF_CORE!=STARTUPCORE)&&(BAMBOO_NUM_OF_CORE<=NUMCORESACTIVE-1)));
617 // send response msg, cahce the msg first
618 if(BAMBOO_CHECK_SEND_MODE()) {
619 cache_msg_5_I(STARTUPCORE,GCMARKREPORT,BAMBOO_NUM_OF_CORE,gc_status_info.gcbusystatus,gcself_numsendobjs,gcself_numreceiveobjs);
621 send_msg_5_I(STARTUPCORE,GCMARKREPORT,BAMBOO_NUM_OF_CORE,gc_status_info.gcbusystatus,gcself_numsendobjs,gcself_numreceiveobjs);
625 void processmsg_gcmarkreport_I() {
626 int data1 = msgdata[msgdataindex];
628 int data2 = msgdata[msgdataindex];
630 int data3 = msgdata[msgdataindex];
632 int data4 = msgdata[msgdataindex];
634 // received a marked phase finish confirm response msg
635 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
637 BAMBOO_ASSERT(waitconfirm);
641 entry_index = (gcnumsrobjs_index == 0) ? 1 : 0;
642 gccorestatus[data1] = data2;
643 gcnumsendobjs[entry_index][data1] = data3;
644 gcnumreceiveobjs[entry_index][data1] = data4;
648 void processmsg_gcmarkedobj_I() {
649 void * objptr = (void *) msgdata[msgdataindex];
652 // received a markedObj msg
653 if(!checkMark(objptr)) {
654 // this is the first time that this object is discovered,
655 // set the flag as DISCOVERED
658 gc_enqueue_I(objptr);
660 gcself_numreceiveobjs++;
661 gc_status_info.gcbusystatus = true;
664 void processmsg_gcmovestart_I() {
666 gcmovestartaddr = msgdata[msgdataindex];
670 void processmsg_gclobjinfo_I(unsigned int msglength) {
672 int cnum = msgdata[msgdataindex];
674 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORES4GC - 1);
676 // store the mark result info
677 gcloads[cnum] = msgdata[msgdataindex];
680 // large obj info here
681 for(int k = 3; k < msglength; k+=2) {
682 void * lobj = (void *) msgdata[msgdataindex];
684 int length = msgdata[msgdataindex];
686 gc_lobjenqueue_I(lobj, length, cnum);
691 void processmsg_gcprofiles_I() {
692 int data1 = msgdata[msgdataindex];
694 int data2 = msgdata[msgdataindex];
697 if(gc_profile_flag) {
699 gc_num_liveobj += data1;
700 gc_num_forwardobj += data2;
708 #ifdef GC_CACHE_ADAPT
709 void processmsg_gcstartcachepolicy_I() {
710 gc_status_info.gcphase = CACHEPOLICYPHASE;
713 void processmsg_gcfinishcachepolicy_I() {
714 int data1 = msgdata[msgdataindex];
716 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
718 // all cores should do update
719 if(data1 < NUMCORESACTIVE) {
720 gccorestatus[data1] = 0;
724 void processmsg_gcstartpref_I() {
725 gc_status_info.gcphase = PREFINISHPHASE;
728 void processmsg_gcfinishpref_I() {
729 int data1 = msgdata[msgdataindex];
731 // received a update phase finish msg
732 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
734 // all cores should do update
735 if(data1 < NUMCORESACTIVE) {
736 gccorestatus[data1] = 0;
739 #endif // GC_CACHE_ADAPT
740 #endif // #ifdef MULTICORE_GC
742 void processmsg_req_notify_start() {
744 if(BAMBOO_CHECK_SEND_MODE()) {
745 cache_msg_1_I(STARTUPCORE,NOTIFYSTART);
747 send_msg_1_I(STARTUPCORE,NOTIFYSTART);
751 void processmsg_notify_start() {
755 // receive object transferred from other cores
756 // or the terminate message from other cores
757 // Should be invoked in critical sections!!
758 // NOTICE: following format is for threadsimulate version only
759 // RAW version please see previous description
760 // format: type + object
761 // type: -1--stall msg
763 // return value: 0--received an object
764 // 1--received nothing
765 // 2--received a Stall Msg
766 // 3--received a lock Msg
767 // RAW version: -1 -- received nothing
768 // otherwise -- received msg type
769 int receiveObject_I() {
770 PROFILE_INTERRUPT_START();
772 // get the incoming msgs
774 if((msgdataindex == msgdatalast) && (!msgdatafull)) {
777 if(BAMBOO_CHECK_SEND_MODE()) {
778 BAMBOO_ASSERT((msgdataindex!=msgdatalast)||(!msgdatafull));
779 // during send, don't process the msg now
783 // processing received msgs
785 MSG_REMAINSIZE_I(size);
788 // have new coming msg
789 if((BAMBOO_MSG_AVAIL() != 0) && !msgdatafull) {
796 //we only ever read the first word
797 unsigned int realtype = msgdata[msgdataindex];
798 unsigned int msglength = checkMsgLength_I(realtype);
800 #if (defined(TASK)||defined(MULTICORE_GC))
801 unsigned int type = realtype & 0xff;
803 unsigned int type = realtype;
806 if(msglength <= size) {
807 // have some whole msg
812 case REQNOTIFYSTART: {
813 processmsg_req_notify_start();
818 processmsg_notify_start();
824 // receive a object transfer msg
825 processmsg_transobj_I(msglength);
830 // receive a stall msg
831 processmsg_transtall_I();
836 // GC version have no lock msgs
839 // receive lock request msg, handle it right now
840 processmsg_lockrequest_I();
844 // receive lock grount msg
845 processmsg_lockgrount_I();
849 // receive lock deny msg
850 processmsg_lockdeny_I();
854 processmsg_lockrelease_I();
860 case PROFILEOUTPUT: {
861 // receive an output profile data request msg
862 processmsg_profileoutput_I();
865 case PROFILEFINISH: {
866 // receive a profile output finish msg
867 processmsg_profilefinish_I();
872 // GC version has no lock msgs
875 // receive a redirect lock request msg, handle it right now
876 processmsg_redirectlock_I();
880 case REDIRECTGROUNT: {
881 // receive a lock grant msg with redirect info
882 processmsg_redirectgrount_I();
887 // receive a lock deny msg with redirect info
888 processmsg_redirectdeny_I();
892 case REDIRECTRELEASE: {
893 // receive a lock release msg with redirect info
894 processmsg_redirectrelease_I();
896 } // case REDIRECTRELEASE
900 case STATUSCONFIRM: {
901 // receive a status confirm info
902 processmsg_statusconfirm_I();
907 processmsg_statusreport_I();
912 // receive a terminate msg
913 processmsg_terminate_I();
918 processmsg_memrequest_I();
923 processmsg_memresponse_I();
930 if(BAMBOO_CHECK_SEND_MODE()) {
931 cache_msg_1_I(STARTUPCORE, MSGPERFRESPONSE);
933 send_msg_1_I(STARTUPCORE, MSGPERFRESPONSE);
937 case MSGPERFRESPONSE: {
942 #if defined(MULTICORE_GC)||defined(PMC_GC)
945 processmsg_gcinvoke_I();
950 processmsg_gcstartpre_I();
956 processmsg_gcstartinit_I();
961 // receive a start GC msg
962 processmsg_gcstart_I();
966 case GCSTARTCOMPACT: {
967 // a compact phase start msg
968 processmsg_gcstartcompact_I();
972 case GCSTARTUPDATE: {
973 // received a update phase start msg
974 processmsg_gcstartupdate_I();
979 processmsg_gcfinishpre_I();
984 processmsg_gcfinishinit_I();
989 processmsg_gcfinishmark_I();
994 processmsg_returnmem_I();
998 case GCFINISHCOMPACT: {
999 // received a compact phase finish msg
1000 processmsg_gcfinishcompact_I();
1004 case GCFINISHUPDATE: {
1005 processmsg_gcfinishupdate_I();
1010 processmsg_gcfinish_I();
1014 case GCMARKCONFIRM: {
1015 // received a marked phase finish confirm request msg
1016 // all cores should do mark
1017 processmsg_gcmarkconfirm_I();
1021 case GCMARKREPORT: {
1022 processmsg_gcmarkreport_I();
1027 processmsg_gcmarkedobj_I();
1032 // received a start moving objs msg
1033 processmsg_gcmovestart_I();
1037 case GCLOBJREQUEST: {
1038 // received a large objs info request msg
1039 transferMarkResults_I();
1044 processmsg_reqblock_I();
1048 case GCGRANTBLOCK: {
1049 processmsg_grantblock_I();
1054 // received a large objs info response msg
1055 processmsg_gclobjinfo_I(msglength);
1061 // received a gcprofiles msg
1062 processmsg_gcprofiles_I();
1065 #endif // GC_PROFILE
1067 #ifdef GC_CACHE_ADAPT
1068 case GCSTARTCACHEPOLICY: {
1069 // received a gcstartcachepolicy msg
1070 processmsg_gcstartcachepolicy_I();
1074 case GCFINISHCACHEPOLICY: {
1075 // received a gcfinishcachepolicy msg
1076 processmsg_gcfinishcachepolicy_I();
1081 // received a gcstartpref msg
1082 processmsg_gcstartpref_I();
1086 case GCFINISHPREF: {
1087 // received a gcfinishpref msg
1088 processmsg_gcfinishpref_I();
1098 if((msgdataindex != msgdatalast) || (msgdatafull)) {
1099 // still have available msg
1103 // have new coming msg
1104 if(BAMBOO_MSG_AVAIL() != 0) {
1108 PROFILE_INTERRUPT_END();