440 // be move during a partial collection. Though it can be |
440 // be move during a partial collection. Though it can be |
441 // inaccurate, it is sufficient for G1 because the conservative |
441 // inaccurate, it is sufficient for G1 because the conservative |
442 // implementation of is_scavengable() for G1 will indicate that |
442 // implementation of is_scavengable() for G1 will indicate that |
443 // all nmethods must be scanned during a partial collection. |
443 // all nmethods must be scanned during a partial collection. |
444 bool G1CollectedHeap::is_in_partial_collection(const void* p) { |
444 bool G1CollectedHeap::is_in_partial_collection(const void* p) { |
445 HeapRegion* hr = heap_region_containing(p); |
445 if (p == NULL) { |
446 return hr != NULL && hr->in_collection_set(); |
446 return false; |
|
447 } |
|
448 return heap_region_containing(p)->in_collection_set(); |
447 } |
449 } |
448 #endif |
450 #endif |
449 |
451 |
450 // Returns true if the reference points to an object that |
452 // Returns true if the reference points to an object that |
451 // can move in an incremental collection. |
453 // can move in an incremental collection. |
452 bool G1CollectedHeap::is_scavengable(const void* p) { |
454 bool G1CollectedHeap::is_scavengable(const void* p) { |
453 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
454 G1CollectorPolicy* g1p = g1h->g1_policy(); |
|
455 HeapRegion* hr = heap_region_containing(p); |
455 HeapRegion* hr = heap_region_containing(p); |
456 if (hr == NULL) { |
456 return !hr->isHumongous(); |
457 // null |
|
458 assert(p == NULL, err_msg("Not NULL " PTR_FORMAT ,p)); |
|
459 return false; |
|
460 } else { |
|
461 return !hr->isHumongous(); |
|
462 } |
|
463 } |
457 } |
464 |
458 |
465 void G1CollectedHeap::check_ct_logs_at_safepoint() { |
459 void G1CollectedHeap::check_ct_logs_at_safepoint() { |
466 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
460 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
467 CardTableModRefBS* ct_bs = g1_barrier_set(); |
461 CardTableModRefBS* ct_bs = g1_barrier_set(); |
2982 } |
2976 } |
2983 return NULL; |
2977 return NULL; |
2984 } |
2978 } |
2985 |
2979 |
2986 Space* G1CollectedHeap::space_containing(const void* addr) const { |
2980 Space* G1CollectedHeap::space_containing(const void* addr) const { |
2987 Space* res = heap_region_containing(addr); |
2981 return heap_region_containing(addr); |
2988 return res; |
|
2989 } |
2982 } |
2990 |
2983 |
2991 HeapWord* G1CollectedHeap::block_start(const void* addr) const { |
2984 HeapWord* G1CollectedHeap::block_start(const void* addr) const { |
2992 Space* sp = space_containing(addr); |
2985 Space* sp = space_containing(addr); |
2993 if (sp != NULL) { |
2986 return sp->block_start(addr); |
2994 return sp->block_start(addr); |
|
2995 } |
|
2996 return NULL; |
|
2997 } |
2987 } |
2998 |
2988 |
2999 size_t G1CollectedHeap::block_size(const HeapWord* addr) const { |
2989 size_t G1CollectedHeap::block_size(const HeapWord* addr) const { |
3000 Space* sp = space_containing(addr); |
2990 Space* sp = space_containing(addr); |
3001 assert(sp != NULL, "block_size of address outside of heap"); |
|
3002 return sp->block_size(addr); |
2991 return sp->block_size(addr); |
3003 } |
2992 } |
3004 |
2993 |
3005 bool G1CollectedHeap::block_is_obj(const HeapWord* addr) const { |
2994 bool G1CollectedHeap::block_is_obj(const HeapWord* addr) const { |
3006 Space* sp = space_containing(addr); |
2995 Space* sp = space_containing(addr); |
4650 |
4639 |
4651 G1ParGCAllocBuffer::G1ParGCAllocBuffer(size_t gclab_word_size) : |
4640 G1ParGCAllocBuffer::G1ParGCAllocBuffer(size_t gclab_word_size) : |
4652 ParGCAllocBuffer(gclab_word_size), _retired(true) { } |
4641 ParGCAllocBuffer(gclab_word_size), _retired(true) { } |
4653 |
4642 |
4654 void G1ParCopyHelper::mark_object(oop obj) { |
4643 void G1ParCopyHelper::mark_object(oop obj) { |
4655 #ifdef ASSERT |
4644 assert(!_g1->heap_region_containing(obj)->in_collection_set(), "should not mark objects in the CSet"); |
4656 HeapRegion* hr = _g1->heap_region_containing(obj); |
|
4657 assert(hr != NULL, "sanity"); |
|
4658 assert(!hr->in_collection_set(), "should not mark objects in the CSet"); |
|
4659 #endif // ASSERT |
|
4660 |
4645 |
4661 // We know that the object is not moving so it's safe to read its size. |
4646 // We know that the object is not moving so it's safe to read its size. |
4662 _cm->grayRoot(obj, (size_t) obj->size(), _worker_id); |
4647 _cm->grayRoot(obj, (size_t) obj->size(), _worker_id); |
4663 } |
4648 } |
4664 |
4649 |
4665 void G1ParCopyHelper::mark_forwarded_object(oop from_obj, oop to_obj) { |
4650 void G1ParCopyHelper::mark_forwarded_object(oop from_obj, oop to_obj) { |
4666 #ifdef ASSERT |
|
4667 assert(from_obj->is_forwarded(), "from obj should be forwarded"); |
4651 assert(from_obj->is_forwarded(), "from obj should be forwarded"); |
4668 assert(from_obj->forwardee() == to_obj, "to obj should be the forwardee"); |
4652 assert(from_obj->forwardee() == to_obj, "to obj should be the forwardee"); |
4669 assert(from_obj != to_obj, "should not be self-forwarded"); |
4653 assert(from_obj != to_obj, "should not be self-forwarded"); |
4670 |
4654 |
4671 HeapRegion* from_hr = _g1->heap_region_containing(from_obj); |
4655 assert(_g1->heap_region_containing(from_obj)->in_collection_set(), "from obj should be in the CSet"); |
4672 assert(from_hr != NULL, "sanity"); |
4656 assert(!_g1->heap_region_containing(to_obj)->in_collection_set(), "should not mark objects in the CSet"); |
4673 assert(from_hr->in_collection_set(), "from obj should be in the CSet"); |
|
4674 |
|
4675 HeapRegion* to_hr = _g1->heap_region_containing(to_obj); |
|
4676 assert(to_hr != NULL, "sanity"); |
|
4677 assert(!to_hr->in_collection_set(), "should not mark objects in the CSet"); |
|
4678 #endif // ASSERT |
|
4679 |
4657 |
4680 // The object might be in the process of being copied by another |
4658 // The object might be in the process of being copied by another |
4681 // worker so we cannot trust that its to-space image is |
4659 // worker so we cannot trust that its to-space image is |
4682 // well-formed. So we have to read its size from its from-space |
4660 // well-formed. So we have to read its size from its from-space |
4683 // image which we know should not be changing. |
4661 // image which we know should not be changing. |
6910 _refine_cte_cl->set_concurrent(concurrent); |
6888 _refine_cte_cl->set_concurrent(concurrent); |
6911 } |
6889 } |
6912 |
6890 |
6913 bool G1CollectedHeap::is_in_closed_subset(const void* p) const { |
6891 bool G1CollectedHeap::is_in_closed_subset(const void* p) const { |
6914 HeapRegion* hr = heap_region_containing(p); |
6892 HeapRegion* hr = heap_region_containing(p); |
6915 if (hr == NULL) { |
6893 return hr->is_in(p); |
6916 return false; |
|
6917 } else { |
|
6918 return hr->is_in(p); |
|
6919 } |
|
6920 } |
6894 } |
6921 |
6895 |
6922 // Methods for the mutator alloc region |
6896 // Methods for the mutator alloc region |
6923 |
6897 |
6924 HeapRegion* G1CollectedHeap::new_mutator_alloc_region(size_t word_size, |
6898 HeapRegion* G1CollectedHeap::new_mutator_alloc_region(size_t word_size, |