1 /* 2 * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_GC_G1_G1COLLECTORSTATE_HPP 26 #define SHARE_GC_G1_G1COLLECTORSTATE_HPP 27 28 #include "gc/g1/g1YCTypes.hpp" 29 #include "utilities/globalDefinitions.hpp" 30 31 // State of the G1 collection. 32 class G1CollectorState { 33 // Indicates whether we are in the phase where we do partial gcs that only contain 34 // the young generation. Not set while _in_full_gc is set. 35 bool _in_young_only_phase; 36 37 // Indicates whether we are in the last young gc before the mixed gc phase. This GC 38 // is required to keep pause time requirements. 39 bool _in_young_gc_before_mixed; 40 41 // If _initiate_conc_mark_if_possible is set at the beginning of a 42 // pause, it is a suggestion that the pause should start a marking 43 // cycle by doing the initial-mark work. However, it is possible 44 // that the concurrent marking thread is still finishing up the 45 // previous marking cycle (e.g., clearing the next marking 46 // bitmap). If that is the case we cannot start a new cycle and 47 // we'll have to wait for the concurrent marking thread to finish 48 // what it is doing. In this case we will postpone the marking cycle 49 // initiation decision for the next pause. When we eventually decide 50 // to start a cycle, we will set _in_initial_mark_gc which 51 // will stay true until the end of the initial-mark pause doing the 52 // initial-mark work. 53 volatile bool _in_initial_mark_gc; 54 55 // At the end of a pause we check the heap occupancy and we decide 56 // whether we will start a marking cycle during the next pause. If 57 // we decide that we want to do that, set this parameter. This parameter will 58 // stay set until the beginning of a subsequent pause (not necessarily 59 // the next one) when we decide that we will indeed start a marking cycle and 60 // do the initial-mark work. 61 volatile bool _initiate_conc_mark_if_possible; 62 63 // Marking or rebuilding remembered set work is in progress. Set from the end 64 // of the initial mark pause to the end of the Cleanup pause. 65 bool _mark_or_rebuild_in_progress; 66 67 // The next bitmap is currently being cleared or about to be cleared. TAMS and bitmap 68 // may be out of sync. 69 bool _clearing_next_bitmap; 70 71 // Set during a full gc pause. 72 bool _in_full_gc; 73 74 // Indicate finish of mixed gc(s) 75 bool _finish_of_mixed_gc; 76 77 public: 78 G1CollectorState() : 79 _in_young_only_phase(true), 80 _in_young_gc_before_mixed(false), 81 82 _in_initial_mark_gc(false), 83 _initiate_conc_mark_if_possible(false), 84 85 _mark_or_rebuild_in_progress(false), 86 _clearing_next_bitmap(false), 87 _in_full_gc(false), 88 _finish_of_mixed_gc(false) { } 89 90 // Phase setters 91 void set_in_young_only_phase(bool v) { _in_young_only_phase = v; } 92 93 // Pause setters 94 void set_in_young_gc_before_mixed(bool v) { _in_young_gc_before_mixed = v; } 95 void set_in_initial_mark_gc(bool v) { _in_initial_mark_gc = v; } 96 void set_in_full_gc(bool v) { _in_full_gc = v; } 97 void set_finish_of_mixed_gc(bool v) { _finish_of_mixed_gc = v; } 98 99 void set_initiate_conc_mark_if_possible(bool v) { _initiate_conc_mark_if_possible = v; } 100 101 void set_mark_or_rebuild_in_progress(bool v) { _mark_or_rebuild_in_progress = v; } 102 void set_clearing_next_bitmap(bool v) { _clearing_next_bitmap = v; } 103 104 // Phase getters 105 bool in_young_only_phase() const { return _in_young_only_phase && !_in_full_gc; } 106 bool in_mixed_phase() const { return !in_young_only_phase() && !_in_full_gc; } 107 108 // Specific pauses 109 bool in_young_gc_before_mixed() const { return _in_young_gc_before_mixed; } 110 bool in_full_gc() const { return _in_full_gc; } 111 bool in_initial_mark_gc() const { return _in_initial_mark_gc; } 112 113 bool initiate_conc_mark_if_possible() const { return _initiate_conc_mark_if_possible; } 114 115 bool mark_or_rebuild_in_progress() const { return _mark_or_rebuild_in_progress; } 116 bool clearing_next_bitmap() const { return _clearing_next_bitmap; } 117 bool finish_of_mixed_gc() const { return _finish_of_mixed_gc; } 118 119 G1YCType yc_type() const { 120 if (in_initial_mark_gc()) { 121 return InitialMark; 122 } else if (mark_or_rebuild_in_progress()) { 123 return DuringMarkOrRebuild; 124 } else if (in_young_only_phase()) { 125 return Normal; 126 } else { 127 return Mixed; 128 } 129 } 130 }; 131 132 #endif // SHARE_GC_G1_G1COLLECTORSTATE_HPP