Print this page
G1: Use SoftMaxHeapSize to guide GC heuristics


  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 public:
  75   G1CollectorState() :
  76     _in_young_only_phase(true),
  77     _in_young_gc_before_mixed(false),
  78 
  79     _in_initial_mark_gc(false),
  80     _initiate_conc_mark_if_possible(false),
  81 
  82     _mark_or_rebuild_in_progress(false),
  83     _clearing_next_bitmap(false),
  84     _in_full_gc(false) { }

  85 
  86   // Phase setters
  87   void set_in_young_only_phase(bool v) { _in_young_only_phase = v; }
  88 
  89   // Pause setters
  90   void set_in_young_gc_before_mixed(bool v) { _in_young_gc_before_mixed = v; }
  91   void set_in_initial_mark_gc(bool v) { _in_initial_mark_gc = v; }
  92   void set_in_full_gc(bool v) { _in_full_gc = v; }

  93 
  94   void set_initiate_conc_mark_if_possible(bool v) { _initiate_conc_mark_if_possible = v; }
  95 
  96   void set_mark_or_rebuild_in_progress(bool v) { _mark_or_rebuild_in_progress = v; }
  97   void set_clearing_next_bitmap(bool v) { _clearing_next_bitmap = v; }
  98 
  99   // Phase getters
 100   bool in_young_only_phase() const { return _in_young_only_phase && !_in_full_gc; }
 101   bool in_mixed_phase() const { return !in_young_only_phase() && !_in_full_gc; }
 102 
 103   // Specific pauses
 104   bool in_young_gc_before_mixed() const { return _in_young_gc_before_mixed; }
 105   bool in_full_gc() const { return _in_full_gc; }
 106   bool in_initial_mark_gc() const { return _in_initial_mark_gc; }
 107 
 108   bool initiate_conc_mark_if_possible() const { return _initiate_conc_mark_if_possible; }
 109 
 110   bool mark_or_rebuild_in_progress() const { return _mark_or_rebuild_in_progress; }
 111   bool clearing_next_bitmap() const { return _clearing_next_bitmap; }

 112 
 113   G1YCType yc_type() const {
 114     if (in_initial_mark_gc()) {
 115       return InitialMark;
 116     } else if (mark_or_rebuild_in_progress()) {
 117       return DuringMarkOrRebuild;
 118     } else if (in_young_only_phase()) {
 119       return Normal;
 120     } else {
 121       return Mixed;
 122     }
 123   }
 124 };
 125 
 126 #endif // SHARE_GC_G1_G1COLLECTORSTATE_HPP


  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