242 gclog_or_tty->print_cr("[%u] task queue overflow, "
243 "moving entries to the global stack",
244 _worker_id);
245 }
246 move_entries_to_global_stack();
247
248 // this should succeed since, even if we overflow the global
249 // stack, we should have definitely removed some entries from the
250 // local queue. So, there must be space on it.
251 bool success = _task_queue->push(obj);
252 assert(success, "invariant");
253 }
254
255 statsOnly( int tmp_size = _task_queue->size();
256 if (tmp_size > _local_max_size) {
257 _local_max_size = tmp_size;
258 }
259 ++_local_pushes );
260 }
261
262 inline bool CMTask::is_below_finger(HeapWord* objAddr,
263 HeapWord* global_finger) const {
264 // If objAddr is above the global finger, then the mark bitmap scan
265 // will find it later, and no push is needed. Similarly, if we have
266 // a current region and objAddr is between the local finger and the
267 // end of the current region, then no push is needed. The tradeoff
268 // of checking both vs only checking the global finger is that the
269 // local check will be more accurate and so result in fewer pushes,
270 // but may also be a little slower.
271 if (_finger != NULL) {
272 // We have a current region.
273
274 // Finger and region values are all NULL or all non-NULL. We
275 // use _finger to check since we immediately use its value.
276 assert(_curr_region != NULL, "invariant");
277 assert(_region_limit != NULL, "invariant");
278 assert(_region_limit <= global_finger, "invariant");
279
280 // True if objAddr is less than the local finger, or is between
281 // the region limit and the global finger.
282 if (objAddr < _finger) {
283 return true;
284 } else if (objAddr < _region_limit) {
285 return false;
286 } // Else check global finger.
287 }
288 // Check global finger.
289 return objAddr < global_finger;
290 }
291
292 inline void CMTask::deal_with_reference(oop obj) {
293 if (_cm->verbose_high()) {
294 gclog_or_tty->print_cr("[%u] we're dealing with reference = "PTR_FORMAT,
295 _worker_id, p2i((void*) obj));
296 }
297
298 ++_refs_reached;
299
300 HeapWord* objAddr = (HeapWord*) obj;
301 assert(obj->is_oop_or_null(true /* ignore mark word */), "Error");
302 if (_g1h->is_in_g1_reserved(objAddr)) {
303 assert(obj != NULL, "null check is implicit");
304 if (!_nextMarkBitMap->isMarked(objAddr)) {
305 // Only get the containing region if the object is not marked on the
306 // bitmap (otherwise, it's a waste of time since we won't do
307 // anything with it).
308 HeapRegion* hr = _g1h->heap_region_containing_raw(obj);
309 if (!hr->obj_allocated_since_next_marking(obj)) {
310 if (_cm->verbose_high()) {
311 gclog_or_tty->print_cr("[%u] "PTR_FORMAT" is not considered marked",
312 _worker_id, p2i((void*) obj));
313 }
314
315 // we need to mark it first
316 if (_cm->par_mark_and_count(obj, hr, _marked_bytes_array, _card_bm)) {
317 // No OrderAccess:store_load() is needed. It is implicit in the
318 // CAS done in CMBitMap::parMark() call in the routine above.
319 HeapWord* global_finger = _cm->finger();
320
321 // We only need to push a newly grey object on the mark
322 // stack if it is in a section of memory the mark bitmap
323 // scan has already examined. Mark bitmap scanning
324 // maintains progress "fingers" for determining that.
325 //
326 // Notice that the global finger might be moving forward
327 // concurrently. This is not a problem. In the worst case, we
328 // mark the object while it is above the global finger and, by
329 // the time we read the global finger, it has moved forward
330 // past this object. In this case, the object will probably
331 // be visited when a task is scanning the region and will also
332 // be pushed on the stack. So, some duplicate work, but no
333 // correctness problems.
334 if (is_below_finger(objAddr, global_finger)) {
335 if (obj->is_typeArray()) {
336 // Immediately process arrays of primitive types, rather
337 // than pushing on the mark stack. This keeps us from
338 // adding humongous objects to the mark stack that might
339 // be reclaimed before the entry is processed - see
340 // selection of candidates for eager reclaim of humongous
341 // objects. The cost of the additional type test is
342 // mitigated by avoiding a trip through the mark stack,
343 // by only doing a bookkeeping update and avoiding the
344 // actual scan of the object - a typeArray contains no
345 // references, and the metadata is built-in.
346 process_grey_object<false>(obj);
347 } else {
348 if (_cm->verbose_high()) {
349 gclog_or_tty->print_cr("[%u] below a finger (local: " PTR_FORMAT
350 ", global: " PTR_FORMAT ") pushing "
351 PTR_FORMAT " on mark stack",
352 _worker_id, p2i(_finger),
353 p2i(global_finger), p2i(objAddr));
354 }
355 push(obj);
356 }
357 }
358 }
359 }
360 }
361 }
362 }
363
364 inline void ConcurrentMark::markPrev(oop p) {
365 assert(!_prevMarkBitMap->isMarked((HeapWord*) p), "sanity");
366 // Note we are overriding the read-only view of the prev map here, via
367 // the cast.
368 ((CMBitMap*)_prevMarkBitMap)->mark((HeapWord*) p);
369 }
370
371 inline void ConcurrentMark::grayRoot(oop obj, size_t word_size,
372 uint worker_id, HeapRegion* hr) {
373 assert(obj != NULL, "pre-condition");
374 HeapWord* addr = (HeapWord*) obj;
375 if (hr == NULL) {
376 hr = _g1h->heap_region_containing_raw(addr);
377 } else {
378 assert(hr->is_in(addr), "pre-condition");
|
242 gclog_or_tty->print_cr("[%u] task queue overflow, "
243 "moving entries to the global stack",
244 _worker_id);
245 }
246 move_entries_to_global_stack();
247
248 // this should succeed since, even if we overflow the global
249 // stack, we should have definitely removed some entries from the
250 // local queue. So, there must be space on it.
251 bool success = _task_queue->push(obj);
252 assert(success, "invariant");
253 }
254
255 statsOnly( int tmp_size = _task_queue->size();
256 if (tmp_size > _local_max_size) {
257 _local_max_size = tmp_size;
258 }
259 ++_local_pushes );
260 }
261
262 inline bool CMTask::is_below_finger(oop obj, HeapWord* global_finger) const {
263 // If obj is above the global finger, then the mark bitmap scan
264 // will find it later, and no push is needed. Similarly, if we have
265 // a current region and obj is between the local finger and the
266 // end of the current region, then no push is needed. The tradeoff
267 // of checking both vs only checking the global finger is that the
268 // local check will be more accurate and so result in fewer pushes,
269 // but may also be a little slower.
270 HeapWord* objAddr = (HeapWord*)obj;
271 if (_finger != NULL) {
272 // We have a current region.
273
274 // Finger and region values are all NULL or all non-NULL. We
275 // use _finger to check since we immediately use its value.
276 assert(_curr_region != NULL, "invariant");
277 assert(_region_limit != NULL, "invariant");
278 assert(_region_limit <= global_finger, "invariant");
279
280 // True if obj is less than the local finger, or is between
281 // the region limit and the global finger.
282 if (objAddr < _finger) {
283 return true;
284 } else if (objAddr < _region_limit) {
285 return false;
286 } // Else check global finger.
287 }
288 // Check global finger.
289 return objAddr < global_finger;
290 }
291
292 inline void CMTask::make_reference_grey(oop obj, HeapRegion* hr) {
293 if (_cm->par_mark_and_count(obj, hr, _marked_bytes_array, _card_bm)) {
294
295 if (_cm->verbose_high()) {
296 gclog_or_tty->print_cr("[%u] marked object " PTR_FORMAT,
297 _worker_id, p2i(obj));
298 }
299
300 // No OrderAccess:store_load() is needed. It is implicit in the
301 // CAS done in CMBitMap::parMark() call in the routine above.
302 HeapWord* global_finger = _cm->finger();
303
304 // We only need to push a newly grey object on the mark
305 // stack if it is in a section of memory the mark bitmap
306 // scan has already examined. Mark bitmap scanning
307 // maintains progress "fingers" for determining that.
308 //
309 // Notice that the global finger might be moving forward
310 // concurrently. This is not a problem. In the worst case, we
311 // mark the object while it is above the global finger and, by
312 // the time we read the global finger, it has moved forward
313 // past this object. In this case, the object will probably
314 // be visited when a task is scanning the region and will also
315 // be pushed on the stack. So, some duplicate work, but no
316 // correctness problems.
317 if (is_below_finger(obj, global_finger)) {
318 if (obj->is_typeArray()) {
319 // Immediately process arrays of primitive types, rather
320 // than pushing on the mark stack. This keeps us from
321 // adding humongous objects to the mark stack that might
322 // be reclaimed before the entry is processed - see
323 // selection of candidates for eager reclaim of humongous
324 // objects. The cost of the additional type test is
325 // mitigated by avoiding a trip through the mark stack,
326 // by only doing a bookkeeping update and avoiding the
327 // actual scan of the object - a typeArray contains no
328 // references, and the metadata is built-in.
329 process_grey_object<false>(obj);
330 } else {
331 if (_cm->verbose_high()) {
332 gclog_or_tty->print_cr("[%u] below a finger (local: " PTR_FORMAT
333 ", global: " PTR_FORMAT ") pushing "
334 PTR_FORMAT " on mark stack",
335 _worker_id, p2i(_finger),
336 p2i(global_finger), p2i(obj));
337 }
338 push(obj);
339 }
340 }
341 }
342 }
343
344 inline void CMTask::deal_with_reference(oop obj) {
345 if (_cm->verbose_high()) {
346 gclog_or_tty->print_cr("[%u] we're dealing with reference = "PTR_FORMAT,
347 _worker_id, p2i((void*) obj));
348 }
349
350 increment_refs_reached();
351
352 HeapWord* objAddr = (HeapWord*) obj;
353 assert(obj->is_oop_or_null(true /* ignore mark word */), "Error");
354 if (_g1h->is_in_g1_reserved(objAddr)) {
355 assert(obj != NULL, "null check is implicit");
356 if (!_nextMarkBitMap->isMarked(objAddr)) {
357 // Only get the containing region if the object is not marked on the
358 // bitmap (otherwise, it's a waste of time since we won't do
359 // anything with it).
360 HeapRegion* hr = _g1h->heap_region_containing_raw(obj);
361 if (!hr->obj_allocated_since_next_marking(obj)) {
362 make_reference_grey(obj, hr);
363 }
364 }
365 }
366 }
367
368 inline void ConcurrentMark::markPrev(oop p) {
369 assert(!_prevMarkBitMap->isMarked((HeapWord*) p), "sanity");
370 // Note we are overriding the read-only view of the prev map here, via
371 // the cast.
372 ((CMBitMap*)_prevMarkBitMap)->mark((HeapWord*) p);
373 }
374
375 inline void ConcurrentMark::grayRoot(oop obj, size_t word_size,
376 uint worker_id, HeapRegion* hr) {
377 assert(obj != NULL, "pre-condition");
378 HeapWord* addr = (HeapWord*) obj;
379 if (hr == NULL) {
380 hr = _g1h->heap_region_containing_raw(addr);
381 } else {
382 assert(hr->is_in(addr), "pre-condition");
|