59 #endif // INCLUDE_ALL_GCS |
59 #endif // INCLUDE_ALL_GCS |
60 |
60 |
61 GenCollectedHeap* GenCollectedHeap::_gch; |
61 GenCollectedHeap* GenCollectedHeap::_gch; |
62 NOT_PRODUCT(size_t GenCollectedHeap::_skip_header_HeapWords = 0;) |
62 NOT_PRODUCT(size_t GenCollectedHeap::_skip_header_HeapWords = 0;) |
63 |
63 |
64 // The set of potentially parallel tasks in strong root scanning. |
64 // The set of potentially parallel tasks in root scanning. |
65 enum GCH_process_strong_roots_tasks { |
65 enum GCH_strong_roots_tasks { |
66 // We probably want to parallelize both of these internally, but for now... |
66 // We probably want to parallelize both of these internally, but for now... |
67 GCH_PS_younger_gens, |
67 GCH_PS_younger_gens, |
68 // Leave this one last. |
68 // Leave this one last. |
69 GCH_PS_NumElements |
69 GCH_PS_NumElements |
70 }; |
70 }; |
71 |
71 |
72 GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) : |
72 GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) : |
73 SharedHeap(policy), |
73 SharedHeap(policy), |
74 _gen_policy(policy), |
74 _gen_policy(policy), |
75 _gen_process_strong_tasks(new SubTasksDone(GCH_PS_NumElements)), |
75 _gen_process_roots_tasks(new SubTasksDone(GCH_PS_NumElements)), |
76 _full_collections_completed(0) |
76 _full_collections_completed(0) |
77 { |
77 { |
78 if (_gen_process_strong_tasks == NULL || |
78 if (_gen_process_roots_tasks == NULL || |
79 !_gen_process_strong_tasks->valid()) { |
79 !_gen_process_roots_tasks->valid()) { |
80 vm_exit_during_initialization("Failed necessary allocation."); |
80 vm_exit_during_initialization("Failed necessary allocation."); |
81 } |
81 } |
82 assert(policy != NULL, "Sanity check"); |
82 assert(policy != NULL, "Sanity check"); |
83 } |
83 } |
84 |
84 |
582 return collector_policy()->satisfy_failed_allocation(size, is_tlab); |
582 return collector_policy()->satisfy_failed_allocation(size, is_tlab); |
583 } |
583 } |
584 |
584 |
585 void GenCollectedHeap::set_par_threads(uint t) { |
585 void GenCollectedHeap::set_par_threads(uint t) { |
586 SharedHeap::set_par_threads(t); |
586 SharedHeap::set_par_threads(t); |
587 _gen_process_strong_tasks->set_n_threads(t); |
587 _gen_process_roots_tasks->set_n_threads(t); |
588 } |
588 } |
589 |
589 |
590 void GenCollectedHeap:: |
590 void GenCollectedHeap:: |
591 gen_process_strong_roots(int level, |
591 gen_process_roots(int level, |
592 bool younger_gens_as_roots, |
592 bool younger_gens_as_roots, |
593 bool activate_scope, |
593 bool activate_scope, |
594 SharedHeap::ScanningOption so, |
594 SharedHeap::ScanningOption so, |
595 OopsInGenClosure* not_older_gens, |
595 OopsInGenClosure* not_older_gens, |
596 OopsInGenClosure* older_gens, |
596 OopsInGenClosure* weak_roots, |
597 KlassClosure* klass_closure) { |
597 OopsInGenClosure* older_gens, |
598 // General strong roots. |
598 CLDClosure* cld_closure, |
599 |
599 CLDClosure* weak_cld_closure, |
600 SharedHeap::process_strong_roots(activate_scope, so, |
600 CodeBlobClosure* code_closure) { |
601 not_older_gens, klass_closure); |
601 |
|
602 // General roots. |
|
603 SharedHeap::process_roots(activate_scope, so, |
|
604 not_older_gens, weak_roots, |
|
605 cld_closure, weak_cld_closure, |
|
606 code_closure); |
602 |
607 |
603 if (younger_gens_as_roots) { |
608 if (younger_gens_as_roots) { |
604 if (!_gen_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) { |
609 if (!_gen_process_roots_tasks->is_task_claimed(GCH_PS_younger_gens)) { |
605 for (int i = 0; i < level; i++) { |
610 for (int i = 0; i < level; i++) { |
606 not_older_gens->set_generation(_gens[i]); |
611 not_older_gens->set_generation(_gens[i]); |
607 _gens[i]->oop_iterate(not_older_gens); |
612 _gens[i]->oop_iterate(not_older_gens); |
608 } |
613 } |
609 not_older_gens->reset_generation(); |
614 not_older_gens->reset_generation(); |
615 older_gens->set_generation(_gens[i]); |
620 older_gens->set_generation(_gens[i]); |
616 rem_set()->younger_refs_iterate(_gens[i], older_gens); |
621 rem_set()->younger_refs_iterate(_gens[i], older_gens); |
617 older_gens->reset_generation(); |
622 older_gens->reset_generation(); |
618 } |
623 } |
619 |
624 |
620 _gen_process_strong_tasks->all_tasks_completed(); |
625 _gen_process_roots_tasks->all_tasks_completed(); |
|
626 } |
|
627 |
|
628 void GenCollectedHeap:: |
|
629 gen_process_roots(int level, |
|
630 bool younger_gens_as_roots, |
|
631 bool activate_scope, |
|
632 SharedHeap::ScanningOption so, |
|
633 bool only_strong_roots, |
|
634 OopsInGenClosure* not_older_gens, |
|
635 OopsInGenClosure* older_gens, |
|
636 CLDClosure* cld_closure) { |
|
637 |
|
638 const bool is_adjust_phase = !only_strong_roots && !younger_gens_as_roots; |
|
639 |
|
640 bool is_moving_collection = false; |
|
641 if (level == 0 || is_adjust_phase) { |
|
642 // young collections are always moving |
|
643 is_moving_collection = true; |
|
644 } |
|
645 |
|
646 MarkingCodeBlobClosure mark_code_closure(not_older_gens, is_moving_collection); |
|
647 CodeBlobClosure* code_closure = &mark_code_closure; |
|
648 |
|
649 gen_process_roots(level, |
|
650 younger_gens_as_roots, |
|
651 activate_scope, so, |
|
652 not_older_gens, only_strong_roots ? NULL : not_older_gens, |
|
653 older_gens, |
|
654 cld_closure, only_strong_roots ? NULL : cld_closure, |
|
655 code_closure); |
|
656 |
621 } |
657 } |
622 |
658 |
623 void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure) { |
659 void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure) { |
624 SharedHeap::process_weak_roots(root_closure); |
660 SharedHeap::process_weak_roots(root_closure); |
625 // "Local" "weak" refs |
661 // "Local" "weak" refs |