small changes
[IRC.git] / Robust / src / Runtime / bamboo / multicoregarbage.h
1 #ifndef BAMBOO_MULTICORE_GARBAGE_H
2 #define BAMBOO_MULTICORE_GARBAGE_H
3 #ifdef MULTICORE_GC
4 #include "multicore.h"
5 #include "multicoregc.h"
6 #include "multicorehelper.h"  // for mappings between core # and block #
7 #include "structdefs.h"
8 #include "multicoregcprofile.h"
9 #include "gctypes.h"
10
11 #ifdef GC_DEBUG
12 #define GC_PRINTF tprintf
13 #else
14 #define GC_PRINTF if(0) tprintf
15 #endif 
16
17 #ifdef GC_DEBUG
18 #define TR() tprintf("%u\n",__LINE__)
19 #else
20 #define TR()
21 #endif
22
23 // data structures for GC
24 #define BAMBOO_SMEM_SIZE_L (BAMBOO_SMEM_SIZE * 2)
25 #define BAMBOO_LARGE_SMEM_BOUND (BAMBOO_SMEM_SIZE_L*NUMCORES4GC)
26 // let each gc core to have one big block, this is very important
27 // for the computation of NUMBLOCKS(s, n), DO NOT change this!
28
29 typedef enum {
30   INITPHASE = 0x0,         // 0x0
31   MARKPHASE,               // 0x1
32   COMPACTPHASE,            // 0x2
33   SUBTLECOMPACTPHASE,      // 0x3
34   MAPPHASE,                // 0x4
35   UPDATEPHASE,             // 0x5
36   CACHEPOLICYPHASE,        // 0x6
37   PREFINISHPHASE,          // 0x7
38   FINISHPHASE              // 0x8
39 } GCPHASETYPE;
40
41 typedef struct gc_status {
42   volatile bool gcprocessing;
43   volatile GCPHASETYPE gcphase; // indicating GC phase
44   volatile bool gcbusystatus;
45 } gc_status_t;
46
47 extern volatile bool gcflag;
48 extern gc_status_t gc_status_info;
49 volatile bool gcprecheck; // indicates if there are updated pregc information
50
51 unsigned INTPTR gccurr_heaptop;
52 struct MGCHash * gcforwardobjtbl; // cache forwarded objs in mark phase
53 // for mark phase termination
54 volatile unsigned int gccorestatus[NUMCORESACTIVE];//records status of each core
55                                                    // 1: running gc
56                                                    // 0: stall
57
58 volatile unsigned int returnedmem[NUMCORESACTIVE];//records status of each core
59                                                    // 1: running gc
60                                                    // 0: stall
61 volatile unsigned int gcnumsendobjs[2][NUMCORESACTIVE];//# of objects sent out
62 volatile unsigned int gcnumreceiveobjs[2][NUMCORESACTIVE];//# of objects received
63 volatile unsigned int gcnumsrobjs_index;//indicates which entry to record the  
64                  // info received before phase 1 of the mark finish 
65                  // checking process
66                  // the info received in phase 2 must be 
67                  // recorded in the other entry
68
69 unsigned int gcself_numsendobjs;
70 unsigned int gcself_numreceiveobjs;
71
72 // for load balancing
73 unsigned INTPTR gcloads[NUMCORES4GC];
74 block_t numblockspercore;
75
76 //Top of each core's heap
77 void * topptrs[NUMCORES4GC];
78
79 // compact instruction
80 //keep track of what block we can fill to
81 unsigned int gcblock2fill;
82
83 // move instruction;
84 //this points to memory handed to core from master
85 volatile unsigned int gcmovestartaddr;
86 //this flag tells core that it is okay to start compacting
87 volatile bool gctomove;
88
89 //keeps track of memory request master was not able to serve
90 volatile unsigned int maxusefulmems[NUMCORES4GC]; //record pending mem requests
91 volatile unsigned int gcrequiredmems[NUMCORES4GC]; //record pending mem requests
92 volatile unsigned int gcmovepending;
93
94 //keep track of current base block pointer for orig block
95 volatile void * update_origblockptr;
96 volatile void * origblockarray[NUMCORES4GC];
97 volatile int origarraycount;
98 volatile bool blockgranted;
99
100
101 // shared memory pointer for pointer mapping tbls
102 // In GC version, this block of memory is located at the bottom of the 
103 // shared memory, right on the top of the smem tbl.
104 // The bottom of the shared memory = sbstart tbl + smemtbl + bamboo_rmsp
105 // These three types of table are always reside at the bottom of the shared 
106 // memory and will never be moved or garbage collected
107 //gcmappingtable gives new pointer location
108 void ** gcmappingtbl;
109 //number of bytes in mapping table
110 unsigned int bamboo_rmsp_size;
111
112 //mark table....keep track of mark bits
113 volatile unsigned int * gcmarktbl;
114
115 bool gc_checkCoreStatus();
116
117 void gc_resetCoreStatus();
118
119
120
121 /* Structure to keep track of free space in block */
122 enum blockstatus {
123   /* BS_USED indicates that we don't have information for this block yet */
124   BS_USED,
125   /* BS_LARGEOBJECT indicates that the beginning of this block has a large object*/
126   BS_LARGEOBJECT,
127   /* BS_FREE indicates that the block is at least partially free */
128   BS_FREE
129 };
130
131 struct blockrecord {
132   enum blockstatus status;
133   unsigned INTPTR usedspace;
134   unsigned INTPTR freespace;
135   unsigned int corenum;
136 };
137
138 #define NOFREEBLOCK 0xffffffff
139 struct allocrecord {
140   unsigned int lowestfreeblock;
141   struct blockrecord * blocktable;
142 };
143
144 struct allocrecord allocationinfo;
145
146 #ifdef GC_CACHE_ADAPT
147 // table recording the sampling data collected for cache adaption 
148 unsigned int * gccachesamplingtbl;
149 unsigned int * gccachesamplingtbl_local;// for zeroing memory only
150 unsigned int size_cachesamplingtbl_local; // for zeroing memory only
151 unsigned int * gccachesamplingtbl_r;
152 unsigned int * gccachesamplingtbl_local_r; // for zeroing memory only
153 unsigned int size_cachesamplingtbl_local_r; // for zeroing memory only
154 unsigned int * gccachepolicytbl;
155 unsigned int size_cachepolicytbl;
156 #endif
157
158 /* Total number of blocks in heap */
159
160 #define GCNUMBLOCK (NUMCORES4GC+(BAMBOO_SHARED_MEM_SIZE-BAMBOO_LARGE_SMEM_BOUND)/BAMBOO_SMEM_SIZE)
161 #define GCNUMLOCALBLOCK (GCNUMBLOCK/NUMCORES4GC)
162
163 /* Leave the neighboring cores with at least two blocks */
164 #define MAXNEIGHBORALLOC (GCNUMLOCALBLOCK-2)
165
166 /* This macro defines the smallest memoy chunk the master will hand out to another core during compacting */
167
168 #define MINMEMORYCHUNKSIZE 32768
169
170 #define ISVALIDPTR(x) ((((unsigned INTPTR)x)>=((unsigned INTPTR)gcbaseva))&&(((unsigned INTPTR)x)<((unsigned INTPTR)(gcbaseva+BAMBOO_SHARED_MEM_SIZE))))
171
172 /* This macro waits for the given gc phase */
173 #define WAITFORGCPHASE(phase) while(gc_status_info.gcphase != phase) ;
174
175 /* Local block number that can never be reached...*/
176 #define MAXBLOCK 0x4fffffff 
177
178 //Takes in pointer to heap object and converts to offset in alignment units
179 #define OBJMAPPINGINDEX(p) ALIGNOBJSIZE((unsigned INTPTR)(p-gcbaseva))
180
181 //Converts size of object into alignment units (need to round up)
182 #define ALIGNUNITS(s) (((s-1)>>ALIGNMENTSHIFT)+1)
183
184 //Rounds object size up to next alignment unit size
185 #define ALIGNSIZE(s) ((((unsigned int)(s-1))&~(ALIGNMENTBYTES-1))+ALIGNMENTBYTES)
186
187 #define GLOBALBLOCK2LOCAL(s) (s/NUMCORES4GC)
188
189 // mapping of pointer to block # (start from 0), here the block # is
190 // the global index
191 #define BLOCKINDEX(b, p)                        \
192   {                                                             \
193     unsigned INTPTR t = (unsigned INTPTR)(p - gcbaseva);        \
194     if(t < BAMBOO_LARGE_SMEM_BOUND) {                           \
195       b = t / BAMBOO_SMEM_SIZE_L;                               \
196     } else {                                                          \
197       b = NUMCORES4GC+((t-BAMBOO_LARGE_SMEM_BOUND)/BAMBOO_SMEM_SIZE); \
198     }                                                                 \
199   }
200
201 #define RESIDECORE(c, p) {     \
202     if(1 == (NUMCORES4GC)) { \
203       c = 0; \
204     } else { \
205       unsigned INTPTR b; \
206       BLOCKINDEX(b, p);               \
207       c = gc_block2core[(b%(NUMCORES4GC*2))]; \
208     } \
209   }
210
211 #define BLOCK2CORE(c, b) {                      \
212     if(1 == (NUMCORES4GC)) {                    \
213       c = 0;                                    \
214     } else {                                    \
215       c = gc_block2core[(b%(NUMCORES4GC*2))];   \
216     }                                           \
217   }
218
219 INLINE static unsigned int hostcore(void * ptr) {
220   // check the host core of ptr
221   unsigned int host;
222   RESIDECORE(host, ptr);
223   return host;
224 }
225
226 /*This macro takes in a number of bytes (the current offset into the
227   heap) and returns the number of local blocks needed for that many
228   bytes */
229
230 #define NUMBLOCKS(s, n) \
231   if(s < (BAMBOO_SMEM_SIZE_L)) { \
232     (n) = 0; \
233   } else { \
234     (n) = 1 + ((s) - (BAMBOO_SMEM_SIZE_L)) / (BAMBOO_SMEM_SIZE); \
235   }
236
237 //this macro takes in a global block identifier and returns the base
238 //offset into the heap
239 #define OFFSET2BASEVA(i) \
240   (((i)<NUMCORES4GC)?(BAMBOO_SMEM_SIZE_L*(i)):(BAMBOO_SMEM_SIZE*((i)-NUMCORES4GC)+BAMBOO_LARGE_SMEM_BOUND))
241
242
243 //This macro takes in a local block number and returns the size of the block
244 #define BLOCKSIZE(c) \
245   ((c)?BAMBOO_SMEM_SIZE:BAMBOO_SMEM_SIZE_L)
246
247 //This macro takes in a local block number and returns the size of the block
248 #define GLOBALBLOCKSIZE(c) \
249   ((c<NUMCORES4GC)?BAMBOO_SMEM_SIZE_L:BAMBOO_SMEM_SIZE)
250
251 //Takes as input the core number c and the local block index n and
252 //returns the global block index
253
254 #define BLOCKINDEX2(c, n) \
255   (gc_core2block[2*(c)+((n)&1)]+(NUMCORES4GC*2)*((n)>>1))
256
257 //This macro takes in a global block number and returns the base
258 //pointer of the next block
259 #define BOUNDPTR(b) \
260   (((b)<NUMCORES4GC)?(((b)+1)*BAMBOO_SMEM_SIZE_L):(BAMBOO_LARGE_SMEM_BOUND+((b)-NUMCORES4GC+1)*BAMBOO_SMEM_SIZE))
261
262 //This macro takes in the core number c and the local block number and
263 //sets p to the base pointer
264
265 #define BASEPTR(p, c, n) {                                 \
266     unsigned int b = BLOCKINDEX2((c), (n));                \
267     if(b < (NUMCORES4GC)) {                                \
268       p = gcbaseva + b * (BAMBOO_SMEM_SIZE_L);             \
269     } else {                                               \
270       p = gcbaseva+(BAMBOO_LARGE_SMEM_BOUND)+              \
271         (b-(NUMCORES4GC))*(BAMBOO_SMEM_SIZE);              \
272     }                                                      \
273   }
274
275 // the next core in the top of the heap
276 #define NEXTTOPCORE(b) (gc_block2core[((b)+1)%(NUMCORES4GC*2)])
277
278 // check if all cores are stall now
279 #define GC_CHECK_ALL_CORE_STATUS() gccorestatus[BAMBOO_NUM_OF_CORE] = 0; \
280   while(!gc_checkCoreStatus()) ;
281
282 // send a 1-word msg to all clients
283 #define GC_SEND_MSG_1_TO_CLIENT(m) \
284   { \
285     for(int i = 0; i < NUMCORESACTIVE; ++i) { \
286       gccorestatus[i] = 1; \
287       if(BAMBOO_NUM_OF_CORE != i) { \
288         send_msg_1(i, (m)); \
289       } \
290     } \
291   }
292
293 #define ISLOCAL(p) (hostcore(p)==BAMBOO_NUM_OF_CORE)
294
295 void initmulticoregcdata();
296 void dismulticoregcdata();
297 bool gc(struct garbagelist * stackptr); // core coordinator routine
298 void gc_collect(struct garbagelist* stackptr); //core collector routine
299 void gc_nocollect(struct garbagelist* stackptr); //non-gc core collector routine
300 void master_mark(struct garbagelist *stackptr);
301 void master_getlargeobjs();
302 void master_compact();
303 void master_updaterefs();
304 void master_finish();
305 void gc_master(struct garbagelist * stackptr);
306
307
308 void transferMarkResults_I();
309 void * gcfindSpareMem_I(unsigned INTPTR requiredmem, unsigned INTPTR maxbytesneeded, unsigned int requiredcore);
310
311 #define INITMULTICOREGCDATA() initmulticoregcdata()
312 #define DISMULTICOREGCDATA() dismulticoregcdata()
313 #else // MULTICORE_GC
314 #define INITMULTICOREGCDATA()
315 #define DISMULTICOREGCDATA()
316 #endif // MULTICORE_GC
317 #endif // BAMBOO_MULTICORE_GARBAGE_H