2656 } |
2656 } |
2657 }; |
2657 }; |
2658 |
2658 |
2659 void |
2659 void |
2660 G1CollectedHeap::do_collection_pause_at_safepoint() { |
2660 G1CollectedHeap::do_collection_pause_at_safepoint() { |
|
2661 if (GC_locker::check_active_before_gc()) { |
|
2662 return; // GC is disabled (e.g. JNI GetXXXCritical operation) |
|
2663 } |
|
2664 |
2661 if (PrintHeapAtGC) { |
2665 if (PrintHeapAtGC) { |
2662 Universe::print_heap_before_gc(); |
2666 Universe::print_heap_before_gc(); |
2663 } |
2667 } |
2664 |
2668 |
2665 { |
2669 { |
2666 ResourceMark rm; |
2670 ResourceMark rm; |
|
2671 |
|
2672 // This call will decide whether this pause is an initial-mark |
|
2673 // pause. If it is, during_initial_mark_pause() will return true |
|
2674 // for the duration of this pause. |
|
2675 g1_policy()->decide_on_conc_mark_initiation(); |
2667 |
2676 |
2668 char verbose_str[128]; |
2677 char verbose_str[128]; |
2669 sprintf(verbose_str, "GC pause "); |
2678 sprintf(verbose_str, "GC pause "); |
2670 if (g1_policy()->in_young_gc_mode()) { |
2679 if (g1_policy()->in_young_gc_mode()) { |
2671 if (g1_policy()->full_young_gcs()) |
2680 if (g1_policy()->full_young_gcs()) |
2672 strcat(verbose_str, "(young)"); |
2681 strcat(verbose_str, "(young)"); |
2673 else |
2682 else |
2674 strcat(verbose_str, "(partial)"); |
2683 strcat(verbose_str, "(partial)"); |
2675 } |
2684 } |
2676 if (g1_policy()->should_initiate_conc_mark()) |
2685 if (g1_policy()->during_initial_mark_pause()) |
2677 strcat(verbose_str, " (initial-mark)"); |
2686 strcat(verbose_str, " (initial-mark)"); |
2678 |
2687 |
2679 // if PrintGCDetails is on, we'll print long statistics information |
2688 // if PrintGCDetails is on, we'll print long statistics information |
2680 // in the collector policy code, so let's not print this as the output |
2689 // in the collector policy code, so let's not print this as the output |
2681 // is messy if we do. |
2690 // is messy if we do. |
2693 increment_gc_time_stamp(); |
2702 increment_gc_time_stamp(); |
2694 |
2703 |
2695 if (g1_policy()->in_young_gc_mode()) { |
2704 if (g1_policy()->in_young_gc_mode()) { |
2696 assert(check_young_list_well_formed(), |
2705 assert(check_young_list_well_formed(), |
2697 "young list should be well formed"); |
2706 "young list should be well formed"); |
2698 } |
|
2699 |
|
2700 if (GC_locker::is_active()) { |
|
2701 return; // GC is disabled (e.g. JNI GetXXXCritical operation) |
|
2702 } |
2707 } |
2703 |
2708 |
2704 bool abandoned = false; |
2709 bool abandoned = false; |
2705 { // Call to jvmpi::post_class_unload_events must occur outside of active GC |
2710 { // Call to jvmpi::post_class_unload_events must occur outside of active GC |
2706 IsGCActiveMark x; |
2711 IsGCActiveMark x; |
2754 |
2759 |
2755 #if SCAN_ONLY_VERBOSE |
2760 #if SCAN_ONLY_VERBOSE |
2756 _young_list->print(); |
2761 _young_list->print(); |
2757 #endif // SCAN_ONLY_VERBOSE |
2762 #endif // SCAN_ONLY_VERBOSE |
2758 |
2763 |
2759 if (g1_policy()->should_initiate_conc_mark()) { |
2764 if (g1_policy()->during_initial_mark_pause()) { |
2760 concurrent_mark()->checkpointRootsInitialPre(); |
2765 concurrent_mark()->checkpointRootsInitialPre(); |
2761 } |
2766 } |
2762 save_marks(); |
2767 save_marks(); |
2763 |
2768 |
2764 // We must do this before any possible evacuation that should propagate |
2769 // We must do this before any possible evacuation that should propagate |
2856 // when they were freed. Add in the bytes evacuated. |
2861 // when they were freed. Add in the bytes evacuated. |
2857 _summary_bytes_used += g1_policy()->bytes_in_to_space(); |
2862 _summary_bytes_used += g1_policy()->bytes_in_to_space(); |
2858 } |
2863 } |
2859 |
2864 |
2860 if (g1_policy()->in_young_gc_mode() && |
2865 if (g1_policy()->in_young_gc_mode() && |
2861 g1_policy()->should_initiate_conc_mark()) { |
2866 g1_policy()->during_initial_mark_pause()) { |
2862 concurrent_mark()->checkpointRootsInitialPost(); |
2867 concurrent_mark()->checkpointRootsInitialPost(); |
2863 set_marking_started(); |
2868 set_marking_started(); |
2864 // CAUTION: after the doConcurrentMark() call below, |
2869 // CAUTION: after the doConcurrentMark() call below, |
2865 // the concurrent marking thread(s) could be running |
2870 // the concurrent marking thread(s) could be running |
2866 // concurrently with us. Make sure that anything after |
2871 // concurrently with us. Make sure that anything after |
3975 |
3980 |
3976 OopsInHeapRegionClosure *scan_root_cl; |
3981 OopsInHeapRegionClosure *scan_root_cl; |
3977 OopsInHeapRegionClosure *scan_perm_cl; |
3982 OopsInHeapRegionClosure *scan_perm_cl; |
3978 OopsInHeapRegionClosure *scan_so_cl; |
3983 OopsInHeapRegionClosure *scan_so_cl; |
3979 |
3984 |
3980 if (_g1h->g1_policy()->should_initiate_conc_mark()) { |
3985 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
3981 scan_root_cl = &scan_mark_root_cl; |
3986 scan_root_cl = &scan_mark_root_cl; |
3982 scan_perm_cl = &scan_mark_perm_cl; |
3987 scan_perm_cl = &scan_mark_perm_cl; |
3983 scan_so_cl = &scan_mark_heap_rs_cl; |
3988 scan_so_cl = &scan_mark_heap_rs_cl; |
3984 } else { |
3989 } else { |
3985 scan_root_cl = &only_scan_root_cl; |
3990 scan_root_cl = &only_scan_root_cl; |
4138 |
4143 |
4139 FilterInHeapRegionAndIntoCSClosure scan_only(this, &boc); |
4144 FilterInHeapRegionAndIntoCSClosure scan_only(this, &boc); |
4140 FilterAndMarkInHeapRegionAndIntoCSClosure scan_and_mark(this, &boc, concurrent_mark()); |
4145 FilterAndMarkInHeapRegionAndIntoCSClosure scan_and_mark(this, &boc, concurrent_mark()); |
4141 |
4146 |
4142 OopsInHeapRegionClosure *foc; |
4147 OopsInHeapRegionClosure *foc; |
4143 if (g1_policy()->should_initiate_conc_mark()) |
4148 if (g1_policy()->during_initial_mark_pause()) |
4144 foc = &scan_and_mark; |
4149 foc = &scan_and_mark; |
4145 else |
4150 else |
4146 foc = &scan_only; |
4151 foc = &scan_only; |
4147 |
4152 |
4148 HeapRegion* hr; |
4153 HeapRegion* hr; |