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 4, //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() {
357 #ifdef GC_CACHE_ADAPT
358 bamboo_mask_timer_intr(); // disable the TILE_TIMER interrupt
365 void processmsg_memrequest_I() {
366 int data1 = msgdata[msgdataindex];
368 int data2 = msgdata[msgdataindex];
370 // receive a shared memory request msg
371 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
373 if(!gc_status_info.gcprocessing || !gcflag) {
374 // either not doing GC or the master core has decided to stop GC but
375 // // still sending msgs to other cores to inform them to stop the GC
377 unsigned INTPTR allocsize = 0;
378 void * mem = smemalloc_I(data2, data1, &allocsize);
380 // send the start_va to request core, cache the msg first
381 if(BAMBOO_CHECK_SEND_MODE()) {
382 cache_msg_3_I(data2,MEMRESPONSE,(unsigned INTPTR) mem,allocsize);
384 send_msg_3_I(data2,MEMRESPONSE,(unsigned INTPTR) mem,allocsize);
386 } //else if mem == NULL, the gcflag of the startup core has been set
387 // and all the other cores have been informed to start gc
393 void processmsg_memresponse_I() {
394 void * memptr =(void *) msgdata[msgdataindex];
396 unsigned int numbytes = msgdata[msgdataindex];
398 // receive a shared memory response msg
400 // if is currently doing gc, dump this msg
401 if(!gc_status_info.gcprocessing) {
405 bamboo_smem_zero_top = NULL;
407 bamboo_smem_size = 0;
408 bamboo_cur_msp = NULL;
411 bamboo_smem_size = numbytes;
412 bamboo_cur_msp = memptr;
414 bamboo_smem_size = numbytes;
415 bamboo_cur_msp =memptr;
423 #endif //ifndef PMCGC
426 #if defined(MULTICORE_GC)||defined(PMC_GC)
427 void processmsg_gcinvoke_I() {
428 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE==STARTUPCORE);
430 if(!gc_status_info.gcprocessing && !gcflag) {
433 for(int i = 0; i < NUMCORESACTIVE; i++) {
434 // reuse the gcnumsendobjs & gcnumreceiveobjs
435 gcnumsendobjs[0][i] = 0;
436 gcnumreceiveobjs[0][i] = 0;
443 for(int i = 0; i < NUMCORES4GC; i++) {
444 if(i != STARTUPCORE) {
445 if(BAMBOO_CHECK_SEND_MODE()) {
446 cache_msg_1_I(i,GCSTARTPRE);
448 send_msg_1_I(i,GCSTARTPRE);
455 void processmsg_gcstartpre_I() {
456 // the first time to be informed to start gc
461 void processmsg_gcstartinit_I() {
462 gc_status_info.gcphase = INITPHASE;
465 void processmsg_gcstart_I() {
467 gc_status_info.gcphase = MARKPHASE;
470 void processmsg_gcstartcompact_I() {
471 gcblock2fill = msgdata[msgdataindex];
473 BAMBOO_ASSERT(!gc_status_info.gcbusystatus);
474 gc_status_info.gcphase = COMPACTPHASE;
477 void processmsg_gcstartupdate_I() {
478 gc_status_info.gcphase = UPDATEPHASE;
481 void processmsg_gcfinishpre_I() {
482 int data1 = msgdata[msgdataindex];
484 int data2 = msgdata[msgdataindex];
486 int data3 = msgdata[msgdataindex];
488 // received a init phase finish msg
489 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
491 // All cores should do init GC
493 gccorestatus[data1] = 0;
494 gcnumsendobjs[0][data1] = data2;
495 gcnumreceiveobjs[0][data1] = data3;
498 void processmsg_gcfinishinit_I() {
499 int data1 = msgdata[msgdataindex];
501 // received a init phase finish msg
502 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
504 // All cores should do init GC
505 if(data1 < NUMCORESACTIVE) {
506 gccorestatus[data1] = 0;
510 void processmsg_reqblock_I() {
511 int cnum=msgdata[msgdataindex];
513 void * topptr= (void *)msgdata[msgdataindex];
515 if (topptr<=update_origblockptr) {
517 if(BAMBOO_CHECK_SEND_MODE()) {
518 cache_msg_1_I(cnum,GCGRANTBLOCK);
520 send_msg_1_I(cnum,GCGRANTBLOCK);
524 origblockarray[cnum]=topptr;
529 void processmsg_grantblock_I() {
534 void processmsg_gcfinishmark_I() {
535 int cnum = msgdata[msgdataindex];
537 int nsend = msgdata[msgdataindex];
539 int nrecv = msgdata[msgdataindex];
541 // received a mark phase finish msg
542 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
543 BAMBOO_ASSERT(gc_status_info.gcphase == MARKPHASE);
545 // all cores should do mark
546 if(cnum < NUMCORESACTIVE) {
547 gccorestatus[cnum] = 0;
551 entry_index = (gcnumsrobjs_index == 0) ? 1 : 0;
554 entry_index = gcnumsrobjs_index;
556 gcnumsendobjs[entry_index][cnum] = nsend;
557 gcnumreceiveobjs[entry_index][cnum] = nrecv;
561 void processmsg_returnmem_I() {
562 unsigned int cnum = msgdata[msgdataindex];
564 void * heaptop = (void *) msgdata[msgdataindex];
567 handleReturnMem_I(cnum, heaptop);
570 void * handlegcfinishcompact_I(int cnum, unsigned int bytesneeded, unsigned int maxbytesneeded) {
571 if(bytesneeded > 0) {
573 return gcfindSpareMem_I(bytesneeded, maxbytesneeded, cnum);
575 //done with compacting
576 gccorestatus[cnum] = 0;
581 void processmsg_gcfinishcompact_I() {
582 int cnum = msgdata[msgdataindex];
584 unsigned int bytesneeded = msgdata[msgdataindex];
586 unsigned int maxbytesneeded = msgdata[msgdataindex];
589 void * startaddr=handlegcfinishcompact_I(cnum, bytesneeded, maxbytesneeded);
591 if(BAMBOO_CHECK_SEND_MODE()) {
592 cache_msg_2_I(cnum,GCMOVESTART,(unsigned INTPTR)startaddr);
594 send_msg_2_I(cnum,GCMOVESTART,(unsigned INTPTR)startaddr);
599 void processmsg_gcfinishupdate_I() {
600 int data1 = msgdata[msgdataindex];
602 // received a update phase finish msg
603 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
605 // all cores should do update
606 if(data1 < NUMCORESACTIVE) {
607 gccorestatus[data1] = 0;
611 void processmsg_gcfinish_I() {
612 // received a GC finish msg
613 gc_status_info.gcphase = FINISHPHASE;
614 gc_status_info.gcprocessing = false;
617 void processmsg_gcmarkconfirm_I() {
618 BAMBOO_ASSERT(((BAMBOO_NUM_OF_CORE!=STARTUPCORE)&&(BAMBOO_NUM_OF_CORE<=NUMCORESACTIVE-1)));
619 // send response msg, cahce the msg first
620 if(BAMBOO_CHECK_SEND_MODE()) {
621 cache_msg_5_I(STARTUPCORE,GCMARKREPORT,BAMBOO_NUM_OF_CORE,gc_status_info.gcbusystatus,gcself_numsendobjs,gcself_numreceiveobjs);
623 send_msg_5_I(STARTUPCORE,GCMARKREPORT,BAMBOO_NUM_OF_CORE,gc_status_info.gcbusystatus,gcself_numsendobjs,gcself_numreceiveobjs);
627 void processmsg_gcmarkreport_I() {
628 int data1 = msgdata[msgdataindex];
630 int data2 = msgdata[msgdataindex];
632 int data3 = msgdata[msgdataindex];
634 int data4 = msgdata[msgdataindex];
636 // received a marked phase finish confirm response msg
637 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
639 BAMBOO_ASSERT(waitconfirm);
643 entry_index = (gcnumsrobjs_index == 0) ? 1 : 0;
644 gccorestatus[data1] = data2;
645 gcnumsendobjs[entry_index][data1] = data3;
646 gcnumreceiveobjs[entry_index][data1] = data4;
650 void processmsg_gcmarkedobj_I() {
651 void * objptr = (void *) msgdata[msgdataindex];
654 // received a markedObj msg
655 if(!checkMark(objptr)) {
656 // this is the first time that this object is discovered,
657 // set the flag as DISCOVERED
660 gc_enqueue_I(objptr);
662 gcself_numreceiveobjs++;
663 gc_status_info.gcbusystatus = true;
666 void processmsg_gcmovestart_I() {
668 gcmovestartaddr = msgdata[msgdataindex];
672 void processmsg_gclobjinfo_I(unsigned int msglength) {
674 int cnum = msgdata[msgdataindex];
676 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORES4GC - 1);
678 // store the mark result info
679 gcloads[cnum] = msgdata[msgdataindex];
682 // large obj info here
683 for(int k = 3; k < msglength; k+=2) {
684 void * lobj = (void *) msgdata[msgdataindex];
686 int length = msgdata[msgdataindex];
688 gc_lobjenqueue_I(lobj, length, cnum);
693 void processmsg_gcprofiles_I() {
694 int data1 = msgdata[msgdataindex];
696 int data2 = msgdata[msgdataindex];
698 int data3 = msgdata[msgdataindex];
701 if(gc_profile_flag) {
704 gc_num_liveobj += data2;
705 gc_num_forwardobj += data3;
713 #ifdef GC_CACHE_ADAPT
714 void processmsg_gcstartcachepolicy_I() {
715 gc_status_info.gcphase = CACHEPOLICYPHASE;
718 void processmsg_gcfinishcachepolicy_I() {
719 int data1 = msgdata[msgdataindex];
721 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
723 // all cores should do update
724 if(data1 < NUMCORESACTIVE) {
725 gccorestatus[data1] = 0;
729 void processmsg_gcstartpref_I() {
730 gc_status_info.gcphase = PREFINISHPHASE;
733 void processmsg_gcfinishpref_I() {
734 int data1 = msgdata[msgdataindex];
736 // received a update phase finish msg
737 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
739 // all cores should do update
740 if(data1 < NUMCORESACTIVE) {
741 gccorestatus[data1] = 0;
744 #endif // GC_CACHE_ADAPT
745 #endif // #ifdef MULTICORE_GC
747 void processmsg_req_notify_start() {
749 if(BAMBOO_CHECK_SEND_MODE()) {
750 cache_msg_1_I(STARTUPCORE,NOTIFYSTART);
752 send_msg_1_I(STARTUPCORE,NOTIFYSTART);
756 void processmsg_notify_start() {
760 // receive object transferred from other cores
761 // or the terminate message from other cores
762 // Should be invoked in critical sections!!
763 // NOTICE: following format is for threadsimulate version only
764 // RAW version please see previous description
765 // format: type + object
766 // type: -1--stall msg
768 // return value: 0--received an object
769 // 1--received nothing
770 // 2--received a Stall Msg
771 // 3--received a lock Msg
772 // RAW version: -1 -- received nothing
773 // otherwise -- received msg type
774 int receiveObject_I() {
775 PROFILE_INTERRUPT_START();
777 // get the incoming msgs
779 if((msgdataindex == msgdatalast) && (!msgdatafull)) {
782 if(BAMBOO_CHECK_SEND_MODE()) {
783 // during send, don't process the msg now
787 // processing received msgs
789 MSG_REMAINSIZE_I(size);
792 // have new coming msg
793 if((BAMBOO_MSG_AVAIL() != 0) && !msgdatafull) {
800 //we only ever read the first word
801 unsigned int realtype = msgdata[msgdataindex];
802 unsigned int msglength = checkMsgLength_I(realtype);
804 #if (defined(TASK)||defined(MULTICORE_GC))
805 unsigned int type = realtype & 0xff;
807 unsigned int type = realtype;
810 if(msglength <= size) {
811 // have some whole msg
816 case REQNOTIFYSTART: {
817 processmsg_req_notify_start();
822 processmsg_notify_start();
828 // receive a object transfer msg
829 processmsg_transobj_I(msglength);
834 // receive a stall msg
835 processmsg_transtall_I();
840 // GC version have no lock msgs
843 // receive lock request msg, handle it right now
844 processmsg_lockrequest_I();
848 // receive lock grount msg
849 processmsg_lockgrount_I();
853 // receive lock deny msg
854 processmsg_lockdeny_I();
858 processmsg_lockrelease_I();
864 case PROFILEOUTPUT: {
865 // receive an output profile data request msg
866 processmsg_profileoutput_I();
869 case PROFILEFINISH: {
870 // receive a profile output finish msg
871 processmsg_profilefinish_I();
876 // GC version has no lock msgs
879 // receive a redirect lock request msg, handle it right now
880 processmsg_redirectlock_I();
884 case REDIRECTGROUNT: {
885 // receive a lock grant msg with redirect info
886 processmsg_redirectgrount_I();
891 // receive a lock deny msg with redirect info
892 processmsg_redirectdeny_I();
896 case REDIRECTRELEASE: {
897 // receive a lock release msg with redirect info
898 processmsg_redirectrelease_I();
900 } // case REDIRECTRELEASE
904 case STATUSCONFIRM: {
905 // receive a status confirm info
906 processmsg_statusconfirm_I();
911 processmsg_statusreport_I();
916 // receive a terminate msg
917 processmsg_terminate_I();
922 processmsg_memrequest_I();
927 processmsg_memresponse_I();
934 if(BAMBOO_CHECK_SEND_MODE()) {
935 cache_msg_1_I(STARTUPCORE, MSGPERFRESPONSE);
937 send_msg_1_I(STARTUPCORE, MSGPERFRESPONSE);
941 case MSGPERFRESPONSE: {
946 #if defined(MULTICORE_GC)||defined(PMC_GC)
949 processmsg_gcinvoke_I();
954 processmsg_gcstartpre_I();
960 processmsg_gcstartinit_I();
965 // receive a start GC msg
966 processmsg_gcstart_I();
970 case GCSTARTCOMPACT: {
971 // a compact phase start msg
972 processmsg_gcstartcompact_I();
976 case GCSTARTUPDATE: {
977 // received a update phase start msg
978 processmsg_gcstartupdate_I();
983 processmsg_gcfinishpre_I();
988 processmsg_gcfinishinit_I();
993 processmsg_gcfinishmark_I();
998 processmsg_returnmem_I();
1002 case GCFINISHCOMPACT: {
1003 // received a compact phase finish msg
1004 processmsg_gcfinishcompact_I();
1008 case GCFINISHUPDATE: {
1009 processmsg_gcfinishupdate_I();
1014 processmsg_gcfinish_I();
1018 case GCMARKCONFIRM: {
1019 // received a marked phase finish confirm request msg
1020 // all cores should do mark
1021 processmsg_gcmarkconfirm_I();
1025 case GCMARKREPORT: {
1026 processmsg_gcmarkreport_I();
1031 processmsg_gcmarkedobj_I();
1036 // received a start moving objs msg
1037 processmsg_gcmovestart_I();
1041 case GCLOBJREQUEST: {
1042 // received a large objs info request msg
1043 transferMarkResults_I();
1048 processmsg_reqblock_I();
1052 case GCGRANTBLOCK: {
1053 processmsg_grantblock_I();
1058 // received a large objs info response msg
1059 processmsg_gclobjinfo_I(msglength);
1065 // received a gcprofiles msg
1066 processmsg_gcprofiles_I();
1069 #endif // GC_PROFILE
1071 #ifdef GC_CACHE_ADAPT
1072 case GCSTARTCACHEPOLICY: {
1073 // received a gcstartcachepolicy msg
1074 processmsg_gcstartcachepolicy_I();
1078 case GCFINISHCACHEPOLICY: {
1079 // received a gcfinishcachepolicy msg
1080 processmsg_gcfinishcachepolicy_I();
1085 // received a gcstartpref msg
1086 processmsg_gcstartpref_I();
1090 case GCFINISHPREF: {
1091 // received a gcfinishpref msg
1092 processmsg_gcfinishpref_I();
1102 if((msgdataindex != msgdatalast) || (msgdatafull)) {
1103 // still have available msg
1107 // have new coming msg
1108 if(BAMBOO_MSG_AVAIL() != 0) {
1112 PROFILE_INTERRUPT_END();