2 #include "multicoremsg.h"
4 #include "multicoreruntime.h"
5 #include "multicoregarbage.h"
6 #include "multicoretaskprofile.h"
8 #include "runtime_arch.h"
11 int msgsizearray[] = {
15 -1, //TRANSOBJ, // 0xD1
16 4, //TRANSTALL, // 0xD2
17 5, //LOCKREQUEST, // 0xD3
18 4, //LOCKGROUNT, // 0xD4
19 4, //LOCKDENY, // 0xD5
20 4, //LOCKRELEASE, // 0xD6
21 2, //PROFILEOUTPUT, // 0xD7
22 1, //PROFILEFINISH, // 0xD8
23 6, //REDIRECTLOCK, // 0xD9
24 4, //REDIRECTGROUNT, // 0xDa
25 4, //REDIRECTDENY, // 0xDb
26 4, //REDIRECTRELEASE, // 0xDc
27 1, //STATUSCONFIRM, // 0xDd
28 5, //STATUSREPORT, // 0xDe
29 1, //TERMINATE, // 0xDf
30 3, //MEMREQUEST, // 0xE0
31 3, //MEMRESPONSE, // 0xE1
34 1, //GCSTARTPRE, // 0xE2
35 1, //GCSTARTINIT, // 0xE3
37 2, //GCSTARTCOMPACT, // 0xE5
38 1, //GCSTARTUPDATE, // 0xE6
39 4, //GCFINISHPRE, // 0xE7
40 2, //GCFINISHINIT, // 0xE8
41 4, //GCFINISHMARK, // 0xE9
42 4, //GCFINISHCOMPACT, // 0xEa
44 2, //GCFINISHUPDATE, // 0xEb
45 1, //GCFINISH, // 0xEc
46 1, //GCMARKCONFIRM, // 0xEd
47 5, //GCMARKREPORT, // 0xEe
48 2, //GCMARKEDOBJ, // 0xEf
49 2, //GCMOVESTART, // 0xF0
50 1, //GCLOBJREQUEST, // 0xF1
53 -1, //GCLOBJINFO, // 0xF2
55 4, //GCPROFILES, // 0xF3
58 1, //GCSTARTCACHEPOLICY // 0xF4
59 2, //GCFINISHCACHEPOLICY // 0xF5
60 1, //GCSTARTPREF, // 0xF6
61 2, //GCFINISHPREF, // 0xF7
62 #endif // GC_CACHE_ADAPT
63 #endif // MULTICORE_GC
67 INLINE unsigned int checkMsgLength_I(unsigned int realtype) {
68 #if (defined(TASK)||defined(MULTICORE_GC))
69 unsigned int type = realtype & 0xff;
71 unsigned int type = realtype;
73 BAMBOO_ASSERT(type<=MSGEND);
76 if(type==TRANSOBJ||type==GCLOBJINFO) {
81 if (type==GCLOBJINFO) {
83 #if (defined(TASK)||defined(MULTICORE_GC))
87 return msgsizearray[type];
91 void processmsg_transobj_I(int msglength) {
92 struct transObjInfo * transObj=RUNMALLOC_I(sizeof(struct transObjInfo));
93 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
95 // store the object and its corresponding queue info, enqueue it later
96 transObj->objptr = (void *)msgdata[msgdataindex];
98 transObj->length = (msglength - 2) / 2;
99 transObj->queues = RUNMALLOC_I(sizeof(int)*(msglength - 3));
100 for(int k = 0; k < transObj->length; k++) {
101 transObj->queues[2*k] = msgdata[msgdataindex];
103 transObj->queues[2*k+1] = msgdata[msgdataindex];
106 // check if there is an existing duplicate item
107 struct QueueItem * prev = NULL;
108 for(struct QueueItem * qitem = getHead(&objqueue);qitem != NULL;qitem=(prev==NULL)?getHead(&objqueue):getNextQueueItem(prev)) {
109 struct transObjInfo * tmpinfo = (struct transObjInfo *)(qitem->objectptr);
110 if(tmpinfo->objptr == transObj->objptr) {
111 // the same object, remove outdate one
112 RUNFREE_I(tmpinfo->queues);
114 removeItem(&objqueue, qitem);
120 addNewItem_I(&objqueue, (void *)transObj);
122 self_numreceiveobjs++;
124 if(gc_status_info.gcprocessing) {
125 if(STARTUPCORE == BAMBOO_NUM_OF_CORE) {
126 // set the gcprecheck to enable checking again
129 // send a update pregc information msg to the master core
130 if(BAMBOO_CHECK_SEND_MODE()) {
131 cache_msg_4_I(STARTUPCORE,GCFINISHPRE,BAMBOO_NUM_OF_CORE,self_numsendobjs,self_numreceiveobjs);
133 send_msg_4_I(STARTUPCORE,GCFINISHPRE,BAMBOO_NUM_OF_CORE,self_numsendobjs, self_numreceiveobjs);
141 void processmsg_transtall_I() {
142 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
144 int num_core = msgdata[msgdataindex];
146 int data2 = msgdata[msgdataindex];
148 int data3 = msgdata[msgdataindex];
150 if(num_core < NUMCORESACTIVE) {
151 corestatus[num_core] = 0;
152 numsendobjs[num_core] = data2;
153 numreceiveobjs[num_core] = data3;
158 void processmsg_lockrequest_I() {
159 // check to see if there is a lock exist for the required obj
160 // msgdata[1] -> lock type
161 int locktype = msgdata[msgdataindex];
163 int data2 = msgdata[msgdataindex]; // obj pointer
165 int data3 = msgdata[msgdataindex]; // lock
167 int data4 = msgdata[msgdataindex]; // request core
169 // -1: redirected, 0: approved, 1: denied
170 int deny=processlockrequest(locktype, data3, data2, data4, data4, true);
173 // for 32 bit machine, the size is always 4 words, cache the msg first
174 int tmp = deny==1 ? LOCKDENY : LOCKGROUNT;
175 if(BAMBOO_CHECK_SEND_MODE()) {
176 cache_msg_4_I(data4,tmp,locktype,data2,data3);
178 send_msg_4_I(data4,tmp,locktype,data2,data3);
183 void processmsg_lockgrount_I() {
185 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
186 int data2 = msgdata[msgdataindex];
188 int data3 = msgdata[msgdataindex];
190 BAMBOO_ASSERT((lockobj == data2) && (lock2require == data3));
198 void processmsg_lockdeny_I() {
200 int data2 = msgdata[msgdataindex];
202 int data3 = msgdata[msgdataindex];
204 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
205 BAMBOO_ASSERT((lockobj == data2) && (lock2require == data3));
213 void processmsg_lockrelease_I() {
214 int data1 = msgdata[msgdataindex];
216 int data2 = msgdata[msgdataindex];
218 int data3 = msgdata[msgdataindex];
220 // receive lock release msg
221 processlockrelease(data1, data2, 0, false);
224 void processmsg_redirectlock_I() {
225 // check to see if there is a lock exist for the required obj
226 int data1 = msgdata[msgdataindex];
227 MSG_INDEXINC_I(); // lock type
228 int data2 = msgdata[msgdataindex];
229 MSG_INDEXINC_I(); // obj pointer
230 int data3 = msgdata[msgdataindex];
231 MSG_INDEXINC_I(); // redirect lock
232 int data4 = msgdata[msgdataindex];
233 MSG_INDEXINC_I(); // root request core
234 int data5 = msgdata[msgdataindex];
235 MSG_INDEXINC_I(); // request core
236 int deny = processlockrequest_I(data1, data3, data2, data5, data4, true);
239 // for 32 bit machine, the size is always 4 words, cache the msg first
240 if(BAMBOO_CHECK_SEND_MODE()) {
241 cache_msg_4_I(data4,deny==1?REDIRECTDENY:REDIRECTGROUNT,data1,data2,data3);
243 send_msg_4_I(data4,deny==1?REDIRECTDENY:REDIRECTGROUNT,data1,data2,data3);
248 void processmsg_redirectgrount_I() {
250 int data2 = msgdata[msgdataindex];
252 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
253 BAMBOO_ASSERT(lockobj == data2, 0xe207);
254 int data3 = msgdata[msgdataindex];
258 RuntimeHashadd_I(objRedirectLockTbl, lockobj, data3);
264 void processmsg_redirectdeny_I() {
266 int data2 = msgdata[msgdataindex];
268 int data3 = msgdata[msgdataindex];
270 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1);
271 BAMBOO_ASSERT(lockobj == data2);
279 void processmsg_redirectrelease_I() {
280 int data1 = msgdata[msgdataindex];
282 int data2 = msgdata[msgdataindex];
284 int data3 = msgdata[msgdataindex];
286 processlockrelease_I(data1, data2, data3, true);
288 #endif // #ifndef MULTICORE_GC
291 void processmsg_profileoutput_I() {
292 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE != STARTUPCORE);
294 totalexetime = msgdata[msgdataindex];
300 // cache the msg first
301 if(BAMBOO_CHECK_SEND_MODE()) {
302 cache_msg_1_I(STARTUPCORE,PROFILEFINISH);
304 send_msg_1_I(STARTUPCORE,PROFILEFINISH);
308 void processmsg_profilefinish_I() {
309 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
314 void processmsg_statusconfirm_I() {
315 BAMBOO_ASSERT(((BAMBOO_NUM_OF_CORE != STARTUPCORE) && (BAMBOO_NUM_OF_CORE <= NUMCORESACTIVE - 1)));
317 // cache the msg first
318 if(BAMBOO_CHECK_SEND_MODE()) {
319 cache_msg_5_I(STARTUPCORE,STATUSREPORT,busystatus?1:0,BAMBOO_NUM_OF_CORE,self_numsendobjs,self_numreceiveobjs);
321 send_msg_5_I(STARTUPCORE,STATUSREPORT,busystatus?1:0,BAMBOO_NUM_OF_CORE,self_numsendobjs,self_numreceiveobjs);
325 void processmsg_statusreport_I() {
326 int data1 = msgdata[msgdataindex];
328 int data2 = msgdata[msgdataindex];
330 int data3 = msgdata[msgdataindex];
332 int data4 = msgdata[msgdataindex];
334 // receive a status confirm info
335 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
339 corestatus[data2] = data1;
340 numsendobjs[data2] = data3;
341 numreceiveobjs[data2] = data4;
344 void processmsg_terminate_I() {
347 #ifdef GC_CACHE_ADAPT
348 bamboo_mask_timer_intr(); // disable the TILE_TIMER interrupt
354 void processmsg_memrequest_I() {
355 int data1 = msgdata[msgdataindex];
357 int data2 = msgdata[msgdataindex];
359 // receive a shared memory request msg
360 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
362 if(!gc_status_info.gcprocessing || !gcflag) {
363 // either not doing GC or the master core has decided to stop GC but
364 // // still sending msgs to other cores to inform them to stop the GC
367 void * mem = smemalloc_I(data2, data1, &allocsize);
369 // send the start_va to request core, cache the msg first
370 if(BAMBOO_CHECK_SEND_MODE()) {
371 cache_msg_3_I(data2,MEMRESPONSE,mem,allocsize);
373 send_msg_3_I(data2,MEMRESPONSE,mem,allocsize);
375 } //else if mem == NULL, the gcflag of the startup core has been set
376 // and all the other cores have been informed to start gc
382 void processmsg_memresponse_I() {
383 void * memptr = msgdata[msgdataindex];
385 unsigned int numbytes = msgdata[msgdataindex];
387 // receive a shared memory response msg
389 // if is currently doing gc, dump this msg
390 if(!gc_status_info.gcprocessing) {
394 bamboo_smem_zero_top = NULL;
396 bamboo_smem_size = 0;
397 bamboo_cur_msp = NULL;
400 bamboo_smem_size = numbytes;
401 bamboo_cur_msp = memptr;
403 bamboo_smem_size = numbytes;
404 bamboo_cur_msp =memptr;
414 void processmsg_gcinvoke_I() {
415 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE==STARTUPCORE);
416 if(!gc_status_info.gcprocessing && !gcflag) {
419 for(int i = 0; i < NUMCORESACTIVE; i++) {
420 // reuse the gcnumsendobjs & gcnumreceiveobjs
421 gcnumsendobjs[0][i] = 0;
422 gcnumreceiveobjs[0][i] = 0;
424 for(int i = 0; i < NUMCORES4GC; i++) {
425 if(i != STARTUPCORE) {
426 if(BAMBOO_CHECK_SEND_MODE()) {
427 cache_msg_1_I(i,GCSTARTPRE);
429 send_msg_1_I(i,GCSTARTPRE);
436 void processmsg_gcstartpre_I() {
437 // the first time to be informed to start gc
441 void processmsg_gcstartinit_I() {
442 gc_status_info.gcphase = INITPHASE;
445 void processmsg_gcstart_I() {
447 gc_status_info.gcphase = MARKPHASE;
450 void processmsg_gcstartcompact_I() {
451 gcblock2fill = msgdata[msgdataindex];
453 BAMBOO_ASSERT(!gc_status_info.gcbusystatus);
454 gc_status_info.gcphase = COMPACTPHASE;
457 void processmsg_gcstartupdate_I() {
458 gc_status_info.gcphase = UPDATEPHASE;
461 void processmsg_gcfinishpre_I() {
462 int data1 = msgdata[msgdataindex];
464 int data2 = msgdata[msgdataindex];
466 int data3 = msgdata[msgdataindex];
468 // received a init phase finish msg
469 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
471 // All cores should do init GC
473 gccorestatus[data1] = 0;
474 gcnumsendobjs[0][data1] = data2;
475 gcnumreceiveobjs[0][data1] = data3;
478 void processmsg_gcfinishinit_I() {
479 int data1 = msgdata[msgdataindex];
481 // received a init phase finish msg
482 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
484 // All cores should do init GC
485 if(data1 < NUMCORESACTIVE) {
486 gccorestatus[data1] = 0;
490 void processmsg_reqblock_I() {
491 int cnum=msgdata[msgdataindex];
493 void * topptr=msgdata[msgdataindex];
495 if (topptr<=update_origblockptr) {
497 if(BAMBOO_CHECK_SEND_MODE()) {
498 cache_msg_1_I(cnum,GCGRANTBLOCK);
500 send_msg_1_I(cnum,GCGRANTBLOCK);
504 origblockarray[cnum]=topptr;
509 void processmsg_grantblock_I() {
514 void processmsg_gcfinishmark_I() {
515 int data1 = msgdata[msgdataindex];
517 int data2 = msgdata[msgdataindex];
519 int data3 = msgdata[msgdataindex];
521 // received a mark phase finish msg
522 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
523 BAMBOO_ASSERT(gc_status_info.gcphase = MARKPHASE);
525 // all cores should do mark
526 if(data1 < NUMCORESACTIVE) {
527 gccorestatus[data1] = 0;
531 entry_index = (gcnumsrobjs_index == 0) ? 1 : 0;
534 entry_index = gcnumsrobjs_index;
536 gcnumsendobjs[entry_index][data1] = data2;
537 gcnumreceiveobjs[entry_index][data1] = data3;
541 void processmsg_returnmem_I() {
542 unsigned int cnum = msgdata[msgdataindex];
544 void * heaptop = (void *) msgdata[msgdataindex];
547 handleReturnMem_I(cnum, heaptop);
550 void * handlegcfinishcompact_I(int cnum, unsigned int bytesneeded, unsigned int maxbytesneeded) {
551 if(bytesneeded > 0) {
553 return gcfindSpareMem_I(bytesneeded, maxbytesneeded, cnum);
555 //done with compacting
556 gccorestatus[cnum] = 0;
561 void processmsg_gcfinishcompact_I() {
562 int cnum = msgdata[msgdataindex];
564 unsigned int bytesneeded = msgdata[msgdataindex];
566 unsigned int maxbytesneeded = msgdata[msgdataindex];
569 void * startaddr=handlegcfinishcompact_I(cnum, bytesneeded, maxbytesneeded);
571 if(BAMBOO_CHECK_SEND_MODE()) {
572 cache_msg_2_I(cnum,GCMOVESTART,startaddr);
574 send_msg_2_I(cnum,GCMOVESTART,startaddr);
579 void processmsg_gcfinishupdate_I() {
580 int data1 = msgdata[msgdataindex];
582 // received a update phase finish msg
583 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
585 // all cores should do update
586 if(data1 < NUMCORESACTIVE) {
587 gccorestatus[data1] = 0;
591 void processmsg_gcfinish_I() {
592 // received a GC finish msg
593 gc_status_info.gcphase = FINISHPHASE;
594 gc_status_info.gcprocessing = false;
597 void processmsg_gcmarkconfirm_I() {
598 BAMBOO_ASSERT(((BAMBOO_NUM_OF_CORE!=STARTUPCORE)&&(BAMBOO_NUM_OF_CORE<=NUMCORESACTIVE-1)));
599 // send response msg, cahce the msg first
600 if(BAMBOO_CHECK_SEND_MODE()) {
601 cache_msg_5_I(STARTUPCORE,GCMARKREPORT,BAMBOO_NUM_OF_CORE,gc_status_info.gcbusystatus,gcself_numsendobjs,gcself_numreceiveobjs);
603 send_msg_5_I(STARTUPCORE,GCMARKREPORT,BAMBOO_NUM_OF_CORE,gc_status_info.gcbusystatus,gcself_numsendobjs,gcself_numreceiveobjs);
607 void processmsg_gcmarkreport_I() {
608 int data1 = msgdata[msgdataindex];
610 int data2 = msgdata[msgdataindex];
612 int data3 = msgdata[msgdataindex];
614 int data4 = msgdata[msgdataindex];
616 // received a marked phase finish confirm response msg
617 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
619 BAMBOO_ASSERT(waitconfirm);
623 entry_index = (gcnumsrobjs_index == 0) ? 1 : 0;
624 gccorestatus[data1] = data2;
625 gcnumsendobjs[entry_index][data1] = data3;
626 gcnumreceiveobjs[entry_index][data1] = data4;
630 void processmsg_gcmarkedobj_I() {
631 void * objptr = (void *) msgdata[msgdataindex];
634 // received a markedObj msg
635 if(!checkMark(objptr)) {
636 // this is the first time that this object is discovered,
637 // set the flag as DISCOVERED
640 gc_enqueue_I(objptr);
642 gcself_numreceiveobjs++;
643 gc_status_info.gcbusystatus = true;
646 void processmsg_gcmovestart_I() {
648 gcmovestartaddr = msgdata[msgdataindex];
652 void processmsg_gclobjinfo_I(unsigned int msglength) {
654 int cnum = msgdata[msgdataindex];
656 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE <= NUMCORES4GC - 1);
658 // store the mark result info
659 gcloads[cnum] = msgdata[msgdataindex];
662 // large obj info here
663 for(int k = 3; k < msglength; k+=2) {
664 int lobj = msgdata[msgdataindex];
666 int length = msgdata[msgdataindex];
668 gc_lobjenqueue_I(lobj, length, cnum);
673 void processmsg_gcprofiles_I() {
674 int data1 = msgdata[msgdataindex];
676 int data2 = msgdata[msgdataindex];
678 int data3 = msgdata[msgdataindex];
681 if(gc_profile_flag) {
684 gc_num_liveobj += data2;
685 gc_num_forwardobj += data3;
693 #ifdef GC_CACHE_ADAPT
694 void processmsg_gcstartcachepolicy_I() {
695 gc_status_info.gcphase = CACHEPOLICYPHASE;
698 void processmsg_gcfinishcachepolicy_I() {
699 int data1 = msgdata[msgdataindex];
701 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
703 // all cores should do update
704 if(data1 < NUMCORESACTIVE) {
705 gccorestatus[data1] = 0;
709 void processmsg_gcstartpref_I() {
710 gc_status_info.gcphase = PREFINISHPHASE;
713 void processmsg_gcfinishpref_I() {
714 int data1 = msgdata[msgdataindex];
716 // received a update phase finish msg
717 BAMBOO_ASSERT(BAMBOO_NUM_OF_CORE == STARTUPCORE);
719 // all cores should do update
720 if(data1 < NUMCORESACTIVE) {
721 gccorestatus[data1] = 0;
724 #endif // GC_CACHE_ADAPT
725 #endif // #ifdef MULTICORE_GC
727 void processmsg_req_notify_start() {
729 if(BAMBOO_CHECK_SEND_MODE()) {
730 cache_msg_1_I(STARTUPCORE,NOTIFYSTART);
732 send_msg_1_I(STARTUPCORE,NOTIFYSTART);
736 void processmsg_notify_start() {
740 // receive object transferred from other cores
741 // or the terminate message from other cores
742 // Should be invoked in critical sections!!
743 // NOTICE: following format is for threadsimulate version only
744 // RAW version please see previous description
745 // format: type + object
746 // type: -1--stall msg
748 // return value: 0--received an object
749 // 1--received nothing
750 // 2--received a Stall Msg
751 // 3--received a lock Msg
752 // RAW version: -1 -- received nothing
753 // otherwise -- received msg type
754 int receiveObject_I() {
755 PROFILE_INTERRUPT_START();
757 // get the incoming msgs
759 if((msgdataindex == msgdatalast) && (!msgdatafull)) {
762 if(BAMBOO_CHECK_SEND_MODE()) {
763 // during send, don't process the msg now
767 // processing received msgs
769 MSG_REMAINSIZE_I(size);
772 // have new coming msg
773 if((BAMBOO_MSG_AVAIL() != 0) && !msgdatafull) {
780 //we only ever read the first word
781 unsigned int realtype = msgdata[msgdataindex];
782 unsigned int msglength = checkMsgLength_I(realtype);
784 #if (defined(TASK)||defined(MULTICORE_GC))
785 unsigned int type = realtype & 0xff;
787 unsigned int type = realtype;
790 if(msglength <= size) {
791 // have some whole msg
796 case REQNOTIFYSTART: {
797 processmsg_req_notify_start();
802 processmsg_notify_start();
808 // receive a object transfer msg
809 processmsg_transobj_I(msglength);
814 // receive a stall msg
815 processmsg_transtall_I();
820 // GC version have no lock msgs
823 // receive lock request msg, handle it right now
824 processmsg_lockrequest_I();
828 // receive lock grount msg
829 processmsg_lockgrount_I();
833 // receive lock deny msg
834 processmsg_lockdeny_I();
838 processmsg_lockrelease_I();
844 case PROFILEOUTPUT: {
845 // receive an output profile data request msg
846 processmsg_profileoutput_I();
849 case PROFILEFINISH: {
850 // receive a profile output finish msg
851 processmsg_profilefinish_I();
856 // GC version has no lock msgs
859 // receive a redirect lock request msg, handle it right now
860 processmsg_redirectlock_I();
864 case REDIRECTGROUNT: {
865 // receive a lock grant msg with redirect info
866 processmsg_redirectgrount_I();
871 // receive a lock deny msg with redirect info
872 processmsg_redirectdeny_I();
876 case REDIRECTRELEASE: {
877 // receive a lock release msg with redirect info
878 processmsg_redirectrelease_I();
880 } // case REDIRECTRELEASE
884 case STATUSCONFIRM: {
885 // receive a status confirm info
886 processmsg_statusconfirm_I();
891 processmsg_statusreport_I();
896 // receive a terminate msg
897 processmsg_terminate_I();
902 processmsg_memrequest_I();
907 processmsg_memresponse_I();
914 processmsg_gcinvoke_I();
919 processmsg_gcstartpre_I();
924 processmsg_gcstartinit_I();
929 // receive a start GC msg
930 processmsg_gcstart_I();
934 case GCSTARTCOMPACT: {
935 // a compact phase start msg
936 processmsg_gcstartcompact_I();
940 case GCSTARTUPDATE: {
941 // received a update phase start msg
942 processmsg_gcstartupdate_I();
947 processmsg_gcfinishpre_I();
952 processmsg_gcfinishinit_I();
957 processmsg_gcfinishmark_I();
962 processmsg_returnmem_I();
966 case GCFINISHCOMPACT: {
967 // received a compact phase finish msg
968 processmsg_gcfinishcompact_I();
972 case GCFINISHUPDATE: {
973 processmsg_gcfinishupdate_I();
978 processmsg_gcfinish_I();
982 case GCMARKCONFIRM: {
983 // received a marked phase finish confirm request msg
984 // all cores should do mark
985 processmsg_gcmarkconfirm_I();
990 processmsg_gcmarkreport_I();
995 processmsg_gcmarkedobj_I();
1000 // received a start moving objs msg
1001 processmsg_gcmovestart_I();
1005 case GCLOBJREQUEST: {
1006 // received a large objs info request msg
1007 transferMarkResults_I();
1012 processmsg_reqblock_I();
1016 case GCGRANTBLOCK: {
1017 processmsg_grantblock_I();
1022 // received a large objs info response msg
1023 processmsg_gclobjinfo_I(msglength);
1029 // received a gcprofiles msg
1030 processmsg_gcprofiles_I();
1033 #endif // GC_PROFILE
1035 #ifdef GC_CACHE_ADAPT
1036 case GCSTARTCACHEPOLICY: {
1037 // received a gcstartcachepolicy msg
1038 processmsg_gcstartcachepolicy_I();
1042 case GCFINISHCACHEPOLICY: {
1043 // received a gcfinishcachepolicy msg
1044 processmsg_gcfinishcachepolicy_I();
1049 // received a gcstartpref msg
1050 processmsg_gcstartpref_I();
1054 case GCFINISHPREF: {
1055 // received a gcfinishpref msg
1056 processmsg_gcfinishpref_I();
1066 if((msgdataindex != msgdatalast) || (msgdatafull)) {
1067 // still have available msg
1071 // have new coming msg
1072 if(BAMBOO_MSG_AVAIL() != 0) {
1076 PROFILE_INTERRUPT_END();