Don't check for swept blocks in -DS.
[ghc.git] / includes / rts / storage / Block.h
1 /* -----------------------------------------------------------------------------
2 *
3 * (c) The GHC Team, 1998-1999
4 *
5 * Block structure for the storage manager
6 *
7 * ---------------------------------------------------------------------------*/
8
9 #ifndef RTS_STORAGE_BLOCK_H
10 #define RTS_STORAGE_BLOCK_H
11
12 /* The actual block and megablock-size constants are defined in
13 * includes/Constants.h, all constants here are derived from these.
14 */
15
16 /* Block related constants (BLOCK_SHIFT is defined in Constants.h) */
17
18 #define BLOCK_SIZE (1<<BLOCK_SHIFT)
19 #define BLOCK_SIZE_W (BLOCK_SIZE/sizeof(W_))
20 #define BLOCK_MASK (BLOCK_SIZE-1)
21
22 #define BLOCK_ROUND_UP(p) ((void *) (((W_)(p)+BLOCK_SIZE-1) & ~BLOCK_MASK))
23 #define BLOCK_ROUND_DOWN(p) ((void *) ((W_)(p) & ~BLOCK_MASK))
24
25 /* Megablock related constants (MBLOCK_SHIFT is defined in Constants.h) */
26
27 #define MBLOCK_SIZE (1<<MBLOCK_SHIFT)
28 #define MBLOCK_SIZE_W (MBLOCK_SIZE/sizeof(W_))
29 #define MBLOCK_MASK (MBLOCK_SIZE-1)
30
31 #define MBLOCK_ROUND_UP(p) ((void *)(((W_)(p)+MBLOCK_SIZE-1) & ~MBLOCK_MASK))
32 #define MBLOCK_ROUND_DOWN(p) ((void *)((W_)(p) & ~MBLOCK_MASK ))
33
34 /* The largest size an object can be before we give it a block of its
35 * own and treat it as an immovable object during GC, expressed as a
36 * fraction of BLOCK_SIZE.
37 */
38 #define LARGE_OBJECT_THRESHOLD ((nat)(BLOCK_SIZE * 8 / 10))
39
40 /* -----------------------------------------------------------------------------
41 * Block descriptor. This structure *must* be the right length, so we
42 * can do pointer arithmetic on pointers to it.
43 */
44
45 /* The block descriptor is 64 bytes on a 64-bit machine, and 32-bytes
46 * on a 32-bit machine.
47 */
48
49 #ifndef CMINUSMINUS
50 typedef struct bdescr_ {
51 StgPtr start; /* start addr of memory */
52 StgPtr free; /* first free byte of memory */
53 struct bdescr_ *link; /* used for chaining blocks together */
54 union {
55 struct bdescr_ *back; /* used (occasionally) for doubly-linked lists*/
56 StgWord *bitmap;
57 StgPtr scan; /* scan pointer for copying GC */
58 } u;
59
60 struct generation_ *gen; /* generation */
61 struct generation_ *dest; /* destination gen */
62
63 StgWord32 blocks; /* no. of blocks (if grp head, 0 otherwise) */
64
65 StgWord16 gen_no;
66 StgWord16 flags; /* block flags, see below */
67 #if SIZEOF_VOID_P == 8
68 StgWord32 _padding[2];
69 #else
70 StgWord32 _padding[0];
71 #endif
72 } bdescr;
73 #endif
74
75 #if SIZEOF_VOID_P == 8
76 #define BDESCR_SIZE 0x40
77 #define BDESCR_MASK 0x3f
78 #define BDESCR_SHIFT 6
79 #else
80 #define BDESCR_SIZE 0x20
81 #define BDESCR_MASK 0x1f
82 #define BDESCR_SHIFT 5
83 #endif
84
85 /* Block contains objects evacuated during this GC */
86 #define BF_EVACUATED 1
87 /* Block is a large object */
88 #define BF_LARGE 2
89 /* Block is pinned */
90 #define BF_PINNED 4
91 /* Block is to be marked, not copied */
92 #define BF_MARKED 8
93 /* Block is free, and on the free list (TODO: is this used?) */
94 #define BF_FREE 16
95 /* Block is executable */
96 #define BF_EXEC 32
97 /* Block contains only a small amount of live data */
98 #define BF_FRAGMENTED 64
99 /* we know about this block (for finding leaks) */
100 #define BF_KNOWN 128
101 /* Block was swept in the last generation */
102 #define BF_SWEPT 256
103
104 /* Finding the block descriptor for a given block -------------------------- */
105
106 #ifdef CMINUSMINUS
107
108 #define Bdescr(p) \
109 ((((p) & MBLOCK_MASK & ~BLOCK_MASK) >> (BLOCK_SHIFT-BDESCR_SHIFT)) \
110 | ((p) & ~MBLOCK_MASK))
111
112 #else
113
114 EXTERN_INLINE bdescr *Bdescr(StgPtr p);
115 EXTERN_INLINE bdescr *Bdescr(StgPtr p)
116 {
117 return (bdescr *)
118 ((((W_)p & MBLOCK_MASK & ~BLOCK_MASK) >> (BLOCK_SHIFT-BDESCR_SHIFT))
119 | ((W_)p & ~MBLOCK_MASK)
120 );
121 }
122
123 #endif
124
125 /* Useful Macros ------------------------------------------------------------ */
126
127 /* Offset of first real data block in a megablock */
128
129 #define FIRST_BLOCK_OFF \
130 ((W_)BLOCK_ROUND_UP(BDESCR_SIZE * (MBLOCK_SIZE / BLOCK_SIZE)))
131
132 /* First data block in a given megablock */
133
134 #define FIRST_BLOCK(m) ((void *)(FIRST_BLOCK_OFF + (W_)(m)))
135
136 /* Last data block in a given megablock */
137
138 #define LAST_BLOCK(m) ((void *)(MBLOCK_SIZE-BLOCK_SIZE + (W_)(m)))
139
140 /* First real block descriptor in a megablock */
141
142 #define FIRST_BDESCR(m) \
143 ((bdescr *)((FIRST_BLOCK_OFF>>(BLOCK_SHIFT-BDESCR_SHIFT)) + (W_)(m)))
144
145 /* Last real block descriptor in a megablock */
146
147 #define LAST_BDESCR(m) \
148 ((bdescr *)(((MBLOCK_SIZE-BLOCK_SIZE)>>(BLOCK_SHIFT-BDESCR_SHIFT)) + (W_)(m)))
149
150 /* Number of usable blocks in a megablock */
151
152 #define BLOCKS_PER_MBLOCK ((MBLOCK_SIZE - FIRST_BLOCK_OFF) / BLOCK_SIZE)
153
154 /* How many blocks in this megablock group */
155
156 #define MBLOCK_GROUP_BLOCKS(n) \
157 (BLOCKS_PER_MBLOCK + (n-1) * (MBLOCK_SIZE / BLOCK_SIZE))
158
159 /* Compute the required size of a megablock group */
160
161 #define BLOCKS_TO_MBLOCKS(n) \
162 (1 + (W_)MBLOCK_ROUND_UP((n-BLOCKS_PER_MBLOCK) * BLOCK_SIZE) / MBLOCK_SIZE)
163
164
165 #ifndef CMINUSMINUS
166 /* to the end... */
167
168 /* Double-linked block lists: --------------------------------------------- */
169
170 INLINE_HEADER void
171 dbl_link_onto(bdescr *bd, bdescr **list)
172 {
173 bd->link = *list;
174 bd->u.back = NULL;
175 if (*list) {
176 (*list)->u.back = bd; /* double-link the list */
177 }
178 *list = bd;
179 }
180
181 INLINE_HEADER void
182 dbl_link_remove(bdescr *bd, bdescr **list)
183 {
184 if (bd->u.back) {
185 bd->u.back->link = bd->link;
186 } else {
187 *list = bd->link;
188 }
189 if (bd->link) {
190 bd->link->u.back = bd->u.back;
191 }
192 }
193
194 INLINE_HEADER void
195 dbl_link_insert_after(bdescr *bd, bdescr *after)
196 {
197 bd->link = after->link;
198 bd->u.back = after;
199 if (after->link) {
200 after->link->u.back = bd;
201 }
202 after->link = bd;
203 }
204
205 INLINE_HEADER void
206 dbl_link_replace(bdescr *new, bdescr *old, bdescr **list)
207 {
208 new->link = old->link;
209 new->u.back = old->u.back;
210 if (old->link) {
211 old->link->u.back = new;
212 }
213 if (old->u.back) {
214 old->u.back->link = new;
215 } else {
216 *list = new;
217 }
218 }
219
220 /* Initialisation ---------------------------------------------------------- */
221
222 extern void initBlockAllocator(void);
223
224 /* Allocation -------------------------------------------------------------- */
225
226 bdescr *allocGroup(nat n);
227 bdescr *allocBlock(void);
228
229 // versions that take the storage manager lock for you:
230 bdescr *allocGroup_lock(nat n);
231 bdescr *allocBlock_lock(void);
232
233 /* De-Allocation ----------------------------------------------------------- */
234
235 void freeGroup(bdescr *p);
236 void freeChain(bdescr *p);
237
238 // versions that take the storage manager lock for you:
239 void freeGroup_lock(bdescr *p);
240 void freeChain_lock(bdescr *p);
241
242 bdescr * splitBlockGroup (bdescr *bd, nat blocks);
243
244 /* Round a value to megablocks --------------------------------------------- */
245
246 // We want to allocate an object around a given size, round it up or
247 // down to the nearest size that will fit in an mblock group.
248 INLINE_HEADER StgWord
249 round_to_mblocks(StgWord words)
250 {
251 if (words > BLOCKS_PER_MBLOCK * BLOCK_SIZE_W) {
252 // first, ignore the gap at the beginning of the first mblock by
253 // adding it to the total words. Then we can pretend we're
254 // dealing in a uniform unit of megablocks.
255 words += FIRST_BLOCK_OFF/sizeof(W_);
256
257 if ((words % MBLOCK_SIZE_W) < (MBLOCK_SIZE_W / 2)) {
258 words = (words / MBLOCK_SIZE_W) * MBLOCK_SIZE_W;
259 } else {
260 words = ((words / MBLOCK_SIZE_W) + 1) * MBLOCK_SIZE_W;
261 }
262
263 words -= FIRST_BLOCK_OFF/sizeof(W_);
264 }
265 return words;
266 }
267
268 INLINE_HEADER StgWord
269 round_up_to_mblocks(StgWord words)
270 {
271 words += FIRST_BLOCK_OFF/sizeof(W_);
272 words = ((words / MBLOCK_SIZE_W) + 1) * MBLOCK_SIZE_W;
273 words -= FIRST_BLOCK_OFF/sizeof(W_);
274 return words;
275 }
276
277 #endif /* !CMINUSMINUS */
278 #endif /* RTS_STORAGE_BLOCK_H */