author | kvn |
Thu, 27 May 2010 18:01:56 -0700 | |
changeset 5694 | 1e0532a6abff |
parent 3261 | c7d5aae8d3f7 |
child 5547 | f4b087cbb361 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
3261 | 2 |
* Copyright 2005-2009 Sun Microsystems, Inc. All Rights Reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
19 |
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
20 |
* CA 95054 USA or visit www.sun.com if you need additional information or |
|
21 |
* have any questions. |
|
22 |
* |
|
23 |
*/ |
|
24 |
||
25 |
class oopDesc; |
|
26 |
class ParMarkBitMapClosure; |
|
27 |
||
28 |
class ParMarkBitMap: public CHeapObj |
|
29 |
{ |
|
30 |
public: |
|
31 |
typedef BitMap::idx_t idx_t; |
|
32 |
||
33 |
// Values returned by the iterate() methods. |
|
34 |
enum IterationStatus { incomplete, complete, full, would_overflow }; |
|
35 |
||
36 |
inline ParMarkBitMap(); |
|
37 |
inline ParMarkBitMap(MemRegion covered_region); |
|
38 |
bool initialize(MemRegion covered_region); |
|
39 |
||
40 |
// Atomically mark an object as live. |
|
41 |
bool mark_obj(HeapWord* addr, size_t size); |
|
42 |
inline bool mark_obj(oop obj, int size); |
|
43 |
inline bool mark_obj(oop obj); |
|
44 |
||
45 |
// Return whether the specified begin or end bit is set. |
|
46 |
inline bool is_obj_beg(idx_t bit) const; |
|
47 |
inline bool is_obj_end(idx_t bit) const; |
|
48 |
||
49 |
// Traditional interface for testing whether an object is marked or not (these |
|
50 |
// test only the begin bits). |
|
51 |
inline bool is_marked(idx_t bit) const; |
|
52 |
inline bool is_marked(HeapWord* addr) const; |
|
53 |
inline bool is_marked(oop obj) const; |
|
54 |
||
55 |
inline bool is_unmarked(idx_t bit) const; |
|
56 |
inline bool is_unmarked(HeapWord* addr) const; |
|
57 |
inline bool is_unmarked(oop obj) const; |
|
58 |
||
59 |
// Convert sizes from bits to HeapWords and back. An object that is n bits |
|
60 |
// long will be bits_to_words(n) words long. An object that is m words long |
|
61 |
// will take up words_to_bits(m) bits in the bitmap. |
|
62 |
inline static size_t bits_to_words(idx_t bits); |
|
63 |
inline static idx_t words_to_bits(size_t words); |
|
64 |
||
65 |
// Return the size in words of an object given a begin bit and an end bit, or |
|
66 |
// the equivalent beg_addr and end_addr. |
|
67 |
inline size_t obj_size(idx_t beg_bit, idx_t end_bit) const; |
|
68 |
inline size_t obj_size(HeapWord* beg_addr, HeapWord* end_addr) const; |
|
69 |
||
70 |
// Return the size in words of the object (a search is done for the end bit). |
|
71 |
inline size_t obj_size(idx_t beg_bit) const; |
|
72 |
inline size_t obj_size(HeapWord* addr) const; |
|
73 |
inline size_t obj_size(oop obj) const; |
|
74 |
||
75 |
// Synonyms for the above. |
|
76 |
size_t obj_size_in_words(oop obj) const { return obj_size((HeapWord*)obj); } |
|
77 |
size_t obj_size_in_words(HeapWord* addr) const { return obj_size(addr); } |
|
78 |
||
79 |
// Apply live_closure to each live object that lies completely within the |
|
80 |
// range [live_range_beg, live_range_end). This is used to iterate over the |
|
81 |
// compacted region of the heap. Return values: |
|
82 |
// |
|
83 |
// incomplete The iteration is not complete. The last object that |
|
84 |
// begins in the range does not end in the range; |
|
85 |
// closure->source() is set to the start of that object. |
|
86 |
// |
|
87 |
// complete The iteration is complete. All objects in the range |
|
88 |
// were processed and the closure is not full; |
|
89 |
// closure->source() is set one past the end of the range. |
|
90 |
// |
|
91 |
// full The closure is full; closure->source() is set to one |
|
92 |
// past the end of the last object processed. |
|
93 |
// |
|
94 |
// would_overflow The next object in the range would overflow the closure; |
|
95 |
// closure->source() is set to the start of that object. |
|
96 |
IterationStatus iterate(ParMarkBitMapClosure* live_closure, |
|
97 |
idx_t range_beg, idx_t range_end) const; |
|
98 |
inline IterationStatus iterate(ParMarkBitMapClosure* live_closure, |
|
99 |
HeapWord* range_beg, |
|
100 |
HeapWord* range_end) const; |
|
101 |
||
102 |
// Apply live closure as above and additionally apply dead_closure to all dead |
|
103 |
// space in the range [range_beg, dead_range_end). Note that dead_range_end |
|
104 |
// must be >= range_end. This is used to iterate over the dense prefix. |
|
105 |
// |
|
106 |
// This method assumes that if the first bit in the range (range_beg) is not |
|
107 |
// marked, then dead space begins at that point and the dead_closure is |
|
108 |
// applied. Thus callers must ensure that range_beg is not in the middle of a |
|
109 |
// live object. |
|
110 |
IterationStatus iterate(ParMarkBitMapClosure* live_closure, |
|
111 |
ParMarkBitMapClosure* dead_closure, |
|
112 |
idx_t range_beg, idx_t range_end, |
|
113 |
idx_t dead_range_end) const; |
|
114 |
inline IterationStatus iterate(ParMarkBitMapClosure* live_closure, |
|
115 |
ParMarkBitMapClosure* dead_closure, |
|
116 |
HeapWord* range_beg, |
|
117 |
HeapWord* range_end, |
|
118 |
HeapWord* dead_range_end) const; |
|
119 |
||
120 |
// Return the number of live words in the range [beg_addr, end_addr) due to |
|
121 |
// objects that start in the range. If a live object extends onto the range, |
|
122 |
// the caller must detect and account for any live words due to that object. |
|
123 |
// If a live object extends beyond the end of the range, only the words within |
|
124 |
// the range are included in the result. |
|
125 |
size_t live_words_in_range(HeapWord* beg_addr, HeapWord* end_addr) const; |
|
126 |
||
127 |
// Same as the above, except the end of the range must be a live object, which |
|
128 |
// is the case when updating pointers. This allows a branch to be removed |
|
129 |
// from inside the loop. |
|
130 |
size_t live_words_in_range(HeapWord* beg_addr, oop end_obj) const; |
|
131 |
||
132 |
inline HeapWord* region_start() const; |
|
133 |
inline HeapWord* region_end() const; |
|
134 |
inline size_t region_size() const; |
|
135 |
inline size_t size() const; |
|
136 |
||
137 |
// Convert a heap address to/from a bit index. |
|
138 |
inline idx_t addr_to_bit(HeapWord* addr) const; |
|
139 |
inline HeapWord* bit_to_addr(idx_t bit) const; |
|
140 |
||
141 |
// Return the bit index of the first marked object that begins (or ends, |
|
142 |
// respectively) in the range [beg, end). If no object is found, return end. |
|
143 |
inline idx_t find_obj_beg(idx_t beg, idx_t end) const; |
|
144 |
inline idx_t find_obj_end(idx_t beg, idx_t end) const; |
|
145 |
||
146 |
inline HeapWord* find_obj_beg(HeapWord* beg, HeapWord* end) const; |
|
147 |
inline HeapWord* find_obj_end(HeapWord* beg, HeapWord* end) const; |
|
148 |
||
149 |
// Clear a range of bits or the entire bitmap (both begin and end bits are |
|
150 |
// cleared). |
|
151 |
inline void clear_range(idx_t beg, idx_t end); |
|
152 |
inline void clear() { clear_range(0, size()); } |
|
153 |
||
154 |
// Return the number of bits required to represent the specified number of |
|
155 |
// HeapWords, or the specified region. |
|
156 |
static inline idx_t bits_required(size_t words); |
|
157 |
static inline idx_t bits_required(MemRegion covered_region); |
|
158 |
static inline idx_t words_required(MemRegion covered_region); |
|
159 |
||
160 |
#ifndef PRODUCT |
|
161 |
// CAS statistics. |
|
162 |
size_t cas_tries() { return _cas_tries; } |
|
163 |
size_t cas_retries() { return _cas_retries; } |
|
164 |
size_t cas_by_another() { return _cas_by_another; } |
|
165 |
||
166 |
void reset_counters(); |
|
167 |
#endif // #ifndef PRODUCT |
|
168 |
||
169 |
#ifdef ASSERT |
|
170 |
void verify_clear() const; |
|
171 |
inline void verify_bit(idx_t bit) const; |
|
172 |
inline void verify_addr(HeapWord* addr) const; |
|
173 |
#endif // #ifdef ASSERT |
|
174 |
||
175 |
private: |
|
176 |
// Each bit in the bitmap represents one unit of 'object granularity.' Objects |
|
177 |
// are double-word aligned in 32-bit VMs, but not in 64-bit VMs, so the 32-bit |
|
178 |
// granularity is 2, 64-bit is 1. |
|
179 |
static inline size_t obj_granularity() { return size_t(MinObjAlignment); } |
|
2997
69cd0f7ac5d6
6814552: par compact - some compilers fail to optimize bitmap code
jcoomes
parents:
1374
diff
changeset
|
180 |
static inline int obj_granularity_shift() { return LogMinObjAlignment; } |
1 | 181 |
|
182 |
HeapWord* _region_start; |
|
183 |
size_t _region_size; |
|
184 |
BitMap _beg_bits; |
|
185 |
BitMap _end_bits; |
|
186 |
PSVirtualSpace* _virtual_space; |
|
187 |
||
188 |
#ifndef PRODUCT |
|
189 |
size_t _cas_tries; |
|
190 |
size_t _cas_retries; |
|
191 |
size_t _cas_by_another; |
|
192 |
#endif // #ifndef PRODUCT |
|
193 |
}; |
|
194 |
||
195 |
inline ParMarkBitMap::ParMarkBitMap(): |
|
1374 | 196 |
_beg_bits(), |
197 |
_end_bits() |
|
1 | 198 |
{ |
199 |
_region_start = 0; |
|
200 |
_virtual_space = 0; |
|
201 |
} |
|
202 |
||
203 |
inline ParMarkBitMap::ParMarkBitMap(MemRegion covered_region): |
|
1374 | 204 |
_beg_bits(), |
205 |
_end_bits() |
|
1 | 206 |
{ |
207 |
initialize(covered_region); |
|
208 |
} |
|
209 |
||
210 |
inline void ParMarkBitMap::clear_range(idx_t beg, idx_t end) |
|
211 |
{ |
|
212 |
_beg_bits.clear_range(beg, end); |
|
213 |
_end_bits.clear_range(beg, end); |
|
214 |
} |
|
215 |
||
216 |
inline ParMarkBitMap::idx_t |
|
217 |
ParMarkBitMap::bits_required(size_t words) |
|
218 |
{ |
|
219 |
// Need two bits (one begin bit, one end bit) for each unit of 'object |
|
220 |
// granularity' in the heap. |
|
221 |
return words_to_bits(words * 2); |
|
222 |
} |
|
223 |
||
224 |
inline ParMarkBitMap::idx_t |
|
225 |
ParMarkBitMap::bits_required(MemRegion covered_region) |
|
226 |
{ |
|
227 |
return bits_required(covered_region.word_size()); |
|
228 |
} |
|
229 |
||
230 |
inline ParMarkBitMap::idx_t |
|
231 |
ParMarkBitMap::words_required(MemRegion covered_region) |
|
232 |
{ |
|
233 |
return bits_required(covered_region) / BitsPerWord; |
|
234 |
} |
|
235 |
||
236 |
inline HeapWord* |
|
237 |
ParMarkBitMap::region_start() const |
|
238 |
{ |
|
239 |
return _region_start; |
|
240 |
} |
|
241 |
||
242 |
inline HeapWord* |
|
243 |
ParMarkBitMap::region_end() const |
|
244 |
{ |
|
245 |
return region_start() + region_size(); |
|
246 |
} |
|
247 |
||
248 |
inline size_t |
|
249 |
ParMarkBitMap::region_size() const |
|
250 |
{ |
|
251 |
return _region_size; |
|
252 |
} |
|
253 |
||
254 |
inline size_t |
|
255 |
ParMarkBitMap::size() const |
|
256 |
{ |
|
257 |
return _beg_bits.size(); |
|
258 |
} |
|
259 |
||
260 |
inline bool ParMarkBitMap::is_obj_beg(idx_t bit) const |
|
261 |
{ |
|
262 |
return _beg_bits.at(bit); |
|
263 |
} |
|
264 |
||
265 |
inline bool ParMarkBitMap::is_obj_end(idx_t bit) const |
|
266 |
{ |
|
267 |
return _end_bits.at(bit); |
|
268 |
} |
|
269 |
||
270 |
inline bool ParMarkBitMap::is_marked(idx_t bit) const |
|
271 |
{ |
|
272 |
return is_obj_beg(bit); |
|
273 |
} |
|
274 |
||
275 |
inline bool ParMarkBitMap::is_marked(HeapWord* addr) const |
|
276 |
{ |
|
277 |
return is_marked(addr_to_bit(addr)); |
|
278 |
} |
|
279 |
||
280 |
inline bool ParMarkBitMap::is_marked(oop obj) const |
|
281 |
{ |
|
282 |
return is_marked((HeapWord*)obj); |
|
283 |
} |
|
284 |
||
285 |
inline bool ParMarkBitMap::is_unmarked(idx_t bit) const |
|
286 |
{ |
|
287 |
return !is_marked(bit); |
|
288 |
} |
|
289 |
||
290 |
inline bool ParMarkBitMap::is_unmarked(HeapWord* addr) const |
|
291 |
{ |
|
292 |
return !is_marked(addr); |
|
293 |
} |
|
294 |
||
295 |
inline bool ParMarkBitMap::is_unmarked(oop obj) const |
|
296 |
{ |
|
297 |
return !is_marked(obj); |
|
298 |
} |
|
299 |
||
300 |
inline size_t |
|
301 |
ParMarkBitMap::bits_to_words(idx_t bits) |
|
302 |
{ |
|
2997
69cd0f7ac5d6
6814552: par compact - some compilers fail to optimize bitmap code
jcoomes
parents:
1374
diff
changeset
|
303 |
return bits << obj_granularity_shift(); |
1 | 304 |
} |
305 |
||
306 |
inline ParMarkBitMap::idx_t |
|
307 |
ParMarkBitMap::words_to_bits(size_t words) |
|
308 |
{ |
|
2997
69cd0f7ac5d6
6814552: par compact - some compilers fail to optimize bitmap code
jcoomes
parents:
1374
diff
changeset
|
309 |
return words >> obj_granularity_shift(); |
1 | 310 |
} |
311 |
||
312 |
inline size_t ParMarkBitMap::obj_size(idx_t beg_bit, idx_t end_bit) const |
|
313 |
{ |
|
314 |
DEBUG_ONLY(verify_bit(beg_bit);) |
|
315 |
DEBUG_ONLY(verify_bit(end_bit);) |
|
316 |
return bits_to_words(end_bit - beg_bit + 1); |
|
317 |
} |
|
318 |
||
319 |
inline size_t |
|
320 |
ParMarkBitMap::obj_size(HeapWord* beg_addr, HeapWord* end_addr) const |
|
321 |
{ |
|
322 |
DEBUG_ONLY(verify_addr(beg_addr);) |
|
323 |
DEBUG_ONLY(verify_addr(end_addr);) |
|
324 |
return pointer_delta(end_addr, beg_addr) + obj_granularity(); |
|
325 |
} |
|
326 |
||
327 |
inline size_t ParMarkBitMap::obj_size(idx_t beg_bit) const |
|
328 |
{ |
|
1374 | 329 |
const idx_t end_bit = _end_bits.get_next_one_offset_inline(beg_bit, size()); |
1 | 330 |
assert(is_marked(beg_bit), "obj not marked"); |
331 |
assert(end_bit < size(), "end bit missing"); |
|
332 |
return obj_size(beg_bit, end_bit); |
|
333 |
} |
|
334 |
||
335 |
inline size_t ParMarkBitMap::obj_size(HeapWord* addr) const |
|
336 |
{ |
|
337 |
return obj_size(addr_to_bit(addr)); |
|
338 |
} |
|
339 |
||
340 |
inline size_t ParMarkBitMap::obj_size(oop obj) const |
|
341 |
{ |
|
342 |
return obj_size((HeapWord*)obj); |
|
343 |
} |
|
344 |
||
345 |
inline ParMarkBitMap::IterationStatus |
|
346 |
ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure, |
|
347 |
HeapWord* range_beg, |
|
348 |
HeapWord* range_end) const |
|
349 |
{ |
|
350 |
return iterate(live_closure, addr_to_bit(range_beg), addr_to_bit(range_end)); |
|
351 |
} |
|
352 |
||
353 |
inline ParMarkBitMap::IterationStatus |
|
354 |
ParMarkBitMap::iterate(ParMarkBitMapClosure* live_closure, |
|
355 |
ParMarkBitMapClosure* dead_closure, |
|
356 |
HeapWord* range_beg, |
|
357 |
HeapWord* range_end, |
|
358 |
HeapWord* dead_range_end) const |
|
359 |
{ |
|
360 |
return iterate(live_closure, dead_closure, |
|
361 |
addr_to_bit(range_beg), addr_to_bit(range_end), |
|
362 |
addr_to_bit(dead_range_end)); |
|
363 |
} |
|
364 |
||
365 |
inline bool |
|
366 |
ParMarkBitMap::mark_obj(oop obj, int size) |
|
367 |
{ |
|
368 |
return mark_obj((HeapWord*)obj, (size_t)size); |
|
369 |
} |
|
370 |
||
371 |
inline BitMap::idx_t |
|
372 |
ParMarkBitMap::addr_to_bit(HeapWord* addr) const |
|
373 |
{ |
|
374 |
DEBUG_ONLY(verify_addr(addr);) |
|
375 |
return words_to_bits(pointer_delta(addr, region_start())); |
|
376 |
} |
|
377 |
||
378 |
inline HeapWord* |
|
379 |
ParMarkBitMap::bit_to_addr(idx_t bit) const |
|
380 |
{ |
|
381 |
DEBUG_ONLY(verify_bit(bit);) |
|
382 |
return region_start() + bits_to_words(bit); |
|
383 |
} |
|
384 |
||
385 |
inline ParMarkBitMap::idx_t |
|
386 |
ParMarkBitMap::find_obj_beg(idx_t beg, idx_t end) const |
|
387 |
{ |
|
1374 | 388 |
return _beg_bits.get_next_one_offset_inline_aligned_right(beg, end); |
1 | 389 |
} |
390 |
||
391 |
inline ParMarkBitMap::idx_t |
|
392 |
ParMarkBitMap::find_obj_end(idx_t beg, idx_t end) const |
|
393 |
{ |
|
1374 | 394 |
return _end_bits.get_next_one_offset_inline_aligned_right(beg, end); |
1 | 395 |
} |
396 |
||
397 |
inline HeapWord* |
|
398 |
ParMarkBitMap::find_obj_beg(HeapWord* beg, HeapWord* end) const |
|
399 |
{ |
|
400 |
const idx_t beg_bit = addr_to_bit(beg); |
|
401 |
const idx_t end_bit = addr_to_bit(end); |
|
402 |
const idx_t search_end = BitMap::word_align_up(end_bit); |
|
403 |
const idx_t res_bit = MIN2(find_obj_beg(beg_bit, search_end), end_bit); |
|
404 |
return bit_to_addr(res_bit); |
|
405 |
} |
|
406 |
||
407 |
inline HeapWord* |
|
408 |
ParMarkBitMap::find_obj_end(HeapWord* beg, HeapWord* end) const |
|
409 |
{ |
|
410 |
const idx_t beg_bit = addr_to_bit(beg); |
|
411 |
const idx_t end_bit = addr_to_bit(end); |
|
412 |
const idx_t search_end = BitMap::word_align_up(end_bit); |
|
413 |
const idx_t res_bit = MIN2(find_obj_end(beg_bit, search_end), end_bit); |
|
414 |
return bit_to_addr(res_bit); |
|
415 |
} |
|
416 |
||
417 |
#ifdef ASSERT |
|
418 |
inline void ParMarkBitMap::verify_bit(idx_t bit) const { |
|
419 |
// Allow one past the last valid bit; useful for loop bounds. |
|
420 |
assert(bit <= _beg_bits.size(), "bit out of range"); |
|
421 |
} |
|
422 |
||
423 |
inline void ParMarkBitMap::verify_addr(HeapWord* addr) const { |
|
424 |
// Allow one past the last valid address; useful for loop bounds. |
|
425 |
assert(addr >= region_start(), "addr too small"); |
|
426 |
assert(addr <= region_start() + region_size(), "addr too big"); |
|
427 |
} |
|
428 |
#endif // #ifdef ASSERT |