Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp @ 4837:eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
Summary: Re-enable survivors during the initial-mark pause. Afterwards, the concurrent marking threads have to scan them and mark everything reachable from them. The next GC will have to wait for the survivors to be scanned.
Reviewed-by: brutisso, johnc
| author | tonyp |
|---|---|
| date | Wed, 25 Jan 2012 12:58:23 -0500 |
| parents | 6a78aa6ac1ff |
| children | a9647476d1a4 |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
| 342 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTORPOLICY_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTORPOLICY_HPP | |
| 27 | |
| 28 #include "gc_implementation/g1/collectionSetChooser.hpp" | |
| 29 #include "gc_implementation/g1/g1MMUTracker.hpp" | |
| 30 #include "memory/collectorPolicy.hpp" | |
| 31 | |
| 342 | 32 // A G1CollectorPolicy makes policy decisions that determine the |
| 33 // characteristics of the collector. Examples include: | |
| 34 // * choice of collection set. | |
| 35 // * when to collect. | |
| 36 | |
| 37 class HeapRegion; | |
| 38 class CollectionSetChooser; | |
| 39 | |
| 40 // Yes, this is a bit unpleasant... but it saves replicating the same thing | |
| 41 // over and over again and introducing subtle problems through small typos and | |
| 42 // cutting and pasting mistakes. The macros below introduces a number | |
| 43 // sequnce into the following two classes and the methods that access it. | |
| 44 | |
| 45 #define define_num_seq(name) \ | |
| 46 private: \ | |
| 47 NumberSeq _all_##name##_times_ms; \ | |
| 48 public: \ | |
| 49 void record_##name##_time_ms(double ms) { \ | |
| 50 _all_##name##_times_ms.add(ms); \ | |
| 51 } \ | |
| 52 NumberSeq* get_##name##_seq() { \ | |
| 53 return &_all_##name##_times_ms; \ | |
| 54 } | |
| 55 | |
| 56 class MainBodySummary; | |
| 57 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
545
diff
changeset
|
58 class PauseSummary: public CHeapObj { |
| 342 | 59 define_num_seq(total) |
| 60 define_num_seq(other) | |
| 61 | |
| 62 public: | |
| 63 virtual MainBodySummary* main_body_summary() { return NULL; } | |
| 64 }; | |
| 65 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
545
diff
changeset
|
66 class MainBodySummary: public CHeapObj { |
| 342 | 67 define_num_seq(satb_drain) // optional |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
68 define_num_seq(root_region_scan_wait) |
| 342 | 69 define_num_seq(parallel) // parallel only |
| 70 define_num_seq(ext_root_scan) | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
71 define_num_seq(satb_filtering) |
| 342 | 72 define_num_seq(update_rs) |
| 73 define_num_seq(scan_rs) | |
| 74 define_num_seq(obj_copy) | |
| 75 define_num_seq(termination) // parallel only | |
| 76 define_num_seq(parallel_other) // parallel only | |
| 77 define_num_seq(mark_closure) | |
| 4023 | 78 define_num_seq(clear_ct) |
| 342 | 79 }; |
| 80 | |
| 677 | 81 class Summary: public PauseSummary, |
| 82 public MainBodySummary { | |
| 342 | 83 public: |
| 84 virtual MainBodySummary* main_body_summary() { return this; } | |
| 85 }; | |
| 86 | |
|
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
87 // There are three command line options related to the young gen size: |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
88 // NewSize, MaxNewSize and NewRatio (There is also -Xmn, but that is |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
89 // just a short form for NewSize==MaxNewSize). G1 will use its internal |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
90 // heuristics to calculate the actual young gen size, so these options |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
91 // basically only limit the range within which G1 can pick a young gen |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
92 // size. Also, these are general options taking byte sizes. G1 will |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
93 // internally work with a number of regions instead. So, some rounding |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
94 // will occur. |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
95 // |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
96 // If nothing related to the the young gen size is set on the command |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
97 // line we should allow the young gen to be between |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
98 // G1DefaultMinNewGenPercent and G1DefaultMaxNewGenPercent of the |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
99 // heap size. This means that every time the heap size changes the |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
100 // limits for the young gen size will be updated. |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
101 // |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
102 // If only -XX:NewSize is set we should use the specified value as the |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
103 // minimum size for young gen. Still using G1DefaultMaxNewGenPercent |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
104 // of the heap as maximum. |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
105 // |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
106 // If only -XX:MaxNewSize is set we should use the specified value as the |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
107 // maximum size for young gen. Still using G1DefaultMinNewGenPercent |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
108 // of the heap as minimum. |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
109 // |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
110 // If -XX:NewSize and -XX:MaxNewSize are both specified we use these values. |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
111 // No updates when the heap size changes. There is a special case when |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
112 // NewSize==MaxNewSize. This is interpreted as "fixed" and will use a |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
113 // different heuristic for calculating the collection set when we do mixed |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
114 // collection. |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
115 // |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
116 // If only -XX:NewRatio is set we should use the specified ratio of the heap |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
117 // as both min and max. This will be interpreted as "fixed" just like the |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
118 // NewSize==MaxNewSize case above. But we will update the min and max |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
119 // everytime the heap size changes. |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
120 // |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
121 // NewSize and MaxNewSize override NewRatio. So, NewRatio is ignored if it is |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
122 // combined with either NewSize or MaxNewSize. (A warning message is printed.) |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
123 class G1YoungGenSizer : public CHeapObj { |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
124 private: |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
125 enum SizerKind { |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
126 SizerDefaults, |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
127 SizerNewSizeOnly, |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
128 SizerMaxNewSizeOnly, |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
129 SizerMaxAndNewSize, |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
130 SizerNewRatio |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
131 }; |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
132 SizerKind _sizer_kind; |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
133 size_t _min_desired_young_length; |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
134 size_t _max_desired_young_length; |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
135 bool _adaptive_size; |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
136 size_t calculate_default_min_length(size_t new_number_of_heap_regions); |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
137 size_t calculate_default_max_length(size_t new_number_of_heap_regions); |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
138 |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
139 public: |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
140 G1YoungGenSizer(); |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
141 void heap_size_changed(size_t new_number_of_heap_regions); |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
142 size_t min_desired_young_length() { |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
143 return _min_desired_young_length; |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
144 } |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
145 size_t max_desired_young_length() { |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
146 return _max_desired_young_length; |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
147 } |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
148 bool adaptive_young_list_length() { |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
149 return _adaptive_size; |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
150 } |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
151 }; |
|
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
152 |
| 342 | 153 class G1CollectorPolicy: public CollectorPolicy { |
| 4013 | 154 private: |
| 342 | 155 // either equal to the number of parallel threads, if ParallelGCThreads |
| 156 // has been set, or 1 otherwise | |
| 157 int _parallel_gc_threads; | |
| 158 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
159 // The number of GC threads currently active. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
160 uintx _no_of_gc_threads; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
161 |
| 342 | 162 enum SomePrivateConstants { |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
163 NumPrevPausesForHeuristics = 10 |
| 342 | 164 }; |
| 165 | |
| 166 G1MMUTracker* _mmu_tracker; | |
| 167 | |
| 168 void initialize_flags(); | |
| 169 | |
| 170 void initialize_all() { | |
| 171 initialize_flags(); | |
| 172 initialize_size_info(); | |
| 173 initialize_perm_generation(PermGen::MarkSweepCompact); | |
| 174 } | |
| 175 | |
| 4013 | 176 CollectionSetChooser* _collectionSetChooser; |
| 342 | 177 |
| 178 double _cur_collection_start_sec; | |
| 179 size_t _cur_collection_pause_used_at_start_bytes; | |
| 180 size_t _cur_collection_pause_used_regions_at_start; | |
| 181 double _cur_collection_par_time_ms; | |
| 182 double _cur_satb_drain_time_ms; | |
| 183 double _cur_clear_ct_time_ms; | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
184 double _cur_ref_proc_time_ms; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
185 double _cur_ref_enq_time_ms; |
| 342 | 186 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
187 #ifndef PRODUCT |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
188 // Card Table Count Cache stats |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
189 double _min_clear_cc_time_ms; // min |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
190 double _max_clear_cc_time_ms; // max |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
191 double _cur_clear_cc_time_ms; // clearing time during current pause |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
192 double _cum_clear_cc_time_ms; // cummulative clearing time |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
193 jlong _num_cc_clears; // number of times the card count cache has been cleared |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
194 #endif |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
195 |
| 342 | 196 // These exclude marking times. |
| 197 TruncatedSeq* _recent_gc_times_ms; | |
| 198 | |
| 199 TruncatedSeq* _concurrent_mark_remark_times_ms; | |
| 200 TruncatedSeq* _concurrent_mark_cleanup_times_ms; | |
| 201 | |
| 677 | 202 Summary* _summary; |
| 342 | 203 |
| 204 NumberSeq* _all_pause_times_ms; | |
| 205 NumberSeq* _all_full_gc_times_ms; | |
| 206 double _stop_world_start; | |
| 207 NumberSeq* _all_stop_world_times_ms; | |
| 208 NumberSeq* _all_yield_times_ms; | |
| 209 | |
| 210 int _aux_num; | |
| 211 NumberSeq* _all_aux_times_ms; | |
| 212 double* _cur_aux_start_times_ms; | |
| 213 double* _cur_aux_times_ms; | |
| 214 bool* _cur_aux_times_set; | |
| 215 | |
| 1611 | 216 double* _par_last_gc_worker_start_times_ms; |
| 342 | 217 double* _par_last_ext_root_scan_times_ms; |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
218 double* _par_last_satb_filtering_times_ms; |
| 342 | 219 double* _par_last_update_rs_times_ms; |
| 220 double* _par_last_update_rs_processed_buffers; | |
| 221 double* _par_last_scan_rs_times_ms; | |
| 222 double* _par_last_obj_copy_times_ms; | |
| 223 double* _par_last_termination_times_ms; | |
| 1611 | 224 double* _par_last_termination_attempts; |
| 225 double* _par_last_gc_worker_end_times_ms; | |
| 2430 | 226 double* _par_last_gc_worker_times_ms; |
| 342 | 227 |
| 4023 | 228 // Each workers 'other' time i.e. the elapsed time of the parallel |
| 229 // phase of the pause minus the sum of the individual sub-phase | |
| 230 // times for a given worker thread. | |
| 231 double* _par_last_gc_worker_other_times_ms; | |
| 232 | |
| 4710 | 233 // indicates whether we are in young or mixed GC mode |
| 234 bool _gcs_are_young; | |
| 342 | 235 |
| 236 size_t _young_list_target_length; | |
| 237 size_t _young_list_fixed_length; | |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
238 size_t _prev_eden_capacity; // used for logging |
| 342 | 239 |
|
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
240 // The max number of regions we can extend the eden by while the GC |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
241 // locker is active. This should be >= _young_list_target_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
242 size_t _young_list_max_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
243 |
| 4710 | 244 bool _last_gc_was_young; |
| 342 | 245 |
| 4710 | 246 unsigned _young_pause_num; |
| 247 unsigned _mixed_pause_num; | |
| 342 | 248 |
| 249 bool _during_marking; | |
| 250 bool _in_marking_window; | |
| 251 bool _in_marking_window_im; | |
| 252 | |
| 253 SurvRateGroup* _short_lived_surv_rate_group; | |
| 254 SurvRateGroup* _survivor_surv_rate_group; | |
| 255 // add here any more surv rate groups | |
| 256 | |
| 1356 | 257 double _gc_overhead_perc; |
| 258 | |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
259 double _reserve_factor; |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
260 size_t _reserve_regions; |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
261 |
| 342 | 262 bool during_marking() { |
| 263 return _during_marking; | |
| 264 } | |
| 265 | |
| 266 private: | |
| 267 enum PredictionConstants { | |
| 268 TruncatedSeqLength = 10 | |
| 269 }; | |
| 270 | |
| 271 TruncatedSeq* _alloc_rate_ms_seq; | |
| 272 double _prev_collection_pause_end_ms; | |
| 273 | |
| 274 TruncatedSeq* _pending_card_diff_seq; | |
| 275 TruncatedSeq* _rs_length_diff_seq; | |
| 276 TruncatedSeq* _cost_per_card_ms_seq; | |
| 4710 | 277 TruncatedSeq* _young_cards_per_entry_ratio_seq; |
| 278 TruncatedSeq* _mixed_cards_per_entry_ratio_seq; | |
| 342 | 279 TruncatedSeq* _cost_per_entry_ms_seq; |
| 4710 | 280 TruncatedSeq* _mixed_cost_per_entry_ms_seq; |
| 342 | 281 TruncatedSeq* _cost_per_byte_ms_seq; |
| 282 TruncatedSeq* _constant_other_time_ms_seq; | |
| 283 TruncatedSeq* _young_other_cost_per_region_ms_seq; | |
| 284 TruncatedSeq* _non_young_other_cost_per_region_ms_seq; | |
| 285 | |
| 286 TruncatedSeq* _pending_cards_seq; | |
| 287 TruncatedSeq* _rs_lengths_seq; | |
| 288 | |
| 289 TruncatedSeq* _cost_per_byte_ms_during_cm_seq; | |
| 290 | |
| 291 TruncatedSeq* _young_gc_eff_seq; | |
| 292 | |
|
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
293 G1YoungGenSizer* _young_gen_sizer; |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
294 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
295 size_t _eden_cset_region_length; |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
296 size_t _survivor_cset_region_length; |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
297 size_t _old_cset_region_length; |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
298 |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
299 void init_cset_region_lengths(size_t eden_cset_region_length, |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
300 size_t survivor_cset_region_length); |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
301 |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
302 size_t eden_cset_region_length() { return _eden_cset_region_length; } |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
303 size_t survivor_cset_region_length() { return _survivor_cset_region_length; } |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
304 size_t old_cset_region_length() { return _old_cset_region_length; } |
| 342 | 305 |
| 306 size_t _free_regions_at_end_of_collection; | |
| 307 | |
| 308 size_t _recorded_rs_lengths; | |
| 309 size_t _max_rs_lengths; | |
| 310 | |
| 311 double _recorded_young_free_cset_time_ms; | |
| 312 double _recorded_non_young_free_cset_time_ms; | |
| 313 | |
| 314 double _sigma; | |
| 315 double _expensive_region_limit_ms; | |
| 316 | |
| 317 size_t _rs_lengths_prediction; | |
| 318 | |
| 319 size_t _known_garbage_bytes; | |
| 320 double _known_garbage_ratio; | |
| 321 | |
| 322 double sigma() { | |
| 323 return _sigma; | |
| 324 } | |
| 325 | |
| 326 // A function that prevents us putting too much stock in small sample | |
| 327 // sets. Returns a number between 2.0 and 1.0, depending on the number | |
| 328 // of samples. 5 or more samples yields one; fewer scales linearly from | |
| 329 // 2.0 at 1 sample to 1.0 at 5. | |
| 330 double confidence_factor(int samples) { | |
| 331 if (samples > 4) return 1.0; | |
| 332 else return 1.0 + sigma() * ((double)(5 - samples))/2.0; | |
| 333 } | |
| 334 | |
| 335 double get_new_neg_prediction(TruncatedSeq* seq) { | |
| 336 return seq->davg() - sigma() * seq->dsd(); | |
| 337 } | |
| 338 | |
| 339 #ifndef PRODUCT | |
| 340 bool verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group); | |
| 341 #endif // PRODUCT | |
| 342 | |
| 1111 | 343 void adjust_concurrent_refinement(double update_rs_time, |
| 344 double update_rs_processed_buffers, | |
| 345 double goal_ms); | |
| 346 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
347 uintx no_of_gc_threads() { return _no_of_gc_threads; } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
348 void set_no_of_gc_threads(uintx v) { _no_of_gc_threads = v; } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
349 |
| 342 | 350 double _pause_time_target_ms; |
| 351 double _recorded_young_cset_choice_time_ms; | |
| 352 double _recorded_non_young_cset_choice_time_ms; | |
| 353 size_t _pending_cards; | |
| 354 size_t _max_pending_cards; | |
| 355 | |
| 356 public: | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
357 // Accessors |
| 342 | 358 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
359 void set_region_eden(HeapRegion* hr, int young_index_in_cset) { |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
360 hr->set_young(); |
| 342 | 361 hr->install_surv_rate_group(_short_lived_surv_rate_group); |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
362 hr->set_young_index_in_cset(young_index_in_cset); |
| 342 | 363 } |
| 364 | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
365 void set_region_survivor(HeapRegion* hr, int young_index_in_cset) { |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
366 assert(hr->is_young() && hr->is_survivor(), "pre-condition"); |
| 342 | 367 hr->install_surv_rate_group(_survivor_surv_rate_group); |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
368 hr->set_young_index_in_cset(young_index_in_cset); |
| 342 | 369 } |
| 370 | |
| 371 #ifndef PRODUCT | |
| 372 bool verify_young_ages(); | |
| 373 #endif // PRODUCT | |
| 374 | |
| 375 double get_new_prediction(TruncatedSeq* seq) { | |
| 376 return MAX2(seq->davg() + sigma() * seq->dsd(), | |
| 377 seq->davg() * confidence_factor(seq->num())); | |
| 378 } | |
| 379 | |
| 380 void record_max_rs_lengths(size_t rs_lengths) { | |
| 381 _max_rs_lengths = rs_lengths; | |
| 382 } | |
| 383 | |
| 384 size_t predict_pending_card_diff() { | |
| 385 double prediction = get_new_neg_prediction(_pending_card_diff_seq); | |
| 4710 | 386 if (prediction < 0.00001) { |
| 342 | 387 return 0; |
| 4710 | 388 } else { |
| 342 | 389 return (size_t) prediction; |
| 4710 | 390 } |
| 342 | 391 } |
| 392 | |
| 393 size_t predict_pending_cards() { | |
| 394 size_t max_pending_card_num = _g1->max_pending_card_num(); | |
| 395 size_t diff = predict_pending_card_diff(); | |
| 396 size_t prediction; | |
| 4710 | 397 if (diff > max_pending_card_num) { |
| 342 | 398 prediction = max_pending_card_num; |
| 4710 | 399 } else { |
| 342 | 400 prediction = max_pending_card_num - diff; |
| 4710 | 401 } |
| 342 | 402 |
| 403 return prediction; | |
| 404 } | |
| 405 | |
| 406 size_t predict_rs_length_diff() { | |
| 407 return (size_t) get_new_prediction(_rs_length_diff_seq); | |
| 408 } | |
| 409 | |
| 410 double predict_alloc_rate_ms() { | |
| 411 return get_new_prediction(_alloc_rate_ms_seq); | |
| 412 } | |
| 413 | |
| 414 double predict_cost_per_card_ms() { | |
| 415 return get_new_prediction(_cost_per_card_ms_seq); | |
| 416 } | |
| 417 | |
| 418 double predict_rs_update_time_ms(size_t pending_cards) { | |
| 419 return (double) pending_cards * predict_cost_per_card_ms(); | |
| 420 } | |
| 421 | |
| 4710 | 422 double predict_young_cards_per_entry_ratio() { |
| 423 return get_new_prediction(_young_cards_per_entry_ratio_seq); | |
| 342 | 424 } |
| 425 | |
| 4710 | 426 double predict_mixed_cards_per_entry_ratio() { |
| 427 if (_mixed_cards_per_entry_ratio_seq->num() < 2) { | |
| 428 return predict_young_cards_per_entry_ratio(); | |
| 429 } else { | |
| 430 return get_new_prediction(_mixed_cards_per_entry_ratio_seq); | |
| 431 } | |
| 342 | 432 } |
| 433 | |
| 434 size_t predict_young_card_num(size_t rs_length) { | |
| 435 return (size_t) ((double) rs_length * | |
| 4710 | 436 predict_young_cards_per_entry_ratio()); |
| 342 | 437 } |
| 438 | |
| 439 size_t predict_non_young_card_num(size_t rs_length) { | |
| 440 return (size_t) ((double) rs_length * | |
| 4710 | 441 predict_mixed_cards_per_entry_ratio()); |
| 342 | 442 } |
| 443 | |
| 444 double predict_rs_scan_time_ms(size_t card_num) { | |
| 4710 | 445 if (gcs_are_young()) { |
| 342 | 446 return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq); |
| 4710 | 447 } else { |
| 448 return predict_mixed_rs_scan_time_ms(card_num); | |
| 449 } | |
| 342 | 450 } |
| 451 | |
| 4710 | 452 double predict_mixed_rs_scan_time_ms(size_t card_num) { |
| 453 if (_mixed_cost_per_entry_ms_seq->num() < 3) { | |
| 342 | 454 return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq); |
| 4710 | 455 } else { |
| 456 return (double) (card_num * | |
| 457 get_new_prediction(_mixed_cost_per_entry_ms_seq)); | |
| 458 } | |
| 342 | 459 } |
| 460 | |
| 461 double predict_object_copy_time_ms_during_cm(size_t bytes_to_copy) { | |
| 4710 | 462 if (_cost_per_byte_ms_during_cm_seq->num() < 3) { |
| 463 return (1.1 * (double) bytes_to_copy) * | |
| 464 get_new_prediction(_cost_per_byte_ms_seq); | |
| 465 } else { | |
| 342 | 466 return (double) bytes_to_copy * |
| 4710 | 467 get_new_prediction(_cost_per_byte_ms_during_cm_seq); |
| 468 } | |
| 342 | 469 } |
| 470 | |
| 471 double predict_object_copy_time_ms(size_t bytes_to_copy) { | |
| 4710 | 472 if (_in_marking_window && !_in_marking_window_im) { |
| 342 | 473 return predict_object_copy_time_ms_during_cm(bytes_to_copy); |
| 4710 | 474 } else { |
| 342 | 475 return (double) bytes_to_copy * |
| 4710 | 476 get_new_prediction(_cost_per_byte_ms_seq); |
| 477 } | |
| 342 | 478 } |
| 479 | |
| 480 double predict_constant_other_time_ms() { | |
| 481 return get_new_prediction(_constant_other_time_ms_seq); | |
| 482 } | |
| 483 | |
| 484 double predict_young_other_time_ms(size_t young_num) { | |
| 4710 | 485 return (double) young_num * |
| 486 get_new_prediction(_young_other_cost_per_region_ms_seq); | |
| 342 | 487 } |
| 488 | |
| 489 double predict_non_young_other_time_ms(size_t non_young_num) { | |
| 4710 | 490 return (double) non_young_num * |
| 491 get_new_prediction(_non_young_other_cost_per_region_ms_seq); | |
| 342 | 492 } |
| 493 | |
| 494 void check_if_region_is_too_expensive(double predicted_time_ms); | |
| 495 | |
| 496 double predict_young_collection_elapsed_time_ms(size_t adjustment); | |
| 497 double predict_base_elapsed_time_ms(size_t pending_cards); | |
| 498 double predict_base_elapsed_time_ms(size_t pending_cards, | |
| 499 size_t scanned_cards); | |
| 500 size_t predict_bytes_to_copy(HeapRegion* hr); | |
| 501 double predict_region_elapsed_time_ms(HeapRegion* hr, bool young); | |
| 502 | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
503 void set_recorded_rs_lengths(size_t rs_lengths); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
504 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
505 size_t cset_region_length() { return young_cset_region_length() + |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
506 old_cset_region_length(); } |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
507 size_t young_cset_region_length() { return eden_cset_region_length() + |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
508 survivor_cset_region_length(); } |
| 342 | 509 |
| 510 void record_young_free_cset_time_ms(double time_ms) { | |
| 511 _recorded_young_free_cset_time_ms = time_ms; | |
| 512 } | |
| 513 | |
| 514 void record_non_young_free_cset_time_ms(double time_ms) { | |
| 515 _recorded_non_young_free_cset_time_ms = time_ms; | |
| 516 } | |
| 517 | |
| 518 double predict_young_gc_eff() { | |
| 519 return get_new_neg_prediction(_young_gc_eff_seq); | |
| 520 } | |
| 521 | |
| 545 | 522 double predict_survivor_regions_evac_time(); |
| 523 | |
| 342 | 524 void cset_regions_freed() { |
| 4710 | 525 bool propagate = _last_gc_was_young && !_in_marking_window; |
| 342 | 526 _short_lived_surv_rate_group->all_surviving_words_recorded(propagate); |
| 527 _survivor_surv_rate_group->all_surviving_words_recorded(propagate); | |
| 528 // also call it on any more surv rate groups | |
| 529 } | |
| 530 | |
| 531 void set_known_garbage_bytes(size_t known_garbage_bytes) { | |
| 532 _known_garbage_bytes = known_garbage_bytes; | |
| 533 size_t heap_bytes = _g1->capacity(); | |
| 534 _known_garbage_ratio = (double) _known_garbage_bytes / (double) heap_bytes; | |
| 535 } | |
| 536 | |
| 537 void decrease_known_garbage_bytes(size_t known_garbage_bytes) { | |
| 538 guarantee( _known_garbage_bytes >= known_garbage_bytes, "invariant" ); | |
| 539 | |
| 540 _known_garbage_bytes -= known_garbage_bytes; | |
| 541 size_t heap_bytes = _g1->capacity(); | |
| 542 _known_garbage_ratio = (double) _known_garbage_bytes / (double) heap_bytes; | |
| 543 } | |
| 544 | |
| 545 G1MMUTracker* mmu_tracker() { | |
| 546 return _mmu_tracker; | |
| 547 } | |
| 548 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
549 double max_pause_time_ms() { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
550 return _mmu_tracker->max_gc_time() * 1000.0; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
551 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
552 |
| 342 | 553 double predict_remark_time_ms() { |
| 554 return get_new_prediction(_concurrent_mark_remark_times_ms); | |
| 555 } | |
| 556 | |
| 557 double predict_cleanup_time_ms() { | |
| 558 return get_new_prediction(_concurrent_mark_cleanup_times_ms); | |
| 559 } | |
| 560 | |
| 561 // Returns an estimate of the survival rate of the region at yg-age | |
| 562 // "yg_age". | |
| 545 | 563 double predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) { |
| 564 TruncatedSeq* seq = surv_rate_group->get_seq(age); | |
| 342 | 565 if (seq->num() == 0) |
| 566 gclog_or_tty->print("BARF! age is %d", age); | |
| 567 guarantee( seq->num() > 0, "invariant" ); | |
| 568 double pred = get_new_prediction(seq); | |
| 569 if (pred > 1.0) | |
| 570 pred = 1.0; | |
| 571 return pred; | |
| 572 } | |
| 573 | |
| 545 | 574 double predict_yg_surv_rate(int age) { |
| 575 return predict_yg_surv_rate(age, _short_lived_surv_rate_group); | |
| 576 } | |
| 577 | |
| 342 | 578 double accum_yg_surv_rate_pred(int age) { |
| 579 return _short_lived_surv_rate_group->accum_surv_rate_pred(age); | |
| 580 } | |
| 581 | |
| 4013 | 582 private: |
| 1611 | 583 void print_stats(int level, const char* str, double value); |
| 584 void print_stats(int level, const char* str, int value); | |
| 585 | |
| 2430 | 586 void print_par_stats(int level, const char* str, double* data); |
| 587 void print_par_sizes(int level, const char* str, double* data); | |
| 342 | 588 |
| 589 void check_other_times(int level, | |
| 590 NumberSeq* other_times_ms, | |
| 591 NumberSeq* calc_other_times_ms) const; | |
| 592 | |
| 593 void print_summary (PauseSummary* stats) const; | |
| 594 | |
| 595 void print_summary (int level, const char* str, NumberSeq* seq) const; | |
| 596 void print_summary_sd (int level, const char* str, NumberSeq* seq) const; | |
| 597 | |
| 598 double avg_value (double* data); | |
| 599 double max_value (double* data); | |
| 600 double sum_of_values (double* data); | |
| 601 double max_sum (double* data1, double* data2); | |
| 602 | |
| 603 double _last_pause_time_ms; | |
| 604 | |
| 605 size_t _bytes_in_collection_set_before_gc; | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
606 size_t _bytes_copied_during_gc; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
607 |
| 342 | 608 // Used to count used bytes in CS. |
| 609 friend class CountCSClosure; | |
| 610 | |
| 611 // Statistics kept per GC stoppage, pause or full. | |
| 612 TruncatedSeq* _recent_prev_end_times_for_all_gcs_sec; | |
| 613 | |
| 614 // Add a new GC of the given duration and end time to the record. | |
| 615 void update_recent_gc_times(double end_time_sec, double elapsed_ms); | |
| 616 | |
| 617 // The head of the list (via "next_in_collection_set()") representing the | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
618 // current collection set. Set from the incrementally built collection |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
619 // set at the start of the pause. |
| 342 | 620 HeapRegion* _collection_set; |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
621 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
622 // The number of bytes in the collection set before the pause. Set from |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
623 // the incrementally built collection set at the start of an evacuation |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
624 // pause. |
| 342 | 625 size_t _collection_set_bytes_used_before; |
| 626 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
627 // The associated information that is maintained while the incremental |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
628 // collection set is being built with young regions. Used to populate |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
629 // the recorded info for the evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
630 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
631 enum CSetBuildType { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
632 Active, // We are actively building the collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
633 Inactive // We are not actively building the collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
634 }; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
635 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
636 CSetBuildType _inc_cset_build_state; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
637 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
638 // The head of the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
639 HeapRegion* _inc_cset_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
640 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
641 // The tail of the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
642 HeapRegion* _inc_cset_tail; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
643 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
644 // The number of bytes in the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
645 // Used to set _collection_set_bytes_used_before at the start of |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
646 // an evacuation pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
647 size_t _inc_cset_bytes_used_before; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
648 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
649 // Used to record the highest end of heap region in collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
650 HeapWord* _inc_cset_max_finger; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
651 |
|
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
652 // The RSet lengths recorded for regions in the CSet. It is updated |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
653 // by the thread that adds a new region to the CSet. We assume that |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
654 // only one thread can be allocating a new CSet region (currently, |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
655 // it does so after taking the Heap_lock) hence no need to |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
656 // synchronize updates to this field. |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
657 size_t _inc_cset_recorded_rs_lengths; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
658 |
|
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
659 // A concurrent refinement thread periodcially samples the young |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
660 // region RSets and needs to update _inc_cset_recorded_rs_lengths as |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
661 // the RSets grow. Instead of having to syncronize updates to that |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
662 // field we accumulate them in this field and add it to |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
663 // _inc_cset_recorded_rs_lengths_diffs at the start of a GC. |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
664 ssize_t _inc_cset_recorded_rs_lengths_diffs; |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
665 |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
666 // The predicted elapsed time it will take to collect the regions in |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
667 // the CSet. This is updated by the thread that adds a new region to |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
668 // the CSet. See the comment for _inc_cset_recorded_rs_lengths about |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
669 // MT-safety assumptions. |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
670 double _inc_cset_predicted_elapsed_time_ms; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
671 |
|
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
672 // See the comment for _inc_cset_recorded_rs_lengths_diffs. |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
673 double _inc_cset_predicted_elapsed_time_ms_diffs; |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
674 |
| 342 | 675 // Stash a pointer to the g1 heap. |
| 676 G1CollectedHeap* _g1; | |
| 677 | |
| 678 // The ratio of gc time to elapsed time, computed over recent pauses. | |
| 679 double _recent_avg_pause_time_ratio; | |
| 680 | |
| 681 double recent_avg_pause_time_ratio() { | |
| 682 return _recent_avg_pause_time_ratio; | |
| 683 } | |
| 684 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
685 // At the end of a pause we check the heap occupancy and we decide |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
686 // whether we will start a marking cycle during the next pause. If |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
687 // we decide that we want to do that, we will set this parameter to |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
688 // true. So, this parameter will stay true between the end of a |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
689 // pause and the beginning of a subsequent pause (not necessarily |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
690 // the next one, see the comments on the next field) when we decide |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
691 // that we will indeed start a marking cycle and do the initial-mark |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
692 // work. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
693 volatile bool _initiate_conc_mark_if_possible; |
| 342 | 694 |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
695 // If initiate_conc_mark_if_possible() is set at the beginning of a |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
696 // pause, it is a suggestion that the pause should start a marking |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
697 // cycle by doing the initial-mark work. However, it is possible |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
698 // that the concurrent marking thread is still finishing up the |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
699 // previous marking cycle (e.g., clearing the next marking |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
700 // bitmap). If that is the case we cannot start a new cycle and |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
701 // we'll have to wait for the concurrent marking thread to finish |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
702 // what it is doing. In this case we will postpone the marking cycle |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
703 // initiation decision for the next pause. When we eventually decide |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
704 // to start a cycle, we will set _during_initial_mark_pause which |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
705 // will stay true until the end of the initial-mark pause and it's |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
706 // the condition that indicates that a pause is doing the |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
707 // initial-mark work. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
708 volatile bool _during_initial_mark_pause; |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
709 |
| 4710 | 710 bool _should_revert_to_young_gcs; |
| 711 bool _last_young_gc; | |
| 342 | 712 |
| 713 // This set of variables tracks the collector efficiency, in order to | |
| 714 // determine whether we should initiate a new marking. | |
| 715 double _cur_mark_stop_world_time_ms; | |
| 716 double _mark_remark_start_sec; | |
| 717 double _mark_cleanup_start_sec; | |
| 718 double _mark_closure_time_ms; | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
719 double _root_region_scan_wait_time_ms; |
| 342 | 720 |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
721 // Update the young list target length either by setting it to the |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
722 // desired fixed value or by calculating it using G1's pause |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
723 // prediction model. If no rs_lengths parameter is passed, predict |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
724 // the RS lengths using the prediction model, otherwise use the |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
725 // given rs_lengths as the prediction. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
726 void update_young_list_target_length(size_t rs_lengths = (size_t) -1); |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
727 |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
728 // Calculate and return the minimum desired young list target |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
729 // length. This is the minimum desired young list length according |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
730 // to the user's inputs. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
731 size_t calculate_young_list_desired_min_length(size_t base_min_length); |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
732 |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
733 // Calculate and return the maximum desired young list target |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
734 // length. This is the maximum desired young list length according |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
735 // to the user's inputs. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
736 size_t calculate_young_list_desired_max_length(); |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
737 |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
738 // Calculate and return the maximum young list target length that |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
739 // can fit into the pause time goal. The parameters are: rs_lengths |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
740 // represent the prediction of how large the young RSet lengths will |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
741 // be, base_min_length is the alreay existing number of regions in |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
742 // the young list, min_length and max_length are the desired min and |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
743 // max young list length according to the user's inputs. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
744 size_t calculate_young_list_target_length(size_t rs_lengths, |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
745 size_t base_min_length, |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
746 size_t desired_min_length, |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
747 size_t desired_max_length); |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
748 |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
749 // Check whether a given young length (young_length) fits into the |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
750 // given target pause time and whether the prediction for the amount |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
751 // of objects to be copied for the given length will fit into the |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
752 // given free space (expressed by base_free_regions). It is used by |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
753 // calculate_young_list_target_length(). |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
754 bool predict_will_fit(size_t young_length, double base_time_ms, |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
755 size_t base_free_regions, double target_pause_time_ms); |
| 342 | 756 |
| 4013 | 757 // Count the number of bytes used in the CS. |
| 758 void count_CS_bytes_used(); | |
| 759 | |
| 342 | 760 public: |
| 761 | |
| 762 G1CollectorPolicy(); | |
| 763 | |
| 764 virtual G1CollectorPolicy* as_g1_policy() { return this; } | |
| 765 | |
| 766 virtual CollectorPolicy::Name kind() { | |
| 767 return CollectorPolicy::G1CollectorPolicyKind; | |
| 768 } | |
| 769 | |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
770 // Check the current value of the young list RSet lengths and |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
771 // compare it against the last prediction. If the current value is |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
772 // higher, recalculate the young list target length prediction. |
|
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
773 void revise_young_list_target_length_if_necessary(); |
| 342 | 774 |
| 775 size_t bytes_in_collection_set() { | |
| 776 return _bytes_in_collection_set_before_gc; | |
| 777 } | |
| 778 | |
| 779 unsigned calc_gc_alloc_time_stamp() { | |
| 780 return _all_pause_times_ms->num() + 1; | |
| 781 } | |
| 782 | |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
783 // This should be called after the heap is resized. |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
784 void record_new_heap_size(size_t new_number_of_regions); |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
785 |
| 4013 | 786 void init(); |
| 342 | 787 |
| 545 | 788 // Create jstat counters for the policy. |
| 789 virtual void initialize_gc_policy_counters(); | |
| 790 | |
| 342 | 791 virtual HeapWord* mem_allocate_work(size_t size, |
| 792 bool is_tlab, | |
| 793 bool* gc_overhead_limit_was_exceeded); | |
| 794 | |
| 795 // This method controls how a collector handles one or more | |
| 796 // of its generations being fully allocated. | |
| 797 virtual HeapWord* satisfy_failed_allocation(size_t size, | |
| 798 bool is_tlab); | |
| 799 | |
| 800 BarrierSet::Name barrier_set_name() { return BarrierSet::G1SATBCTLogging; } | |
| 801 | |
| 802 GenRemSet::Name rem_set_name() { return GenRemSet::CardTable; } | |
| 803 | |
|
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
804 bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0); |
|
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
805 |
| 342 | 806 // Update the heuristic info to record a collection pause of the given |
| 807 // start time, where the given number of bytes were used at the start. | |
| 808 // This may involve changing the desired size of a collection set. | |
| 809 | |
| 4013 | 810 void record_stop_world_start(); |
| 342 | 811 |
| 4013 | 812 void record_collection_pause_start(double start_time_sec, size_t start_used); |
| 342 | 813 |
| 814 // Must currently be called while the world is stopped. | |
|
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
815 void record_concurrent_mark_init_end(double |
| 342 | 816 mark_init_elapsed_time_ms); |
| 817 | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
818 void record_mark_closure_time(double mark_closure_time_ms) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
819 _mark_closure_time_ms = mark_closure_time_ms; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
820 } |
| 342 | 821 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
822 void record_root_region_scan_wait_time(double time_ms) { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
823 _root_region_scan_wait_time_ms = time_ms; |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
824 } |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
825 |
| 4013 | 826 void record_concurrent_mark_remark_start(); |
| 827 void record_concurrent_mark_remark_end(); | |
| 342 | 828 |
| 4013 | 829 void record_concurrent_mark_cleanup_start(); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
830 void record_concurrent_mark_cleanup_end(int no_of_gc_threads); |
| 4013 | 831 void record_concurrent_mark_cleanup_completed(); |
| 342 | 832 |
| 4013 | 833 void record_concurrent_pause(); |
| 834 void record_concurrent_pause_end(); | |
| 342 | 835 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
836 void record_collection_pause_end(int no_of_gc_threads); |
|
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
837 void print_heap_transition(); |
| 342 | 838 |
| 839 // Record the fact that a full collection occurred. | |
| 4013 | 840 void record_full_collection_start(); |
| 841 void record_full_collection_end(); | |
| 342 | 842 |
| 1611 | 843 void record_gc_worker_start_time(int worker_i, double ms) { |
| 844 _par_last_gc_worker_start_times_ms[worker_i] = ms; | |
| 845 } | |
| 846 | |
| 342 | 847 void record_ext_root_scan_time(int worker_i, double ms) { |
| 848 _par_last_ext_root_scan_times_ms[worker_i] = ms; | |
| 849 } | |
| 850 | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
851 void record_satb_filtering_time(int worker_i, double ms) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
852 _par_last_satb_filtering_times_ms[worker_i] = ms; |
| 342 | 853 } |
| 854 | |
| 855 void record_satb_drain_time(double ms) { | |
| 4023 | 856 assert(_g1->mark_in_progress(), "shouldn't be here otherwise"); |
| 342 | 857 _cur_satb_drain_time_ms = ms; |
| 858 } | |
| 859 | |
| 860 void record_update_rs_time(int thread, double ms) { | |
| 861 _par_last_update_rs_times_ms[thread] = ms; | |
| 862 } | |
| 863 | |
| 864 void record_update_rs_processed_buffers (int thread, | |
| 865 double processed_buffers) { | |
| 866 _par_last_update_rs_processed_buffers[thread] = processed_buffers; | |
| 867 } | |
| 868 | |
| 869 void record_scan_rs_time(int thread, double ms) { | |
| 870 _par_last_scan_rs_times_ms[thread] = ms; | |
| 871 } | |
| 872 | |
| 873 void reset_obj_copy_time(int thread) { | |
| 874 _par_last_obj_copy_times_ms[thread] = 0.0; | |
| 875 } | |
| 876 | |
| 877 void reset_obj_copy_time() { | |
| 878 reset_obj_copy_time(0); | |
| 879 } | |
| 880 | |
| 881 void record_obj_copy_time(int thread, double ms) { | |
| 882 _par_last_obj_copy_times_ms[thread] += ms; | |
| 883 } | |
| 884 | |
| 1611 | 885 void record_termination(int thread, double ms, size_t attempts) { |
| 886 _par_last_termination_times_ms[thread] = ms; | |
| 887 _par_last_termination_attempts[thread] = (double) attempts; | |
| 342 | 888 } |
| 889 | |
| 1611 | 890 void record_gc_worker_end_time(int worker_i, double ms) { |
| 891 _par_last_gc_worker_end_times_ms[worker_i] = ms; | |
| 342 | 892 } |
| 893 | |
|
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
549
diff
changeset
|
894 void record_pause_time_ms(double ms) { |
| 342 | 895 _last_pause_time_ms = ms; |
| 896 } | |
| 897 | |
| 898 void record_clear_ct_time(double ms) { | |
| 899 _cur_clear_ct_time_ms = ms; | |
| 900 } | |
| 901 | |
| 902 void record_par_time(double ms) { | |
| 903 _cur_collection_par_time_ms = ms; | |
| 904 } | |
| 905 | |
| 906 void record_aux_start_time(int i) { | |
| 907 guarantee(i < _aux_num, "should be within range"); | |
| 908 _cur_aux_start_times_ms[i] = os::elapsedTime() * 1000.0; | |
| 909 } | |
| 910 | |
| 911 void record_aux_end_time(int i) { | |
| 912 guarantee(i < _aux_num, "should be within range"); | |
| 913 double ms = os::elapsedTime() * 1000.0 - _cur_aux_start_times_ms[i]; | |
| 914 _cur_aux_times_set[i] = true; | |
| 915 _cur_aux_times_ms[i] += ms; | |
| 916 } | |
| 917 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
918 void record_ref_proc_time(double ms) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
919 _cur_ref_proc_time_ms = ms; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
920 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
921 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
922 void record_ref_enq_time(double ms) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
923 _cur_ref_enq_time_ms = ms; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
924 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3920
diff
changeset
|
925 |
|
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
926 #ifndef PRODUCT |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
927 void record_cc_clear_time(double ms) { |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
928 if (_min_clear_cc_time_ms < 0.0 || ms <= _min_clear_cc_time_ms) |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
929 _min_clear_cc_time_ms = ms; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
930 if (_max_clear_cc_time_ms < 0.0 || ms >= _max_clear_cc_time_ms) |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
931 _max_clear_cc_time_ms = ms; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
932 _cur_clear_cc_time_ms = ms; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
933 _cum_clear_cc_time_ms += ms; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
934 _num_cc_clears++; |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
935 } |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
936 #endif |
|
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
838
diff
changeset
|
937 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
938 // Record how much space we copied during a GC. This is typically |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
939 // called when a GC alloc region is being retired. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
940 void record_bytes_copied_during_gc(size_t bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
941 _bytes_copied_during_gc += bytes; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
942 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
943 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
944 // The amount of space we copied during a GC. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
945 size_t bytes_copied_during_gc() { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
946 return _bytes_copied_during_gc; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
947 } |
| 342 | 948 |
| 949 // Choose a new collection set. Marks the chosen regions as being | |
| 950 // "in_collection_set", and links them together. The head and number of | |
| 951 // the collection set are available via access methods. | |
| 4013 | 952 void choose_collection_set(double target_pause_time_ms); |
| 342 | 953 |
| 954 // The head of the list (via "next_in_collection_set()") representing the | |
| 955 // current collection set. | |
| 956 HeapRegion* collection_set() { return _collection_set; } | |
| 957 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
958 void clear_collection_set() { _collection_set = NULL; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
959 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
960 // Add old region "hr" to the CSet. |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4023
diff
changeset
|
961 void add_old_region_to_cset(HeapRegion* hr); |
| 342 | 962 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
963 // Incremental CSet Support |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
964 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
965 // The head of the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
966 HeapRegion* inc_cset_head() { return _inc_cset_head; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
967 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
968 // The tail of the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
969 HeapRegion* inc_set_tail() { return _inc_cset_tail; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
970 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
971 // Initialize incremental collection set info. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
972 void start_incremental_cset_building(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
973 |
|
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
974 // Perform any final calculations on the incremental CSet fields |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
975 // before we can use them. |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
976 void finalize_incremental_cset_building(); |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
977 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
978 void clear_incremental_cset() { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
979 _inc_cset_head = NULL; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
980 _inc_cset_tail = NULL; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
981 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
982 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
983 // Stop adding regions to the incremental collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
984 void stop_incremental_cset_building() { _inc_cset_build_state = Inactive; } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
985 |
|
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
986 // Add information about hr to the aggregated information for the |
|
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
987 // incrementally built collection set. |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
988 void add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
989 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
990 // Update information about hr in the aggregated information for |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
991 // the incrementally built collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
992 void update_incremental_cset_info(HeapRegion* hr, size_t new_rs_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
993 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
994 private: |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
995 // Update the incremental cset information when adding a region |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
996 // (should not be called directly). |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
997 void add_region_to_incremental_cset_common(HeapRegion* hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
998 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
999 public: |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1000 // Add hr to the LHS of the incremental collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1001 void add_region_to_incremental_cset_lhs(HeapRegion* hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1002 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1003 // Add hr to the RHS of the incremental collection set. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1004 void add_region_to_incremental_cset_rhs(HeapRegion* hr); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1005 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1006 #ifndef PRODUCT |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1007 void print_collection_set(HeapRegion* list_head, outputStream* st); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1008 #endif // !PRODUCT |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1359
diff
changeset
|
1009 |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1010 bool initiate_conc_mark_if_possible() { return _initiate_conc_mark_if_possible; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1011 void set_initiate_conc_mark_if_possible() { _initiate_conc_mark_if_possible = true; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1012 void clear_initiate_conc_mark_if_possible() { _initiate_conc_mark_if_possible = false; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1013 |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1014 bool during_initial_mark_pause() { return _during_initial_mark_pause; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1015 void set_during_initial_mark_pause() { _during_initial_mark_pause = true; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1016 void clear_during_initial_mark_pause(){ _during_initial_mark_pause = false; } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1017 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1018 // This sets the initiate_conc_mark_if_possible() flag to start a |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1019 // new cycle, as long as we are not already in one. It's best if it |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1020 // is called during a safepoint when the test whether a cycle is in |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1021 // progress or not is stable. |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1022 bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1023 |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1024 // This is called at the very beginning of an evacuation pause (it |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1025 // has to be the first thing that the pause does). If |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1026 // initiate_conc_mark_if_possible() is true, and the concurrent |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1027 // marking thread has completed its work during the previous cycle, |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1028 // it will set during_initial_mark_pause() to so that the pause does |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1029 // the initial-mark work and start a marking cycle. |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1030 void decide_on_conc_mark_initiation(); |
| 342 | 1031 |
| 1032 // If an expansion would be appropriate, because recent GC overhead had | |
| 1033 // exceeded the desired limit, return an amount to expand by. | |
| 4013 | 1034 size_t expansion_amount(); |
| 342 | 1035 |
| 1036 #ifndef PRODUCT | |
| 1037 // Check any appropriate marked bytes info, asserting false if | |
| 1038 // something's wrong, else returning "true". | |
| 4013 | 1039 bool assertMarkedBytesDataOK(); |
| 342 | 1040 #endif |
| 1041 | |
| 1042 // Print tracing information. | |
| 1043 void print_tracing_info() const; | |
| 1044 | |
| 1045 // Print stats on young survival ratio | |
| 1046 void print_yg_surv_rate_info() const; | |
| 1047 | |
| 545 | 1048 void finished_recalculating_age_indexes(bool is_survivors) { |
| 1049 if (is_survivors) { | |
| 1050 _survivor_surv_rate_group->finished_recalculating_age_indexes(); | |
| 1051 } else { | |
| 1052 _short_lived_surv_rate_group->finished_recalculating_age_indexes(); | |
| 1053 } | |
| 342 | 1054 // do that for any other surv rate groups |
| 1055 } | |
| 1056 | |
| 1973 | 1057 bool is_young_list_full() { |
| 1058 size_t young_list_length = _g1->young_list()->length(); | |
|
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1059 size_t young_list_target_length = _young_list_target_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1060 return young_list_length >= young_list_target_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1061 } |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1062 |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1063 bool can_expand_young_list() { |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1064 size_t young_list_length = _g1->young_list()->length(); |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1065 size_t young_list_max_length = _young_list_max_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1066 return young_list_length < young_list_max_length; |
|
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1067 } |
| 1973 | 1068 |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1069 size_t young_list_max_length() { |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1070 return _young_list_max_length; |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1071 } |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1072 |
| 4710 | 1073 bool gcs_are_young() { |
| 1074 return _gcs_are_young; | |
| 342 | 1075 } |
| 4710 | 1076 void set_gcs_are_young(bool gcs_are_young) { |
| 1077 _gcs_are_young = gcs_are_young; | |
| 342 | 1078 } |
| 1079 | |
| 1080 bool adaptive_young_list_length() { | |
|
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4727
diff
changeset
|
1081 return _young_gen_sizer->adaptive_young_list_length(); |
| 342 | 1082 } |
| 1083 | |
| 1084 inline double get_gc_eff_factor() { | |
| 1085 double ratio = _known_garbage_ratio; | |
| 1086 | |
| 1087 double square = ratio * ratio; | |
| 1088 // square = square * square; | |
| 1089 double ret = square * 9.0 + 1.0; | |
| 1090 #if 0 | |
| 1091 gclog_or_tty->print_cr("ratio = %1.2lf, ret = %1.2lf", ratio, ret); | |
| 1092 #endif // 0 | |
| 1093 guarantee(0.0 <= ret && ret < 10.0, "invariant!"); | |
| 1094 return ret; | |
| 1095 } | |
| 1096 | |
| 4013 | 1097 private: |
| 342 | 1098 // |
| 1099 // Survivor regions policy. | |
| 1100 // | |
| 1101 | |
| 1102 // Current tenuring threshold, set to 0 if the collector reaches the | |
| 1103 // maximum amount of suvivors regions. | |
| 1104 int _tenuring_threshold; | |
| 1105 | |
| 545 | 1106 // The limit on the number of regions allocated for survivors. |
| 1107 size_t _max_survivor_regions; | |
| 1108 | |
|
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1109 // For reporting purposes. |
|
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1110 size_t _eden_bytes_before_gc; |
|
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1111 size_t _survivor_bytes_before_gc; |
|
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1112 size_t _capacity_before_gc; |
|
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1113 |
| 545 | 1114 // The amount of survor regions after a collection. |
| 1115 size_t _recorded_survivor_regions; | |
| 1116 // List of survivor regions. | |
| 1117 HeapRegion* _recorded_survivor_head; | |
| 1118 HeapRegion* _recorded_survivor_tail; | |
| 1119 | |
| 1120 ageTable _survivors_age_table; | |
| 1121 | |
| 342 | 1122 public: |
| 1123 | |
| 1124 inline GCAllocPurpose | |
| 1125 evacuation_destination(HeapRegion* src_region, int age, size_t word_sz) { | |
| 1126 if (age < _tenuring_threshold && src_region->is_young()) { | |
| 1127 return GCAllocForSurvived; | |
| 1128 } else { | |
| 1129 return GCAllocForTenured; | |
| 1130 } | |
| 1131 } | |
| 1132 | |
| 1133 inline bool track_object_age(GCAllocPurpose purpose) { | |
| 1134 return purpose == GCAllocForSurvived; | |
| 1135 } | |
| 1136 | |
| 545 | 1137 static const size_t REGIONS_UNLIMITED = ~(size_t)0; |
| 1138 | |
| 1139 size_t max_regions(int purpose); | |
| 342 | 1140 |
| 1141 // The limit on regions for a particular purpose is reached. | |
| 1142 void note_alloc_region_limit_reached(int purpose) { | |
| 1143 if (purpose == GCAllocForSurvived) { | |
| 1144 _tenuring_threshold = 0; | |
| 1145 } | |
| 1146 } | |
| 1147 | |
| 1148 void note_start_adding_survivor_regions() { | |
| 1149 _survivor_surv_rate_group->start_adding_regions(); | |
| 1150 } | |
| 1151 | |
| 1152 void note_stop_adding_survivor_regions() { | |
| 1153 _survivor_surv_rate_group->stop_adding_regions(); | |
| 1154 } | |
| 545 | 1155 |
| 1156 void record_survivor_regions(size_t regions, | |
| 1157 HeapRegion* head, | |
| 1158 HeapRegion* tail) { | |
| 1159 _recorded_survivor_regions = regions; | |
| 1160 _recorded_survivor_head = head; | |
| 1161 _recorded_survivor_tail = tail; | |
| 1162 } | |
| 1163 | |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
794
diff
changeset
|
1164 size_t recorded_survivor_regions() { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
794
diff
changeset
|
1165 return _recorded_survivor_regions; |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
794
diff
changeset
|
1166 } |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
794
diff
changeset
|
1167 |
| 545 | 1168 void record_thread_age_table(ageTable* age_table) |
| 1169 { | |
| 1170 _survivors_age_table.merge_par(age_table); | |
| 1171 } | |
| 1172 | |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1173 void update_max_gc_locker_expansion(); |
|
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1174 |
| 545 | 1175 // Calculates survivor space parameters. |
|
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1176 void update_survivors_policy(); |
| 545 | 1177 |
| 342 | 1178 }; |
| 1179 | |
| 1180 // This should move to some place more general... | |
| 1181 | |
| 1182 // If we have "n" measurements, and we've kept track of their "sum" and the | |
| 1183 // "sum_of_squares" of the measurements, this returns the variance of the | |
| 1184 // sequence. | |
| 1185 inline double variance(int n, double sum_of_squares, double sum) { | |
| 1186 double n_d = (double)n; | |
| 1187 double avg = sum/n_d; | |
| 1188 return (sum_of_squares - 2.0 * avg * sum + n_d * avg * avg) / n_d; | |
| 1189 } | |
| 1190 | |
| 1972 | 1191 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTORPOLICY_HPP |