Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 1705:2d160770d2e5
6814437: G1: remove the _new_refs array
Summary: The per-worker _new_refs array is used to hold references that point into the collection set. It is populated during RSet updating and subsequently processed. In the event of an evacuation failure it processed again to recreate the RSets of regions in the collection set. Remove the per-worker _new_refs array by processing the references directly. Use a DirtyCardQueue to hold the cards containing the references so that the RSets of regions in the collection set can be recreated when handling an evacuation failure.
Reviewed-by: iveresov, jmasa, tonyp
author | johnc |
---|---|
date | Mon, 02 Aug 2010 12:51:43 -0700 |
parents | 4e5661ba9d98 |
children | 0ce1569c90e5 |
rev | line source |
---|---|
342 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
2 * Copyright (c) 2001, 2010, 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 | |
25 #include "incls/_precompiled.incl" | |
26 #include "incls/_g1CollectorPolicy.cpp.incl" | |
27 | |
28 #define PREDICTIONS_VERBOSE 0 | |
29 | |
30 // <NEW PREDICTION> | |
31 | |
32 // Different defaults for different number of GC threads | |
33 // They were chosen by running GCOld and SPECjbb on debris with different | |
34 // numbers of GC threads and choosing them based on the results | |
35 | |
36 // all the same | |
37 static double rs_length_diff_defaults[] = { | |
38 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 | |
39 }; | |
40 | |
41 static double cost_per_card_ms_defaults[] = { | |
42 0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015 | |
43 }; | |
44 | |
45 // all the same | |
46 static double fully_young_cards_per_entry_ratio_defaults[] = { | |
47 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 | |
48 }; | |
49 | |
50 static double cost_per_entry_ms_defaults[] = { | |
51 0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005 | |
52 }; | |
53 | |
54 static double cost_per_byte_ms_defaults[] = { | |
55 0.00006, 0.00003, 0.00003, 0.000015, 0.000015, 0.00001, 0.00001, 0.000009 | |
56 }; | |
57 | |
58 // these should be pretty consistent | |
59 static double constant_other_time_ms_defaults[] = { | |
60 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0 | |
61 }; | |
62 | |
63 | |
64 static double young_other_cost_per_region_ms_defaults[] = { | |
65 0.3, 0.2, 0.2, 0.15, 0.15, 0.12, 0.12, 0.1 | |
66 }; | |
67 | |
68 static double non_young_other_cost_per_region_ms_defaults[] = { | |
69 1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30 | |
70 }; | |
71 | |
72 // </NEW PREDICTION> | |
73 | |
74 G1CollectorPolicy::G1CollectorPolicy() : | |
75 _parallel_gc_threads((ParallelGCThreads > 0) ? ParallelGCThreads : 1), | |
76 _n_pauses(0), | |
77 _recent_CH_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
78 _recent_G1_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
79 _recent_evac_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
80 _recent_pause_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
81 _recent_rs_sizes(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
82 _recent_gc_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
83 _all_pause_times_ms(new NumberSeq()), | |
84 _stop_world_start(0.0), | |
85 _all_stop_world_times_ms(new NumberSeq()), | |
86 _all_yield_times_ms(new NumberSeq()), | |
87 | |
88 _all_mod_union_times_ms(new NumberSeq()), | |
89 | |
677 | 90 _summary(new Summary()), |
91 _abandoned_summary(new AbandonedSummary()), | |
342 | 92 |
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
93 #ifndef PRODUCT |
342 | 94 _cur_clear_ct_time_ms(0.0), |
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
95 _min_clear_cc_time_ms(-1.0), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
96 _max_clear_cc_time_ms(-1.0), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
97 _cur_clear_cc_time_ms(0.0), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
98 _cum_clear_cc_time_ms(0.0), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
99 _num_cc_clears(0L), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
100 #endif |
342 | 101 |
102 _region_num_young(0), | |
103 _region_num_tenured(0), | |
104 _prev_region_num_young(0), | |
105 _prev_region_num_tenured(0), | |
106 | |
107 _aux_num(10), | |
108 _all_aux_times_ms(new NumberSeq[_aux_num]), | |
109 _cur_aux_start_times_ms(new double[_aux_num]), | |
110 _cur_aux_times_ms(new double[_aux_num]), | |
111 _cur_aux_times_set(new bool[_aux_num]), | |
112 | |
113 _concurrent_mark_init_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
114 _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
115 _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
116 | |
117 // <NEW PREDICTION> | |
118 | |
119 _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
120 _prev_collection_pause_end_ms(0.0), | |
121 _pending_card_diff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
122 _rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
123 _cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
124 _fully_young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), | |
125 _partially_young_cards_per_entry_ratio_seq( | |
126 new TruncatedSeq(TruncatedSeqLength)), | |
127 _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
128 _partially_young_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
129 _cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
130 _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)), | |
131 _constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
132 _young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
133 _non_young_other_cost_per_region_ms_seq( | |
134 new TruncatedSeq(TruncatedSeqLength)), | |
135 | |
136 _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)), | |
137 _scanned_cards_seq(new TruncatedSeq(TruncatedSeqLength)), | |
138 _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)), | |
139 | |
751 | 140 _pause_time_target_ms((double) MaxGCPauseMillis), |
342 | 141 |
142 // </NEW PREDICTION> | |
143 | |
144 _in_young_gc_mode(false), | |
145 _full_young_gcs(true), | |
146 _full_young_pause_num(0), | |
147 _partial_young_pause_num(0), | |
148 | |
149 _during_marking(false), | |
150 _in_marking_window(false), | |
151 _in_marking_window_im(false), | |
152 | |
153 _known_garbage_ratio(0.0), | |
154 _known_garbage_bytes(0), | |
155 | |
156 _young_gc_eff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
157 | |
158 _recent_prev_end_times_for_all_gcs_sec(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
159 | |
160 _recent_CS_bytes_used_before(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
161 _recent_CS_bytes_surviving(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
162 | |
163 _recent_avg_pause_time_ratio(0.0), | |
164 _num_markings(0), | |
165 _n_marks(0), | |
166 _n_pauses_at_mark_end(0), | |
167 | |
168 _all_full_gc_times_ms(new NumberSeq()), | |
169 | |
170 // G1PausesBtwnConcMark defaults to -1 | |
171 // so the hack is to do the cast QQQ FIXME | |
172 _pauses_btwn_concurrent_mark((size_t)G1PausesBtwnConcMark), | |
173 _n_marks_since_last_pause(0), | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
174 _initiate_conc_mark_if_possible(false), |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
175 _during_initial_mark_pause(false), |
342 | 176 _should_revert_to_full_young_gcs(false), |
177 _last_full_young_gc(false), | |
178 | |
179 _prev_collection_pause_used_at_end_bytes(0), | |
180 | |
181 _collection_set(NULL), | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
182 _collection_set_size(0), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
183 _collection_set_bytes_used_before(0), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
184 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
185 // Incremental CSet attributes |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
186 _inc_cset_build_state(Inactive), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
187 _inc_cset_head(NULL), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
188 _inc_cset_tail(NULL), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
189 _inc_cset_size(0), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
190 _inc_cset_young_index(0), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
191 _inc_cset_bytes_used_before(0), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
192 _inc_cset_max_finger(NULL), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
193 _inc_cset_recorded_young_bytes(0), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
194 _inc_cset_recorded_rs_lengths(0), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
195 _inc_cset_predicted_elapsed_time_ms(0.0), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
196 _inc_cset_predicted_bytes_to_copy(0), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
197 |
342 | 198 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away |
199 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
200 #endif // _MSC_VER | |
201 | |
202 _short_lived_surv_rate_group(new SurvRateGroup(this, "Short Lived", | |
203 G1YoungSurvRateNumRegionsSummary)), | |
204 _survivor_surv_rate_group(new SurvRateGroup(this, "Survivor", | |
545 | 205 G1YoungSurvRateNumRegionsSummary)), |
342 | 206 // add here any more surv rate groups |
545 | 207 _recorded_survivor_regions(0), |
208 _recorded_survivor_head(NULL), | |
209 _recorded_survivor_tail(NULL), | |
1356 | 210 _survivors_age_table(true), |
211 | |
212 _gc_overhead_perc(0.0) | |
545 | 213 |
342 | 214 { |
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
215 // Set up the region size and associated fields. Given that the |
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
216 // policy is created before the heap, we have to set this up here, |
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
217 // so it's done as soon as possible. |
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
218 HeapRegion::setup_heap_region_size(Arguments::min_heap_size()); |
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1111
diff
changeset
|
219 HeapRegionRemSet::setup_remset_size(); |
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
220 |
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
221 // Verify PLAB sizes |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
222 const uint region_size = HeapRegion::GrainWords; |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
223 if (YoungPLABSize > region_size || OldPLABSize > region_size) { |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
224 char buffer[128]; |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
225 jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most %u", |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
226 OldPLABSize > region_size ? "Old" : "Young", region_size); |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
227 vm_exit_during_initialization(buffer); |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
228 } |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
229 |
342 | 230 _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); |
231 _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; | |
232 | |
1611 | 233 _par_last_gc_worker_start_times_ms = new double[_parallel_gc_threads]; |
342 | 234 _par_last_ext_root_scan_times_ms = new double[_parallel_gc_threads]; |
235 _par_last_mark_stack_scan_times_ms = new double[_parallel_gc_threads]; | |
236 | |
237 _par_last_update_rs_times_ms = new double[_parallel_gc_threads]; | |
238 _par_last_update_rs_processed_buffers = new double[_parallel_gc_threads]; | |
239 | |
240 _par_last_scan_rs_times_ms = new double[_parallel_gc_threads]; | |
241 | |
242 _par_last_obj_copy_times_ms = new double[_parallel_gc_threads]; | |
243 | |
244 _par_last_termination_times_ms = new double[_parallel_gc_threads]; | |
1611 | 245 _par_last_termination_attempts = new double[_parallel_gc_threads]; |
246 _par_last_gc_worker_end_times_ms = new double[_parallel_gc_threads]; | |
342 | 247 |
248 // start conservatively | |
751 | 249 _expensive_region_limit_ms = 0.5 * (double) MaxGCPauseMillis; |
342 | 250 |
251 // <NEW PREDICTION> | |
252 | |
253 int index; | |
254 if (ParallelGCThreads == 0) | |
255 index = 0; | |
256 else if (ParallelGCThreads > 8) | |
257 index = 7; | |
258 else | |
259 index = ParallelGCThreads - 1; | |
260 | |
261 _pending_card_diff_seq->add(0.0); | |
262 _rs_length_diff_seq->add(rs_length_diff_defaults[index]); | |
263 _cost_per_card_ms_seq->add(cost_per_card_ms_defaults[index]); | |
264 _fully_young_cards_per_entry_ratio_seq->add( | |
265 fully_young_cards_per_entry_ratio_defaults[index]); | |
266 _cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]); | |
267 _cost_per_byte_ms_seq->add(cost_per_byte_ms_defaults[index]); | |
268 _constant_other_time_ms_seq->add(constant_other_time_ms_defaults[index]); | |
269 _young_other_cost_per_region_ms_seq->add( | |
270 young_other_cost_per_region_ms_defaults[index]); | |
271 _non_young_other_cost_per_region_ms_seq->add( | |
272 non_young_other_cost_per_region_ms_defaults[index]); | |
273 | |
274 // </NEW PREDICTION> | |
275 | |
1610
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
276 // Below, we might need to calculate the pause time target based on |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
277 // the pause interval. When we do so we are going to give G1 maximum |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
278 // flexibility and allow it to do pauses when it needs to. So, we'll |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
279 // arrange that the pause interval to be pause time target + 1 to |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
280 // ensure that a) the pause time target is maximized with respect to |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
281 // the pause interval and b) we maintain the invariant that pause |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
282 // time target < pause interval. If the user does not want this |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
283 // maximum flexibility, they will have to set the pause interval |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
284 // explicitly. |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
285 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
286 // First make sure that, if either parameter is set, its value is |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
287 // reasonable. |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
288 if (!FLAG_IS_DEFAULT(MaxGCPauseMillis)) { |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
289 if (MaxGCPauseMillis < 1) { |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
290 vm_exit_during_initialization("MaxGCPauseMillis should be " |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
291 "greater than 0"); |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
292 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
293 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
294 if (!FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
295 if (GCPauseIntervalMillis < 1) { |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
296 vm_exit_during_initialization("GCPauseIntervalMillis should be " |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
297 "greater than 0"); |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
298 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
299 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
300 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
301 // Then, if the pause time target parameter was not set, set it to |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
302 // the default value. |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
303 if (FLAG_IS_DEFAULT(MaxGCPauseMillis)) { |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
304 if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
305 // The default pause time target in G1 is 200ms |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
306 FLAG_SET_DEFAULT(MaxGCPauseMillis, 200); |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
307 } else { |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
308 // We do not allow the pause interval to be set without the |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
309 // pause time target |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
310 vm_exit_during_initialization("GCPauseIntervalMillis cannot be set " |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
311 "without setting MaxGCPauseMillis"); |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
312 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
313 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
314 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
315 // Then, if the interval parameter was not set, set it according to |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
316 // the pause time target (this will also deal with the case when the |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
317 // pause time target is the default value). |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
318 if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
319 FLAG_SET_DEFAULT(GCPauseIntervalMillis, MaxGCPauseMillis + 1); |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
320 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
321 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
322 // Finally, make sure that the two parameters are consistent. |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
323 if (MaxGCPauseMillis >= GCPauseIntervalMillis) { |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
324 char buffer[256]; |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
325 jio_snprintf(buffer, 256, |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
326 "MaxGCPauseMillis (%u) should be less than " |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
327 "GCPauseIntervalMillis (%u)", |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
328 MaxGCPauseMillis, GCPauseIntervalMillis); |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
329 vm_exit_during_initialization(buffer); |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
330 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
331 |
751 | 332 double max_gc_time = (double) MaxGCPauseMillis / 1000.0; |
1610
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
333 double time_slice = (double) GCPauseIntervalMillis / 1000.0; |
342 | 334 _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time); |
751 | 335 _sigma = (double) G1ConfidencePercent / 100.0; |
342 | 336 |
337 // start conservatively (around 50ms is about right) | |
338 _concurrent_mark_init_times_ms->add(0.05); | |
339 _concurrent_mark_remark_times_ms->add(0.05); | |
340 _concurrent_mark_cleanup_times_ms->add(0.20); | |
341 _tenuring_threshold = MaxTenuringThreshold; | |
342 | |
1282 | 343 // if G1FixedSurvivorSpaceSize is 0 which means the size is not |
344 // fixed, then _max_survivor_regions will be calculated at | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
345 // calculate_young_list_target_length during initialization |
1282 | 346 _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes; |
545 | 347 |
1356 | 348 assert(GCTimeRatio > 0, |
349 "we should have set it to a default value set_g1_gc_flags() " | |
350 "if a user set it to 0"); | |
351 _gc_overhead_perc = 100.0 * (1.0 / (1.0 + GCTimeRatio)); | |
352 | |
342 | 353 initialize_all(); |
354 } | |
355 | |
356 // Increment "i", mod "len" | |
357 static void inc_mod(int& i, int len) { | |
358 i++; if (i == len) i = 0; | |
359 } | |
360 | |
361 void G1CollectorPolicy::initialize_flags() { | |
362 set_min_alignment(HeapRegion::GrainBytes); | |
363 set_max_alignment(GenRemSet::max_alignment_constraint(rem_set_name())); | |
547
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
364 if (SurvivorRatio < 1) { |
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
365 vm_exit_during_initialization("Invalid survivor ratio specified"); |
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
366 } |
342 | 367 CollectorPolicy::initialize_flags(); |
368 } | |
369 | |
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
370 // The easiest way to deal with the parsing of the NewSize / |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
371 // MaxNewSize / etc. parameteres is to re-use the code in the |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
372 // TwoGenerationCollectorPolicy class. This is similar to what |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
373 // ParallelScavenge does with its GenerationSizer class (see |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
374 // ParallelScavengeHeap::initialize()). We might change this in the |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
375 // future, but it's a good start. |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
376 class G1YoungGenSizer : public TwoGenerationCollectorPolicy { |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
377 size_t size_to_region_num(size_t byte_size) { |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
378 return MAX2((size_t) 1, byte_size / HeapRegion::GrainBytes); |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
379 } |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
380 |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
381 public: |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
382 G1YoungGenSizer() { |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
383 initialize_flags(); |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
384 initialize_size_info(); |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
385 } |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
386 |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
387 size_t min_young_region_num() { |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
388 return size_to_region_num(_min_gen0_size); |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
389 } |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
390 size_t initial_young_region_num() { |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
391 return size_to_region_num(_initial_gen0_size); |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
392 } |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
393 size_t max_young_region_num() { |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
394 return size_to_region_num(_max_gen0_size); |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
395 } |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
396 }; |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
397 |
342 | 398 void G1CollectorPolicy::init() { |
399 // Set aside an initial future to_space. | |
400 _g1 = G1CollectedHeap::heap(); | |
401 | |
402 assert(Heap_lock->owned_by_self(), "Locking discipline."); | |
403 | |
545 | 404 initialize_gc_policy_counters(); |
405 | |
342 | 406 if (G1Gen) { |
407 _in_young_gc_mode = true; | |
408 | |
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
409 G1YoungGenSizer sizer; |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
410 size_t initial_region_num = sizer.initial_young_region_num(); |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
411 |
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
412 if (UseAdaptiveSizePolicy) { |
342 | 413 set_adaptive_young_list_length(true); |
414 _young_list_fixed_length = 0; | |
415 } else { | |
416 set_adaptive_young_list_length(false); | |
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
417 _young_list_fixed_length = initial_region_num; |
342 | 418 } |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
419 _free_regions_at_end_of_collection = _g1->free_regions(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
420 calculate_young_list_min_length(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
421 guarantee( _young_list_min_length == 0, "invariant, not enough info" ); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
422 calculate_young_list_target_length(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
423 } else { |
342 | 424 _young_list_fixed_length = 0; |
425 _in_young_gc_mode = false; | |
426 } | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
427 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
428 // We may immediately start allocating regions and placing them on the |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
429 // collection set list. Initialize the per-collection set info |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
430 start_incremental_cset_building(); |
342 | 431 } |
432 | |
545 | 433 // Create the jstat counters for the policy. |
434 void G1CollectorPolicy::initialize_gc_policy_counters() | |
435 { | |
436 _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 2 + G1Gen); | |
437 } | |
438 | |
342 | 439 void G1CollectorPolicy::calculate_young_list_min_length() { |
440 _young_list_min_length = 0; | |
441 | |
442 if (!adaptive_young_list_length()) | |
443 return; | |
444 | |
445 if (_alloc_rate_ms_seq->num() > 3) { | |
446 double now_sec = os::elapsedTime(); | |
447 double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0; | |
448 double alloc_rate_ms = predict_alloc_rate_ms(); | |
449 int min_regions = (int) ceil(alloc_rate_ms * when_ms); | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
450 int current_region_num = (int) _g1->young_list()->length(); |
342 | 451 _young_list_min_length = min_regions + current_region_num; |
452 } | |
453 } | |
454 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
455 void G1CollectorPolicy::calculate_young_list_target_length() { |
342 | 456 if (adaptive_young_list_length()) { |
457 size_t rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq); | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
458 calculate_young_list_target_length(rs_lengths); |
342 | 459 } else { |
460 if (full_young_gcs()) | |
461 _young_list_target_length = _young_list_fixed_length; | |
462 else | |
463 _young_list_target_length = _young_list_fixed_length / 2; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
464 |
342 | 465 _young_list_target_length = MAX2(_young_list_target_length, (size_t)1); |
466 } | |
545 | 467 calculate_survivors_policy(); |
342 | 468 } |
469 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
470 void G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths) { |
342 | 471 guarantee( adaptive_young_list_length(), "pre-condition" ); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
472 guarantee( !_in_marking_window || !_last_full_young_gc, "invariant" ); |
342 | 473 |
474 double start_time_sec = os::elapsedTime(); | |
1282 | 475 size_t min_reserve_perc = MAX2((size_t)2, (size_t)G1ReservePercent); |
342 | 476 min_reserve_perc = MIN2((size_t) 50, min_reserve_perc); |
477 size_t reserve_regions = | |
478 (size_t) ((double) min_reserve_perc * (double) _g1->n_regions() / 100.0); | |
479 | |
480 if (full_young_gcs() && _free_regions_at_end_of_collection > 0) { | |
481 // we are in fully-young mode and there are free regions in the heap | |
482 | |
545 | 483 double survivor_regions_evac_time = |
484 predict_survivor_regions_evac_time(); | |
485 | |
342 | 486 double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0; |
487 size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq); | |
488 size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff(); | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
489 size_t scanned_cards = predict_young_card_num(adj_rs_lengths); |
545 | 490 double base_time_ms = predict_base_elapsed_time_ms(pending_cards, scanned_cards) |
491 + survivor_regions_evac_time; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
492 |
342 | 493 // the result |
494 size_t final_young_length = 0; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
495 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
496 size_t init_free_regions = |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
497 MAX2((size_t)0, _free_regions_at_end_of_collection - reserve_regions); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
498 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
499 // if we're still under the pause target... |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
500 if (base_time_ms <= target_pause_time_ms) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
501 // We make sure that the shortest young length that makes sense |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
502 // fits within the target pause time. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
503 size_t min_young_length = 1; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
504 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
505 if (predict_will_fit(min_young_length, base_time_ms, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
506 init_free_regions, target_pause_time_ms)) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
507 // The shortest young length will fit within the target pause time; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
508 // we'll now check whether the absolute maximum number of young |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
509 // regions will fit in the target pause time. If not, we'll do |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
510 // a binary search between min_young_length and max_young_length |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
511 size_t abs_max_young_length = _free_regions_at_end_of_collection - 1; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
512 size_t max_young_length = abs_max_young_length; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
513 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
514 if (max_young_length > min_young_length) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
515 // Let's check if the initial max young length will fit within the |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
516 // target pause. If so then there is no need to search for a maximal |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
517 // young length - we'll return the initial maximum |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
518 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
519 if (predict_will_fit(max_young_length, base_time_ms, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
520 init_free_regions, target_pause_time_ms)) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
521 // The maximum young length will satisfy the target pause time. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
522 // We are done so set min young length to this maximum length. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
523 // The code after the loop will then set final_young_length using |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
524 // the value cached in the minimum length. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
525 min_young_length = max_young_length; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
526 } else { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
527 // The maximum possible number of young regions will not fit within |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
528 // the target pause time so let's search.... |
342 | 529 |
530 size_t diff = (max_young_length - min_young_length) / 2; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
531 max_young_length = min_young_length + diff; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
532 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
533 while (max_young_length > min_young_length) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
534 if (predict_will_fit(max_young_length, base_time_ms, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
535 init_free_regions, target_pause_time_ms)) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
536 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
537 // The current max young length will fit within the target |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
538 // pause time. Note we do not exit the loop here. By setting |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
539 // min = max, and then increasing the max below means that |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
540 // we will continue searching for an upper bound in the |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
541 // range [max..max+diff] |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
542 min_young_length = max_young_length; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
543 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
544 diff = (max_young_length - min_young_length) / 2; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
545 max_young_length = min_young_length + diff; |
342 | 546 } |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
547 // the above loop found a maximal young length that will fit |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
548 // within the target pause time. |
342 | 549 } |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
550 assert(min_young_length <= abs_max_young_length, "just checking"); |
342 | 551 } |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
552 final_young_length = min_young_length; |
342 | 553 } |
554 } | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
555 // and we're done! |
342 | 556 |
557 // we should have at least one region in the target young length | |
545 | 558 _young_list_target_length = |
559 MAX2((size_t) 1, final_young_length + _recorded_survivor_regions); | |
342 | 560 |
561 // let's keep an eye of how long we spend on this calculation | |
562 // right now, I assume that we'll print it when we need it; we | |
563 // should really adde it to the breakdown of a pause | |
564 double end_time_sec = os::elapsedTime(); | |
565 double elapsed_time_ms = (end_time_sec - start_time_sec) * 1000.0; | |
566 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
567 #ifdef TRACE_CALC_YOUNG_LENGTH |
342 | 568 // leave this in for debugging, just in case |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
569 gclog_or_tty->print_cr("target = %1.1lf ms, young = " SIZE_FORMAT ", " |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
570 "elapsed %1.2lf ms, (%s%s) " SIZE_FORMAT SIZE_FORMAT, |
342 | 571 target_pause_time_ms, |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
572 _young_list_target_length |
342 | 573 elapsed_time_ms, |
574 full_young_gcs() ? "full" : "partial", | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
575 during_initial_mark_pause() ? " i-m" : "", |
545 | 576 _in_marking_window, |
577 _in_marking_window_im); | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
578 #endif // TRACE_CALC_YOUNG_LENGTH |
342 | 579 |
580 if (_young_list_target_length < _young_list_min_length) { | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
581 // bummer; this means that, if we do a pause when the maximal |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
582 // length dictates, we'll violate the pause spacing target (the |
342 | 583 // min length was calculate based on the application's current |
584 // alloc rate); | |
585 | |
586 // so, we have to bite the bullet, and allocate the minimum | |
587 // number. We'll violate our target, but we just can't meet it. | |
588 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
589 #ifdef TRACE_CALC_YOUNG_LENGTH |
342 | 590 // leave this in for debugging, just in case |
591 gclog_or_tty->print_cr("adjusted target length from " | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
592 SIZE_FORMAT " to " SIZE_FORMAT, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
593 _young_list_target_length, _young_list_min_length); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
594 #endif // TRACE_CALC_YOUNG_LENGTH |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
595 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
596 _young_list_target_length = _young_list_min_length; |
342 | 597 } |
598 } else { | |
599 // we are in a partially-young mode or we've run out of regions (due | |
600 // to evacuation failure) | |
601 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
602 #ifdef TRACE_CALC_YOUNG_LENGTH |
342 | 603 // leave this in for debugging, just in case |
604 gclog_or_tty->print_cr("(partial) setting target to " SIZE_FORMAT | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
605 _young_list_min_length); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
606 #endif // TRACE_CALC_YOUNG_LENGTH |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
607 // we'll do the pause as soon as possible by choosing the minimum |
342 | 608 _young_list_target_length = |
609 MAX2(_young_list_min_length, (size_t) 1); | |
610 } | |
611 | |
612 _rs_lengths_prediction = rs_lengths; | |
613 } | |
614 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
615 // This is used by: calculate_young_list_target_length(rs_length). It |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
616 // returns true iff: |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
617 // the predicted pause time for the given young list will not overflow |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
618 // the target pause time |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
619 // and: |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
620 // the predicted amount of surviving data will not overflow the |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
621 // the amount of free space available for survivor regions. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
622 // |
342 | 623 bool |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
624 G1CollectorPolicy::predict_will_fit(size_t young_length, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
625 double base_time_ms, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
626 size_t init_free_regions, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
627 double target_pause_time_ms) { |
342 | 628 |
629 if (young_length >= init_free_regions) | |
630 // end condition 1: not enough space for the young regions | |
631 return false; | |
632 | |
633 double accum_surv_rate_adj = 0.0; | |
634 double accum_surv_rate = | |
635 accum_yg_surv_rate_pred((int)(young_length - 1)) - accum_surv_rate_adj; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
636 |
342 | 637 size_t bytes_to_copy = |
638 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes); | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
639 |
342 | 640 double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
641 |
342 | 642 double young_other_time_ms = |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
643 predict_young_other_time_ms(young_length); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
644 |
342 | 645 double pause_time_ms = |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
646 base_time_ms + copy_time_ms + young_other_time_ms; |
342 | 647 |
648 if (pause_time_ms > target_pause_time_ms) | |
649 // end condition 2: over the target pause time | |
650 return false; | |
651 | |
652 size_t free_bytes = | |
653 (init_free_regions - young_length) * HeapRegion::GrainBytes; | |
654 | |
655 if ((2.0 + sigma()) * (double) bytes_to_copy > (double) free_bytes) | |
656 // end condition 3: out of to-space (conservatively) | |
657 return false; | |
658 | |
659 // success! | |
660 return true; | |
661 } | |
662 | |
545 | 663 double G1CollectorPolicy::predict_survivor_regions_evac_time() { |
664 double survivor_regions_evac_time = 0.0; | |
665 for (HeapRegion * r = _recorded_survivor_head; | |
666 r != NULL && r != _recorded_survivor_tail->get_next_young_region(); | |
667 r = r->get_next_young_region()) { | |
668 survivor_regions_evac_time += predict_region_elapsed_time_ms(r, true); | |
669 } | |
670 return survivor_regions_evac_time; | |
671 } | |
672 | |
342 | 673 void G1CollectorPolicy::check_prediction_validity() { |
674 guarantee( adaptive_young_list_length(), "should not call this otherwise" ); | |
675 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
676 size_t rs_lengths = _g1->young_list()->sampled_rs_lengths(); |
342 | 677 if (rs_lengths > _rs_lengths_prediction) { |
678 // add 10% to avoid having to recalculate often | |
679 size_t rs_lengths_prediction = rs_lengths * 1100 / 1000; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
680 calculate_young_list_target_length(rs_lengths_prediction); |
342 | 681 } |
682 } | |
683 | |
684 HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size, | |
685 bool is_tlab, | |
686 bool* gc_overhead_limit_was_exceeded) { | |
687 guarantee(false, "Not using this policy feature yet."); | |
688 return NULL; | |
689 } | |
690 | |
691 // This method controls how a collector handles one or more | |
692 // of its generations being fully allocated. | |
693 HeapWord* G1CollectorPolicy::satisfy_failed_allocation(size_t size, | |
694 bool is_tlab) { | |
695 guarantee(false, "Not using this policy feature yet."); | |
696 return NULL; | |
697 } | |
698 | |
699 | |
700 #ifndef PRODUCT | |
701 bool G1CollectorPolicy::verify_young_ages() { | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
702 HeapRegion* head = _g1->young_list()->first_region(); |
342 | 703 return |
704 verify_young_ages(head, _short_lived_surv_rate_group); | |
705 // also call verify_young_ages on any additional surv rate groups | |
706 } | |
707 | |
708 bool | |
709 G1CollectorPolicy::verify_young_ages(HeapRegion* head, | |
710 SurvRateGroup *surv_rate_group) { | |
711 guarantee( surv_rate_group != NULL, "pre-condition" ); | |
712 | |
713 const char* name = surv_rate_group->name(); | |
714 bool ret = true; | |
715 int prev_age = -1; | |
716 | |
717 for (HeapRegion* curr = head; | |
718 curr != NULL; | |
719 curr = curr->get_next_young_region()) { | |
720 SurvRateGroup* group = curr->surv_rate_group(); | |
721 if (group == NULL && !curr->is_survivor()) { | |
722 gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name); | |
723 ret = false; | |
724 } | |
725 | |
726 if (surv_rate_group == group) { | |
727 int age = curr->age_in_surv_rate_group(); | |
728 | |
729 if (age < 0) { | |
730 gclog_or_tty->print_cr("## %s: encountered negative age", name); | |
731 ret = false; | |
732 } | |
733 | |
734 if (age <= prev_age) { | |
735 gclog_or_tty->print_cr("## %s: region ages are not strictly increasing " | |
736 "(%d, %d)", name, age, prev_age); | |
737 ret = false; | |
738 } | |
739 prev_age = age; | |
740 } | |
741 } | |
742 | |
743 return ret; | |
744 } | |
745 #endif // PRODUCT | |
746 | |
747 void G1CollectorPolicy::record_full_collection_start() { | |
748 _cur_collection_start_sec = os::elapsedTime(); | |
749 // Release the future to-space so that it is available for compaction into. | |
750 _g1->set_full_collection(); | |
751 } | |
752 | |
753 void G1CollectorPolicy::record_full_collection_end() { | |
754 // Consider this like a collection pause for the purposes of allocation | |
755 // since last pause. | |
756 double end_sec = os::elapsedTime(); | |
757 double full_gc_time_sec = end_sec - _cur_collection_start_sec; | |
758 double full_gc_time_ms = full_gc_time_sec * 1000.0; | |
759 | |
760 _all_full_gc_times_ms->add(full_gc_time_ms); | |
761 | |
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
762 update_recent_gc_times(end_sec, full_gc_time_ms); |
342 | 763 |
764 _g1->clear_full_collection(); | |
765 | |
766 // "Nuke" the heuristics that control the fully/partially young GC | |
767 // transitions and make sure we start with fully young GCs after the | |
768 // Full GC. | |
769 set_full_young_gcs(true); | |
770 _last_full_young_gc = false; | |
771 _should_revert_to_full_young_gcs = false; | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
772 clear_initiate_conc_mark_if_possible(); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
773 clear_during_initial_mark_pause(); |
342 | 774 _known_garbage_bytes = 0; |
775 _known_garbage_ratio = 0.0; | |
776 _in_marking_window = false; | |
777 _in_marking_window_im = false; | |
778 | |
779 _short_lived_surv_rate_group->start_adding_regions(); | |
780 // also call this on any additional surv rate groups | |
781 | |
545 | 782 record_survivor_regions(0, NULL, NULL); |
783 | |
342 | 784 _prev_region_num_young = _region_num_young; |
785 _prev_region_num_tenured = _region_num_tenured; | |
786 | |
787 _free_regions_at_end_of_collection = _g1->free_regions(); | |
545 | 788 // Reset survivors SurvRateGroup. |
789 _survivor_surv_rate_group->reset(); | |
342 | 790 calculate_young_list_min_length(); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
791 calculate_young_list_target_length(); |
342 | 792 } |
793 | |
794 void G1CollectorPolicy::record_before_bytes(size_t bytes) { | |
795 _bytes_in_to_space_before_gc += bytes; | |
796 } | |
797 | |
798 void G1CollectorPolicy::record_after_bytes(size_t bytes) { | |
799 _bytes_in_to_space_after_gc += bytes; | |
800 } | |
801 | |
802 void G1CollectorPolicy::record_stop_world_start() { | |
803 _stop_world_start = os::elapsedTime(); | |
804 } | |
805 | |
806 void G1CollectorPolicy::record_collection_pause_start(double start_time_sec, | |
807 size_t start_used) { | |
808 if (PrintGCDetails) { | |
809 gclog_or_tty->stamp(PrintGCTimeStamps); | |
810 gclog_or_tty->print("[GC pause"); | |
811 if (in_young_gc_mode()) | |
812 gclog_or_tty->print(" (%s)", full_young_gcs() ? "young" : "partial"); | |
813 } | |
814 | |
815 assert(_g1->used_regions() == _g1->recalculate_used_regions(), | |
816 "sanity"); | |
636 | 817 assert(_g1->used() == _g1->recalculate_used(), "sanity"); |
342 | 818 |
819 double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0; | |
820 _all_stop_world_times_ms->add(s_w_t_ms); | |
821 _stop_world_start = 0.0; | |
822 | |
823 _cur_collection_start_sec = start_time_sec; | |
824 _cur_collection_pause_used_at_start_bytes = start_used; | |
825 _cur_collection_pause_used_regions_at_start = _g1->used_regions(); | |
826 _pending_cards = _g1->pending_card_num(); | |
827 _max_pending_cards = _g1->max_pending_card_num(); | |
828 | |
829 _bytes_in_to_space_before_gc = 0; | |
830 _bytes_in_to_space_after_gc = 0; | |
831 _bytes_in_collection_set_before_gc = 0; | |
832 | |
833 #ifdef DEBUG | |
834 // initialise these to something well known so that we can spot | |
835 // if they are not set properly | |
836 | |
837 for (int i = 0; i < _parallel_gc_threads; ++i) { | |
1611 | 838 _par_last_gc_worker_start_times_ms[i] = -1234.0; |
839 _par_last_ext_root_scan_times_ms[i] = -1234.0; | |
840 _par_last_mark_stack_scan_times_ms[i] = -1234.0; | |
841 _par_last_update_rs_times_ms[i] = -1234.0; | |
842 _par_last_update_rs_processed_buffers[i] = -1234.0; | |
843 _par_last_scan_rs_times_ms[i] = -1234.0; | |
844 _par_last_obj_copy_times_ms[i] = -1234.0; | |
845 _par_last_termination_times_ms[i] = -1234.0; | |
846 _par_last_termination_attempts[i] = -1234.0; | |
847 _par_last_gc_worker_end_times_ms[i] = -1234.0; | |
342 | 848 } |
849 #endif | |
850 | |
851 for (int i = 0; i < _aux_num; ++i) { | |
852 _cur_aux_times_ms[i] = 0.0; | |
853 _cur_aux_times_set[i] = false; | |
854 } | |
855 | |
856 _satb_drain_time_set = false; | |
857 _last_satb_drain_processed_buffers = -1; | |
858 | |
859 if (in_young_gc_mode()) | |
860 _last_young_gc_full = false; | |
861 | |
862 // do that for any other surv rate groups | |
863 _short_lived_surv_rate_group->stop_adding_regions(); | |
1282 | 864 _survivors_age_table.clear(); |
545 | 865 |
342 | 866 assert( verify_young_ages(), "region age verification" ); |
867 } | |
868 | |
869 void G1CollectorPolicy::record_mark_closure_time(double mark_closure_time_ms) { | |
870 _mark_closure_time_ms = mark_closure_time_ms; | |
871 } | |
872 | |
873 void G1CollectorPolicy::record_concurrent_mark_init_start() { | |
874 _mark_init_start_sec = os::elapsedTime(); | |
875 guarantee(!in_young_gc_mode(), "should not do be here in young GC mode"); | |
876 } | |
877 | |
878 void G1CollectorPolicy::record_concurrent_mark_init_end_pre(double | |
879 mark_init_elapsed_time_ms) { | |
880 _during_marking = true; | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
881 assert(!initiate_conc_mark_if_possible(), "we should have cleared it by now"); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
882 clear_during_initial_mark_pause(); |
342 | 883 _cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms; |
884 } | |
885 | |
886 void G1CollectorPolicy::record_concurrent_mark_init_end() { | |
887 double end_time_sec = os::elapsedTime(); | |
888 double elapsed_time_ms = (end_time_sec - _mark_init_start_sec) * 1000.0; | |
889 _concurrent_mark_init_times_ms->add(elapsed_time_ms); | |
890 record_concurrent_mark_init_end_pre(elapsed_time_ms); | |
891 | |
892 _mmu_tracker->add_pause(_mark_init_start_sec, end_time_sec, true); | |
893 } | |
894 | |
895 void G1CollectorPolicy::record_concurrent_mark_remark_start() { | |
896 _mark_remark_start_sec = os::elapsedTime(); | |
897 _during_marking = false; | |
898 } | |
899 | |
900 void G1CollectorPolicy::record_concurrent_mark_remark_end() { | |
901 double end_time_sec = os::elapsedTime(); | |
902 double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0; | |
903 _concurrent_mark_remark_times_ms->add(elapsed_time_ms); | |
904 _cur_mark_stop_world_time_ms += elapsed_time_ms; | |
905 _prev_collection_pause_end_ms += elapsed_time_ms; | |
906 | |
907 _mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true); | |
908 } | |
909 | |
910 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() { | |
911 _mark_cleanup_start_sec = os::elapsedTime(); | |
912 } | |
913 | |
914 void | |
915 G1CollectorPolicy::record_concurrent_mark_cleanup_end(size_t freed_bytes, | |
916 size_t max_live_bytes) { | |
917 record_concurrent_mark_cleanup_end_work1(freed_bytes, max_live_bytes); | |
918 record_concurrent_mark_cleanup_end_work2(); | |
919 } | |
920 | |
921 void | |
922 G1CollectorPolicy:: | |
923 record_concurrent_mark_cleanup_end_work1(size_t freed_bytes, | |
924 size_t max_live_bytes) { | |
925 if (_n_marks < 2) _n_marks++; | |
926 if (G1PolicyVerbose > 0) | |
927 gclog_or_tty->print_cr("At end of marking, max_live is " SIZE_FORMAT " MB " | |
928 " (of " SIZE_FORMAT " MB heap).", | |
929 max_live_bytes/M, _g1->capacity()/M); | |
930 } | |
931 | |
932 // The important thing about this is that it includes "os::elapsedTime". | |
933 void G1CollectorPolicy::record_concurrent_mark_cleanup_end_work2() { | |
934 double end_time_sec = os::elapsedTime(); | |
935 double elapsed_time_ms = (end_time_sec - _mark_cleanup_start_sec)*1000.0; | |
936 _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms); | |
937 _cur_mark_stop_world_time_ms += elapsed_time_ms; | |
938 _prev_collection_pause_end_ms += elapsed_time_ms; | |
939 | |
940 _mmu_tracker->add_pause(_mark_cleanup_start_sec, end_time_sec, true); | |
941 | |
942 _num_markings++; | |
943 | |
944 // We did a marking, so reset the "since_last_mark" variables. | |
945 double considerConcMarkCost = 1.0; | |
946 // If there are available processors, concurrent activity is free... | |
947 if (Threads::number_of_non_daemon_threads() * 2 < | |
948 os::active_processor_count()) { | |
949 considerConcMarkCost = 0.0; | |
950 } | |
951 _n_pauses_at_mark_end = _n_pauses; | |
952 _n_marks_since_last_pause++; | |
953 } | |
954 | |
955 void | |
956 G1CollectorPolicy::record_concurrent_mark_cleanup_completed() { | |
957 if (in_young_gc_mode()) { | |
958 _should_revert_to_full_young_gcs = false; | |
959 _last_full_young_gc = true; | |
960 _in_marking_window = false; | |
961 if (adaptive_young_list_length()) | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
962 calculate_young_list_target_length(); |
342 | 963 } |
964 } | |
965 | |
966 void G1CollectorPolicy::record_concurrent_pause() { | |
967 if (_stop_world_start > 0.0) { | |
968 double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0; | |
969 _all_yield_times_ms->add(yield_ms); | |
970 } | |
971 } | |
972 | |
973 void G1CollectorPolicy::record_concurrent_pause_end() { | |
974 } | |
975 | |
976 void G1CollectorPolicy::record_collection_pause_end_CH_strong_roots() { | |
977 _cur_CH_strong_roots_end_sec = os::elapsedTime(); | |
978 _cur_CH_strong_roots_dur_ms = | |
979 (_cur_CH_strong_roots_end_sec - _cur_collection_start_sec) * 1000.0; | |
980 } | |
981 | |
982 void G1CollectorPolicy::record_collection_pause_end_G1_strong_roots() { | |
983 _cur_G1_strong_roots_end_sec = os::elapsedTime(); | |
984 _cur_G1_strong_roots_dur_ms = | |
985 (_cur_G1_strong_roots_end_sec - _cur_CH_strong_roots_end_sec) * 1000.0; | |
986 } | |
987 | |
988 template<class T> | |
989 T sum_of(T* sum_arr, int start, int n, int N) { | |
990 T sum = (T)0; | |
991 for (int i = 0; i < n; i++) { | |
992 int j = (start + i) % N; | |
993 sum += sum_arr[j]; | |
994 } | |
995 return sum; | |
996 } | |
997 | |
1611 | 998 void G1CollectorPolicy::print_par_stats(int level, |
999 const char* str, | |
1000 double* data, | |
342 | 1001 bool summary) { |
1002 double min = data[0], max = data[0]; | |
1003 double total = 0.0; | |
1004 int j; | |
1005 for (j = 0; j < level; ++j) | |
1006 gclog_or_tty->print(" "); | |
1007 gclog_or_tty->print("[%s (ms):", str); | |
1008 for (uint i = 0; i < ParallelGCThreads; ++i) { | |
1009 double val = data[i]; | |
1010 if (val < min) | |
1011 min = val; | |
1012 if (val > max) | |
1013 max = val; | |
1014 total += val; | |
1015 gclog_or_tty->print(" %3.1lf", val); | |
1016 } | |
1017 if (summary) { | |
1018 gclog_or_tty->print_cr(""); | |
1019 double avg = total / (double) ParallelGCThreads; | |
1020 gclog_or_tty->print(" "); | |
1021 for (j = 0; j < level; ++j) | |
1022 gclog_or_tty->print(" "); | |
1023 gclog_or_tty->print("Avg: %5.1lf, Min: %5.1lf, Max: %5.1lf", | |
1024 avg, min, max); | |
1025 } | |
1026 gclog_or_tty->print_cr("]"); | |
1027 } | |
1028 | |
1611 | 1029 void G1CollectorPolicy::print_par_sizes(int level, |
1030 const char* str, | |
1031 double* data, | |
1032 bool summary) { | |
342 | 1033 double min = data[0], max = data[0]; |
1034 double total = 0.0; | |
1035 int j; | |
1036 for (j = 0; j < level; ++j) | |
1037 gclog_or_tty->print(" "); | |
1038 gclog_or_tty->print("[%s :", str); | |
1039 for (uint i = 0; i < ParallelGCThreads; ++i) { | |
1040 double val = data[i]; | |
1041 if (val < min) | |
1042 min = val; | |
1043 if (val > max) | |
1044 max = val; | |
1045 total += val; | |
1046 gclog_or_tty->print(" %d", (int) val); | |
1047 } | |
1048 if (summary) { | |
1049 gclog_or_tty->print_cr(""); | |
1050 double avg = total / (double) ParallelGCThreads; | |
1051 gclog_or_tty->print(" "); | |
1052 for (j = 0; j < level; ++j) | |
1053 gclog_or_tty->print(" "); | |
1054 gclog_or_tty->print("Sum: %d, Avg: %d, Min: %d, Max: %d", | |
1055 (int)total, (int)avg, (int)min, (int)max); | |
1056 } | |
1057 gclog_or_tty->print_cr("]"); | |
1058 } | |
1059 | |
1060 void G1CollectorPolicy::print_stats (int level, | |
1061 const char* str, | |
1062 double value) { | |
1063 for (int j = 0; j < level; ++j) | |
1064 gclog_or_tty->print(" "); | |
1065 gclog_or_tty->print_cr("[%s: %5.1lf ms]", str, value); | |
1066 } | |
1067 | |
1068 void G1CollectorPolicy::print_stats (int level, | |
1069 const char* str, | |
1070 int value) { | |
1071 for (int j = 0; j < level; ++j) | |
1072 gclog_or_tty->print(" "); | |
1073 gclog_or_tty->print_cr("[%s: %d]", str, value); | |
1074 } | |
1075 | |
1076 double G1CollectorPolicy::avg_value (double* data) { | |
1077 if (ParallelGCThreads > 0) { | |
1078 double ret = 0.0; | |
1079 for (uint i = 0; i < ParallelGCThreads; ++i) | |
1080 ret += data[i]; | |
1081 return ret / (double) ParallelGCThreads; | |
1082 } else { | |
1083 return data[0]; | |
1084 } | |
1085 } | |
1086 | |
1087 double G1CollectorPolicy::max_value (double* data) { | |
1088 if (ParallelGCThreads > 0) { | |
1089 double ret = data[0]; | |
1090 for (uint i = 1; i < ParallelGCThreads; ++i) | |
1091 if (data[i] > ret) | |
1092 ret = data[i]; | |
1093 return ret; | |
1094 } else { | |
1095 return data[0]; | |
1096 } | |
1097 } | |
1098 | |
1099 double G1CollectorPolicy::sum_of_values (double* data) { | |
1100 if (ParallelGCThreads > 0) { | |
1101 double sum = 0.0; | |
1102 for (uint i = 0; i < ParallelGCThreads; i++) | |
1103 sum += data[i]; | |
1104 return sum; | |
1105 } else { | |
1106 return data[0]; | |
1107 } | |
1108 } | |
1109 | |
1110 double G1CollectorPolicy::max_sum (double* data1, | |
1111 double* data2) { | |
1112 double ret = data1[0] + data2[0]; | |
1113 | |
1114 if (ParallelGCThreads > 0) { | |
1115 for (uint i = 1; i < ParallelGCThreads; ++i) { | |
1116 double data = data1[i] + data2[i]; | |
1117 if (data > ret) | |
1118 ret = data; | |
1119 } | |
1120 } | |
1121 return ret; | |
1122 } | |
1123 | |
1124 // Anything below that is considered to be zero | |
1125 #define MIN_TIMER_GRANULARITY 0.0000001 | |
1126 | |
677 | 1127 void G1CollectorPolicy::record_collection_pause_end(bool abandoned) { |
342 | 1128 double end_time_sec = os::elapsedTime(); |
1129 double elapsed_ms = _last_pause_time_ms; | |
1130 bool parallel = ParallelGCThreads > 0; | |
1131 double evac_ms = (end_time_sec - _cur_G1_strong_roots_end_sec) * 1000.0; | |
1132 size_t rs_size = | |
1133 _cur_collection_pause_used_regions_at_start - collection_set_size(); | |
1134 size_t cur_used_bytes = _g1->used(); | |
1135 assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); | |
1136 bool last_pause_included_initial_mark = false; | |
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
1137 bool update_stats = !abandoned && !_g1->evacuation_failed(); |
342 | 1138 |
1139 #ifndef PRODUCT | |
1140 if (G1YoungSurvRateVerbose) { | |
1141 gclog_or_tty->print_cr(""); | |
1142 _short_lived_surv_rate_group->print(); | |
1143 // do that for any other surv rate groups too | |
1144 } | |
1145 #endif // PRODUCT | |
1146 | |
1147 if (in_young_gc_mode()) { | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1148 last_pause_included_initial_mark = during_initial_mark_pause(); |
342 | 1149 if (last_pause_included_initial_mark) |
1150 record_concurrent_mark_init_end_pre(0.0); | |
1151 | |
1152 size_t min_used_targ = | |
1283
1c72304f1885
6928073: G1: use existing command line parameters for marking cycle initiation
tonyp
parents:
1282
diff
changeset
|
1153 (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; |
342 | 1154 |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1155 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1156 if (!_g1->mark_in_progress() && !_last_full_young_gc) { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1157 assert(!last_pause_included_initial_mark, "invariant"); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1158 if (cur_used_bytes > min_used_targ && |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1159 cur_used_bytes > _prev_collection_pause_used_at_end_bytes) { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1160 assert(!during_initial_mark_pause(), "we should not see this here"); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1161 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1162 // Note: this might have already been set, if during the last |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1163 // pause we decided to start a cycle but at the beginning of |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1164 // this pause we decided to postpone it. That's OK. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1165 set_initiate_conc_mark_if_possible(); |
342 | 1166 } |
1167 } | |
1168 | |
1169 _prev_collection_pause_used_at_end_bytes = cur_used_bytes; | |
1170 } | |
1171 | |
1172 _mmu_tracker->add_pause(end_time_sec - elapsed_ms/1000.0, | |
1173 end_time_sec, false); | |
1174 | |
1175 guarantee(_cur_collection_pause_used_regions_at_start >= | |
1176 collection_set_size(), | |
1177 "Negative RS size?"); | |
1178 | |
1179 // This assert is exempted when we're doing parallel collection pauses, | |
1180 // because the fragmentation caused by the parallel GC allocation buffers | |
1181 // can lead to more memory being used during collection than was used | |
1182 // before. Best leave this out until the fragmentation problem is fixed. | |
1183 // Pauses in which evacuation failed can also lead to negative | |
1184 // collections, since no space is reclaimed from a region containing an | |
1185 // object whose evacuation failed. | |
1186 // Further, we're now always doing parallel collection. But I'm still | |
1187 // leaving this here as a placeholder for a more precise assertion later. | |
1188 // (DLD, 10/05.) | |
1189 assert((true || parallel) // Always using GC LABs now. | |
1190 || _g1->evacuation_failed() | |
1191 || _cur_collection_pause_used_at_start_bytes >= cur_used_bytes, | |
1192 "Negative collection"); | |
1193 | |
1194 size_t freed_bytes = | |
1195 _cur_collection_pause_used_at_start_bytes - cur_used_bytes; | |
1196 size_t surviving_bytes = _collection_set_bytes_used_before - freed_bytes; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1197 |
342 | 1198 double survival_fraction = |
1199 (double)surviving_bytes/ | |
1200 (double)_collection_set_bytes_used_before; | |
1201 | |
1202 _n_pauses++; | |
1203 | |
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
1204 if (update_stats) { |
342 | 1205 _recent_CH_strong_roots_times_ms->add(_cur_CH_strong_roots_dur_ms); |
1206 _recent_G1_strong_roots_times_ms->add(_cur_G1_strong_roots_dur_ms); | |
1207 _recent_evac_times_ms->add(evac_ms); | |
1208 _recent_pause_times_ms->add(elapsed_ms); | |
1209 | |
1210 _recent_rs_sizes->add(rs_size); | |
1211 | |
1212 // We exempt parallel collection from this check because Alloc Buffer | |
1213 // fragmentation can produce negative collections. Same with evac | |
1214 // failure. | |
1215 // Further, we're now always doing parallel collection. But I'm still | |
1216 // leaving this here as a placeholder for a more precise assertion later. | |
1217 // (DLD, 10/05. | |
1218 assert((true || parallel) | |
1219 || _g1->evacuation_failed() | |
1220 || surviving_bytes <= _collection_set_bytes_used_before, | |
1221 "Or else negative collection!"); | |
1222 _recent_CS_bytes_used_before->add(_collection_set_bytes_used_before); | |
1223 _recent_CS_bytes_surviving->add(surviving_bytes); | |
1224 | |
1225 // this is where we update the allocation rate of the application | |
1226 double app_time_ms = | |
1227 (_cur_collection_start_sec * 1000.0 - _prev_collection_pause_end_ms); | |
1228 if (app_time_ms < MIN_TIMER_GRANULARITY) { | |
1229 // This usually happens due to the timer not having the required | |
1230 // granularity. Some Linuxes are the usual culprits. | |
1231 // We'll just set it to something (arbitrarily) small. | |
1232 app_time_ms = 1.0; | |
1233 } | |
1234 size_t regions_allocated = | |
1235 (_region_num_young - _prev_region_num_young) + | |
1236 (_region_num_tenured - _prev_region_num_tenured); | |
1237 double alloc_rate_ms = (double) regions_allocated / app_time_ms; | |
1238 _alloc_rate_ms_seq->add(alloc_rate_ms); | |
1239 _prev_region_num_young = _region_num_young; | |
1240 _prev_region_num_tenured = _region_num_tenured; | |
1241 | |
1242 double interval_ms = | |
1243 (end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0; | |
1244 update_recent_gc_times(end_time_sec, elapsed_ms); | |
1245 _recent_avg_pause_time_ratio = _recent_gc_times_ms->sum()/interval_ms; | |
1086
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1246 if (recent_avg_pause_time_ratio() < 0.0 || |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1247 (recent_avg_pause_time_ratio() - 1.0 > 0.0)) { |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1248 #ifndef PRODUCT |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1249 // Dump info to allow post-facto debugging |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1250 gclog_or_tty->print_cr("recent_avg_pause_time_ratio() out of bounds"); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1251 gclog_or_tty->print_cr("-------------------------------------------"); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1252 gclog_or_tty->print_cr("Recent GC Times (ms):"); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1253 _recent_gc_times_ms->dump(); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1254 gclog_or_tty->print_cr("(End Time=%3.3f) Recent GC End Times (s):", end_time_sec); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1255 _recent_prev_end_times_for_all_gcs_sec->dump(); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1256 gclog_or_tty->print_cr("GC = %3.3f, Interval = %3.3f, Ratio = %3.3f", |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1257 _recent_gc_times_ms->sum(), interval_ms, recent_avg_pause_time_ratio()); |
1087
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1258 // In debug mode, terminate the JVM if the user wants to debug at this point. |
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1259 assert(!G1FailOnFPError, "Debugging data for CR 6898948 has been dumped above"); |
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1260 #endif // !PRODUCT |
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1261 // Clip ratio between 0.0 and 1.0, and continue. This will be fixed in |
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1262 // CR 6902692 by redoing the manner in which the ratio is incrementally computed. |
1086
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1263 if (_recent_avg_pause_time_ratio < 0.0) { |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1264 _recent_avg_pause_time_ratio = 0.0; |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1265 } else { |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1266 assert(_recent_avg_pause_time_ratio - 1.0 > 0.0, "Ctl-point invariant"); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1267 _recent_avg_pause_time_ratio = 1.0; |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1268 } |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1269 } |
342 | 1270 } |
1271 | |
1272 if (G1PolicyVerbose > 1) { | |
1273 gclog_or_tty->print_cr(" Recording collection pause(%d)", _n_pauses); | |
1274 } | |
1275 | |
1276 PauseSummary* summary; | |
677 | 1277 if (abandoned) { |
1278 summary = _abandoned_summary; | |
1279 } else { | |
1280 summary = _summary; | |
342 | 1281 } |
1282 | |
1283 double ext_root_scan_time = avg_value(_par_last_ext_root_scan_times_ms); | |
1284 double mark_stack_scan_time = avg_value(_par_last_mark_stack_scan_times_ms); | |
1285 double update_rs_time = avg_value(_par_last_update_rs_times_ms); | |
1286 double update_rs_processed_buffers = | |
1287 sum_of_values(_par_last_update_rs_processed_buffers); | |
1288 double scan_rs_time = avg_value(_par_last_scan_rs_times_ms); | |
1289 double obj_copy_time = avg_value(_par_last_obj_copy_times_ms); | |
1290 double termination_time = avg_value(_par_last_termination_times_ms); | |
1291 | |
648
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1292 double parallel_other_time = _cur_collection_par_time_ms - |
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1293 (update_rs_time + ext_root_scan_time + mark_stack_scan_time + |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1294 scan_rs_time + obj_copy_time + termination_time); |
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
1295 if (update_stats) { |
342 | 1296 MainBodySummary* body_summary = summary->main_body_summary(); |
1297 guarantee(body_summary != NULL, "should not be null!"); | |
1298 | |
1299 if (_satb_drain_time_set) | |
1300 body_summary->record_satb_drain_time_ms(_cur_satb_drain_time_ms); | |
1301 else | |
1302 body_summary->record_satb_drain_time_ms(0.0); | |
1303 body_summary->record_ext_root_scan_time_ms(ext_root_scan_time); | |
1304 body_summary->record_mark_stack_scan_time_ms(mark_stack_scan_time); | |
1305 body_summary->record_update_rs_time_ms(update_rs_time); | |
1306 body_summary->record_scan_rs_time_ms(scan_rs_time); | |
1307 body_summary->record_obj_copy_time_ms(obj_copy_time); | |
1308 if (parallel) { | |
1309 body_summary->record_parallel_time_ms(_cur_collection_par_time_ms); | |
1310 body_summary->record_clear_ct_time_ms(_cur_clear_ct_time_ms); | |
1311 body_summary->record_termination_time_ms(termination_time); | |
1312 body_summary->record_parallel_other_time_ms(parallel_other_time); | |
1313 } | |
1314 body_summary->record_mark_closure_time_ms(_mark_closure_time_ms); | |
1315 } | |
1316 | |
1317 if (G1PolicyVerbose > 1) { | |
1318 gclog_or_tty->print_cr(" ET: %10.6f ms (avg: %10.6f ms)\n" | |
1319 " CH Strong: %10.6f ms (avg: %10.6f ms)\n" | |
1320 " G1 Strong: %10.6f ms (avg: %10.6f ms)\n" | |
1321 " Evac: %10.6f ms (avg: %10.6f ms)\n" | |
1322 " ET-RS: %10.6f ms (avg: %10.6f ms)\n" | |
1323 " |RS|: " SIZE_FORMAT, | |
1324 elapsed_ms, recent_avg_time_for_pauses_ms(), | |
1325 _cur_CH_strong_roots_dur_ms, recent_avg_time_for_CH_strong_ms(), | |
1326 _cur_G1_strong_roots_dur_ms, recent_avg_time_for_G1_strong_ms(), | |
1327 evac_ms, recent_avg_time_for_evac_ms(), | |
1328 scan_rs_time, | |
1329 recent_avg_time_for_pauses_ms() - | |
1330 recent_avg_time_for_G1_strong_ms(), | |
1331 rs_size); | |
1332 | |
1333 gclog_or_tty->print_cr(" Used at start: " SIZE_FORMAT"K" | |
1334 " At end " SIZE_FORMAT "K\n" | |
1335 " garbage : " SIZE_FORMAT "K" | |
1336 " of " SIZE_FORMAT "K\n" | |
1337 " survival : %6.2f%% (%6.2f%% avg)", | |
1338 _cur_collection_pause_used_at_start_bytes/K, | |
1339 _g1->used()/K, freed_bytes/K, | |
1340 _collection_set_bytes_used_before/K, | |
1341 survival_fraction*100.0, | |
1342 recent_avg_survival_fraction()*100.0); | |
1343 gclog_or_tty->print_cr(" Recent %% gc pause time: %6.2f", | |
1344 recent_avg_pause_time_ratio() * 100.0); | |
1345 } | |
1346 | |
1347 double other_time_ms = elapsed_ms; | |
1348 | |
1349 if (!abandoned) { | |
1350 if (_satb_drain_time_set) | |
1351 other_time_ms -= _cur_satb_drain_time_ms; | |
1352 | |
1353 if (parallel) | |
1354 other_time_ms -= _cur_collection_par_time_ms + _cur_clear_ct_time_ms; | |
1355 else | |
1356 other_time_ms -= | |
1357 update_rs_time + | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1358 ext_root_scan_time + mark_stack_scan_time + |
342 | 1359 scan_rs_time + obj_copy_time; |
1360 } | |
1361 | |
1362 if (PrintGCDetails) { | |
1363 gclog_or_tty->print_cr("%s%s, %1.8lf secs]", | |
677 | 1364 abandoned ? " (abandoned)" : "", |
342 | 1365 (last_pause_included_initial_mark) ? " (initial-mark)" : "", |
1366 elapsed_ms / 1000.0); | |
1367 | |
1368 if (!abandoned) { | |
677 | 1369 if (_satb_drain_time_set) { |
342 | 1370 print_stats(1, "SATB Drain Time", _cur_satb_drain_time_ms); |
677 | 1371 } |
1372 if (_last_satb_drain_processed_buffers >= 0) { | |
342 | 1373 print_stats(2, "Processed Buffers", _last_satb_drain_processed_buffers); |
677 | 1374 } |
1375 if (parallel) { | |
1376 print_stats(1, "Parallel Time", _cur_collection_par_time_ms); | |
1611 | 1377 print_par_stats(2, "GC Worker Start Time", |
1378 _par_last_gc_worker_start_times_ms, false); | |
677 | 1379 print_par_stats(2, "Update RS", _par_last_update_rs_times_ms); |
1611 | 1380 print_par_sizes(3, "Processed Buffers", |
1381 _par_last_update_rs_processed_buffers, true); | |
1382 print_par_stats(2, "Ext Root Scanning", | |
1383 _par_last_ext_root_scan_times_ms); | |
1384 print_par_stats(2, "Mark Stack Scanning", | |
1385 _par_last_mark_stack_scan_times_ms); | |
342 | 1386 print_par_stats(2, "Scan RS", _par_last_scan_rs_times_ms); |
1387 print_par_stats(2, "Object Copy", _par_last_obj_copy_times_ms); | |
1388 print_par_stats(2, "Termination", _par_last_termination_times_ms); | |
1611 | 1389 print_par_sizes(3, "Termination Attempts", |
1390 _par_last_termination_attempts, true); | |
1391 print_par_stats(2, "GC Worker End Time", | |
1392 _par_last_gc_worker_end_times_ms, false); | |
342 | 1393 print_stats(2, "Other", parallel_other_time); |
1394 print_stats(1, "Clear CT", _cur_clear_ct_time_ms); | |
677 | 1395 } else { |
1396 print_stats(1, "Update RS", update_rs_time); | |
794 | 1397 print_stats(2, "Processed Buffers", |
1398 (int)update_rs_processed_buffers); | |
342 | 1399 print_stats(1, "Ext Root Scanning", ext_root_scan_time); |
1400 print_stats(1, "Mark Stack Scanning", mark_stack_scan_time); | |
1401 print_stats(1, "Scan RS", scan_rs_time); | |
1402 print_stats(1, "Object Copying", obj_copy_time); | |
1403 } | |
1404 } | |
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1405 #ifndef PRODUCT |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1406 print_stats(1, "Cur Clear CC", _cur_clear_cc_time_ms); |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1407 print_stats(1, "Cum Clear CC", _cum_clear_cc_time_ms); |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1408 print_stats(1, "Min Clear CC", _min_clear_cc_time_ms); |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1409 print_stats(1, "Max Clear CC", _max_clear_cc_time_ms); |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1410 if (_num_cc_clears > 0) { |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1411 print_stats(1, "Avg Clear CC", _cum_clear_cc_time_ms / ((double)_num_cc_clears)); |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1412 } |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1413 #endif |
342 | 1414 print_stats(1, "Other", other_time_ms); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1415 print_stats(2, "Choose CSet", _recorded_young_cset_choice_time_ms); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1416 |
342 | 1417 for (int i = 0; i < _aux_num; ++i) { |
1418 if (_cur_aux_times_set[i]) { | |
1419 char buffer[96]; | |
1420 sprintf(buffer, "Aux%d", i); | |
1421 print_stats(1, buffer, _cur_aux_times_ms[i]); | |
1422 } | |
1423 } | |
1424 } | |
1425 if (PrintGCDetails) | |
1426 gclog_or_tty->print(" ["); | |
1427 if (PrintGC || PrintGCDetails) | |
1428 _g1->print_size_transition(gclog_or_tty, | |
1429 _cur_collection_pause_used_at_start_bytes, | |
1430 _g1->used(), _g1->capacity()); | |
1431 if (PrintGCDetails) | |
1432 gclog_or_tty->print_cr("]"); | |
1433 | |
1434 _all_pause_times_ms->add(elapsed_ms); | |
648
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1435 if (update_stats) { |
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1436 summary->record_total_time_ms(elapsed_ms); |
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1437 summary->record_other_time_ms(other_time_ms); |
2314b7336582
6820321: G1: Error: guarantee(check_nums(total, n, parts), "all seq lengths should match")
tonyp
parents:
640
diff
changeset
|
1438 } |
342 | 1439 for (int i = 0; i < _aux_num; ++i) |
1440 if (_cur_aux_times_set[i]) | |
1441 _all_aux_times_ms[i].add(_cur_aux_times_ms[i]); | |
1442 | |
1443 // Reset marks-between-pauses counter. | |
1444 _n_marks_since_last_pause = 0; | |
1445 | |
1446 // Update the efficiency-since-mark vars. | |
1447 double proc_ms = elapsed_ms * (double) _parallel_gc_threads; | |
1448 if (elapsed_ms < MIN_TIMER_GRANULARITY) { | |
1449 // This usually happens due to the timer not having the required | |
1450 // granularity. Some Linuxes are the usual culprits. | |
1451 // We'll just set it to something (arbitrarily) small. | |
1452 proc_ms = 1.0; | |
1453 } | |
1454 double cur_efficiency = (double) freed_bytes / proc_ms; | |
1455 | |
1456 bool new_in_marking_window = _in_marking_window; | |
1457 bool new_in_marking_window_im = false; | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1458 if (during_initial_mark_pause()) { |
342 | 1459 new_in_marking_window = true; |
1460 new_in_marking_window_im = true; | |
1461 } | |
1462 | |
1463 if (in_young_gc_mode()) { | |
1464 if (_last_full_young_gc) { | |
1465 set_full_young_gcs(false); | |
1466 _last_full_young_gc = false; | |
1467 } | |
1468 | |
1469 if ( !_last_young_gc_full ) { | |
1470 if ( _should_revert_to_full_young_gcs || | |
1471 _known_garbage_ratio < 0.05 || | |
1472 (adaptive_young_list_length() && | |
1473 (get_gc_eff_factor() * cur_efficiency < predict_young_gc_eff())) ) { | |
1474 set_full_young_gcs(true); | |
1475 } | |
1476 } | |
1477 _should_revert_to_full_young_gcs = false; | |
1478 | |
1479 if (_last_young_gc_full && !_during_marking) | |
1480 _young_gc_eff_seq->add(cur_efficiency); | |
1481 } | |
1482 | |
1483 _short_lived_surv_rate_group->start_adding_regions(); | |
1484 // do that for any other surv rate groupsx | |
1485 | |
1486 // <NEW PREDICTION> | |
1487 | |
677 | 1488 if (update_stats) { |
342 | 1489 double pause_time_ms = elapsed_ms; |
1490 | |
1491 size_t diff = 0; | |
1492 if (_max_pending_cards >= _pending_cards) | |
1493 diff = _max_pending_cards - _pending_cards; | |
1494 _pending_card_diff_seq->add((double) diff); | |
1495 | |
1496 double cost_per_card_ms = 0.0; | |
1497 if (_pending_cards > 0) { | |
1498 cost_per_card_ms = update_rs_time / (double) _pending_cards; | |
1499 _cost_per_card_ms_seq->add(cost_per_card_ms); | |
1500 } | |
1501 | |
1502 size_t cards_scanned = _g1->cards_scanned(); | |
1503 | |
1504 double cost_per_entry_ms = 0.0; | |
1505 if (cards_scanned > 10) { | |
1506 cost_per_entry_ms = scan_rs_time / (double) cards_scanned; | |
1507 if (_last_young_gc_full) | |
1508 _cost_per_entry_ms_seq->add(cost_per_entry_ms); | |
1509 else | |
1510 _partially_young_cost_per_entry_ms_seq->add(cost_per_entry_ms); | |
1511 } | |
1512 | |
1513 if (_max_rs_lengths > 0) { | |
1514 double cards_per_entry_ratio = | |
1515 (double) cards_scanned / (double) _max_rs_lengths; | |
1516 if (_last_young_gc_full) | |
1517 _fully_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); | |
1518 else | |
1519 _partially_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); | |
1520 } | |
1521 | |
1522 size_t rs_length_diff = _max_rs_lengths - _recorded_rs_lengths; | |
1523 if (rs_length_diff >= 0) | |
1524 _rs_length_diff_seq->add((double) rs_length_diff); | |
1525 | |
1526 size_t copied_bytes = surviving_bytes; | |
1527 double cost_per_byte_ms = 0.0; | |
1528 if (copied_bytes > 0) { | |
1529 cost_per_byte_ms = obj_copy_time / (double) copied_bytes; | |
1530 if (_in_marking_window) | |
1531 _cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms); | |
1532 else | |
1533 _cost_per_byte_ms_seq->add(cost_per_byte_ms); | |
1534 } | |
1535 | |
1536 double all_other_time_ms = pause_time_ms - | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1537 (update_rs_time + scan_rs_time + obj_copy_time + |
342 | 1538 _mark_closure_time_ms + termination_time); |
1539 | |
1540 double young_other_time_ms = 0.0; | |
1541 if (_recorded_young_regions > 0) { | |
1542 young_other_time_ms = | |
1543 _recorded_young_cset_choice_time_ms + | |
1544 _recorded_young_free_cset_time_ms; | |
1545 _young_other_cost_per_region_ms_seq->add(young_other_time_ms / | |
1546 (double) _recorded_young_regions); | |
1547 } | |
1548 double non_young_other_time_ms = 0.0; | |
1549 if (_recorded_non_young_regions > 0) { | |
1550 non_young_other_time_ms = | |
1551 _recorded_non_young_cset_choice_time_ms + | |
1552 _recorded_non_young_free_cset_time_ms; | |
1553 | |
1554 _non_young_other_cost_per_region_ms_seq->add(non_young_other_time_ms / | |
1555 (double) _recorded_non_young_regions); | |
1556 } | |
1557 | |
1558 double constant_other_time_ms = all_other_time_ms - | |
1559 (young_other_time_ms + non_young_other_time_ms); | |
1560 _constant_other_time_ms_seq->add(constant_other_time_ms); | |
1561 | |
1562 double survival_ratio = 0.0; | |
1563 if (_bytes_in_collection_set_before_gc > 0) { | |
1564 survival_ratio = (double) bytes_in_to_space_during_gc() / | |
1565 (double) _bytes_in_collection_set_before_gc; | |
1566 } | |
1567 | |
1568 _pending_cards_seq->add((double) _pending_cards); | |
1569 _scanned_cards_seq->add((double) cards_scanned); | |
1570 _rs_lengths_seq->add((double) _max_rs_lengths); | |
1571 | |
1572 double expensive_region_limit_ms = | |
751 | 1573 (double) MaxGCPauseMillis - predict_constant_other_time_ms(); |
342 | 1574 if (expensive_region_limit_ms < 0.0) { |
1575 // this means that the other time was predicted to be longer than | |
1576 // than the max pause time | |
751 | 1577 expensive_region_limit_ms = (double) MaxGCPauseMillis; |
342 | 1578 } |
1579 _expensive_region_limit_ms = expensive_region_limit_ms; | |
1580 | |
1581 if (PREDICTIONS_VERBOSE) { | |
1582 gclog_or_tty->print_cr(""); | |
1583 gclog_or_tty->print_cr("PREDICTIONS %1.4lf %d " | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1584 "REGIONS %d %d %d " |
342 | 1585 "PENDING_CARDS %d %d " |
1586 "CARDS_SCANNED %d %d " | |
1587 "RS_LENGTHS %d %d " | |
1588 "RS_UPDATE %1.6lf %1.6lf RS_SCAN %1.6lf %1.6lf " | |
1589 "SURVIVAL_RATIO %1.6lf %1.6lf " | |
1590 "OBJECT_COPY %1.6lf %1.6lf OTHER_CONSTANT %1.6lf %1.6lf " | |
1591 "OTHER_YOUNG %1.6lf %1.6lf " | |
1592 "OTHER_NON_YOUNG %1.6lf %1.6lf " | |
1593 "VTIME_DIFF %1.6lf TERMINATION %1.6lf " | |
1594 "ELAPSED %1.6lf %1.6lf ", | |
1595 _cur_collection_start_sec, | |
1596 (!_last_young_gc_full) ? 2 : | |
1597 (last_pause_included_initial_mark) ? 1 : 0, | |
1598 _recorded_region_num, | |
1599 _recorded_young_regions, | |
1600 _recorded_non_young_regions, | |
1601 _predicted_pending_cards, _pending_cards, | |
1602 _predicted_cards_scanned, cards_scanned, | |
1603 _predicted_rs_lengths, _max_rs_lengths, | |
1604 _predicted_rs_update_time_ms, update_rs_time, | |
1605 _predicted_rs_scan_time_ms, scan_rs_time, | |
1606 _predicted_survival_ratio, survival_ratio, | |
1607 _predicted_object_copy_time_ms, obj_copy_time, | |
1608 _predicted_constant_other_time_ms, constant_other_time_ms, | |
1609 _predicted_young_other_time_ms, young_other_time_ms, | |
1610 _predicted_non_young_other_time_ms, | |
1611 non_young_other_time_ms, | |
1612 _vtime_diff_ms, termination_time, | |
1613 _predicted_pause_time_ms, elapsed_ms); | |
1614 } | |
1615 | |
1616 if (G1PolicyVerbose > 0) { | |
1617 gclog_or_tty->print_cr("Pause Time, predicted: %1.4lfms (predicted %s), actual: %1.4lfms", | |
1618 _predicted_pause_time_ms, | |
1619 (_within_target) ? "within" : "outside", | |
1620 elapsed_ms); | |
1621 } | |
1622 | |
1623 } | |
1624 | |
1625 _in_marking_window = new_in_marking_window; | |
1626 _in_marking_window_im = new_in_marking_window_im; | |
1627 _free_regions_at_end_of_collection = _g1->free_regions(); | |
1628 calculate_young_list_min_length(); | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1629 calculate_young_list_target_length(); |
342 | 1630 |
1111 | 1631 // Note that _mmu_tracker->max_gc_time() returns the time in seconds. |
1282 | 1632 double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; |
1111 | 1633 adjust_concurrent_refinement(update_rs_time, update_rs_processed_buffers, update_rs_time_goal_ms); |
342 | 1634 // </NEW PREDICTION> |
1635 } | |
1636 | |
1637 // <NEW PREDICTION> | |
1638 | |
1111 | 1639 void G1CollectorPolicy::adjust_concurrent_refinement(double update_rs_time, |
1640 double update_rs_processed_buffers, | |
1641 double goal_ms) { | |
1642 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
1643 ConcurrentG1Refine *cg1r = G1CollectedHeap::heap()->concurrent_g1_refine(); | |
1644 | |
1282 | 1645 if (G1UseAdaptiveConcRefinement) { |
1111 | 1646 const int k_gy = 3, k_gr = 6; |
1647 const double inc_k = 1.1, dec_k = 0.9; | |
1648 | |
1649 int g = cg1r->green_zone(); | |
1650 if (update_rs_time > goal_ms) { | |
1651 g = (int)(g * dec_k); // Can become 0, that's OK. That would mean a mutator-only processing. | |
1652 } else { | |
1653 if (update_rs_time < goal_ms && update_rs_processed_buffers > g) { | |
1654 g = (int)MAX2(g * inc_k, g + 1.0); | |
1655 } | |
1656 } | |
1657 // Change the refinement threads params | |
1658 cg1r->set_green_zone(g); | |
1659 cg1r->set_yellow_zone(g * k_gy); | |
1660 cg1r->set_red_zone(g * k_gr); | |
1661 cg1r->reinitialize_threads(); | |
1662 | |
1663 int processing_threshold_delta = MAX2((int)(cg1r->green_zone() * sigma()), 1); | |
1664 int processing_threshold = MIN2(cg1r->green_zone() + processing_threshold_delta, | |
1665 cg1r->yellow_zone()); | |
1666 // Change the barrier params | |
1667 dcqs.set_process_completed_threshold(processing_threshold); | |
1668 dcqs.set_max_completed_queue(cg1r->red_zone()); | |
1669 } | |
1670 | |
1671 int curr_queue_size = dcqs.completed_buffers_num(); | |
1672 if (curr_queue_size >= cg1r->yellow_zone()) { | |
1673 dcqs.set_completed_queue_padding(curr_queue_size); | |
1674 } else { | |
1675 dcqs.set_completed_queue_padding(0); | |
1676 } | |
1677 dcqs.notify_if_necessary(); | |
1678 } | |
1679 | |
342 | 1680 double |
1681 G1CollectorPolicy:: | |
1682 predict_young_collection_elapsed_time_ms(size_t adjustment) { | |
1683 guarantee( adjustment == 0 || adjustment == 1, "invariant" ); | |
1684 | |
1685 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1686 size_t young_num = g1h->young_list()->length(); |
342 | 1687 if (young_num == 0) |
1688 return 0.0; | |
1689 | |
1690 young_num += adjustment; | |
1691 size_t pending_cards = predict_pending_cards(); | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1692 size_t rs_lengths = g1h->young_list()->sampled_rs_lengths() + |
342 | 1693 predict_rs_length_diff(); |
1694 size_t card_num; | |
1695 if (full_young_gcs()) | |
1696 card_num = predict_young_card_num(rs_lengths); | |
1697 else | |
1698 card_num = predict_non_young_card_num(rs_lengths); | |
1699 size_t young_byte_size = young_num * HeapRegion::GrainBytes; | |
1700 double accum_yg_surv_rate = | |
1701 _short_lived_surv_rate_group->accum_surv_rate(adjustment); | |
1702 | |
1703 size_t bytes_to_copy = | |
1704 (size_t) (accum_yg_surv_rate * (double) HeapRegion::GrainBytes); | |
1705 | |
1706 return | |
1707 predict_rs_update_time_ms(pending_cards) + | |
1708 predict_rs_scan_time_ms(card_num) + | |
1709 predict_object_copy_time_ms(bytes_to_copy) + | |
1710 predict_young_other_time_ms(young_num) + | |
1711 predict_constant_other_time_ms(); | |
1712 } | |
1713 | |
1714 double | |
1715 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) { | |
1716 size_t rs_length = predict_rs_length_diff(); | |
1717 size_t card_num; | |
1718 if (full_young_gcs()) | |
1719 card_num = predict_young_card_num(rs_length); | |
1720 else | |
1721 card_num = predict_non_young_card_num(rs_length); | |
1722 return predict_base_elapsed_time_ms(pending_cards, card_num); | |
1723 } | |
1724 | |
1725 double | |
1726 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards, | |
1727 size_t scanned_cards) { | |
1728 return | |
1729 predict_rs_update_time_ms(pending_cards) + | |
1730 predict_rs_scan_time_ms(scanned_cards) + | |
1731 predict_constant_other_time_ms(); | |
1732 } | |
1733 | |
1734 double | |
1735 G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr, | |
1736 bool young) { | |
1737 size_t rs_length = hr->rem_set()->occupied(); | |
1738 size_t card_num; | |
1739 if (full_young_gcs()) | |
1740 card_num = predict_young_card_num(rs_length); | |
1741 else | |
1742 card_num = predict_non_young_card_num(rs_length); | |
1743 size_t bytes_to_copy = predict_bytes_to_copy(hr); | |
1744 | |
1745 double region_elapsed_time_ms = | |
1746 predict_rs_scan_time_ms(card_num) + | |
1747 predict_object_copy_time_ms(bytes_to_copy); | |
1748 | |
1749 if (young) | |
1750 region_elapsed_time_ms += predict_young_other_time_ms(1); | |
1751 else | |
1752 region_elapsed_time_ms += predict_non_young_other_time_ms(1); | |
1753 | |
1754 return region_elapsed_time_ms; | |
1755 } | |
1756 | |
1757 size_t | |
1758 G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) { | |
1759 size_t bytes_to_copy; | |
1760 if (hr->is_marked()) | |
1761 bytes_to_copy = hr->max_live_bytes(); | |
1762 else { | |
1763 guarantee( hr->is_young() && hr->age_in_surv_rate_group() != -1, | |
1764 "invariant" ); | |
1765 int age = hr->age_in_surv_rate_group(); | |
545 | 1766 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group()); |
342 | 1767 bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate); |
1768 } | |
1769 | |
1770 return bytes_to_copy; | |
1771 } | |
1772 | |
1773 void | |
1774 G1CollectorPolicy::start_recording_regions() { | |
1775 _recorded_rs_lengths = 0; | |
1776 _recorded_young_regions = 0; | |
1777 _recorded_non_young_regions = 0; | |
1778 | |
1779 #if PREDICTIONS_VERBOSE | |
1780 _recorded_marked_bytes = 0; | |
1781 _recorded_young_bytes = 0; | |
1782 _predicted_bytes_to_copy = 0; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1783 _predicted_rs_lengths = 0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1784 _predicted_cards_scanned = 0; |
342 | 1785 #endif // PREDICTIONS_VERBOSE |
1786 } | |
1787 | |
1788 void | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1789 G1CollectorPolicy::record_cset_region_info(HeapRegion* hr, bool young) { |
342 | 1790 #if PREDICTIONS_VERBOSE |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1791 if (!young) { |
342 | 1792 _recorded_marked_bytes += hr->max_live_bytes(); |
1793 } | |
1794 _predicted_bytes_to_copy += predict_bytes_to_copy(hr); | |
1795 #endif // PREDICTIONS_VERBOSE | |
1796 | |
1797 size_t rs_length = hr->rem_set()->occupied(); | |
1798 _recorded_rs_lengths += rs_length; | |
1799 } | |
1800 | |
1801 void | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1802 G1CollectorPolicy::record_non_young_cset_region(HeapRegion* hr) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1803 assert(!hr->is_young(), "should not call this"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1804 ++_recorded_non_young_regions; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1805 record_cset_region_info(hr, false); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1806 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1807 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1808 void |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1809 G1CollectorPolicy::set_recorded_young_regions(size_t n_regions) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1810 _recorded_young_regions = n_regions; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1811 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1812 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1813 void G1CollectorPolicy::set_recorded_young_bytes(size_t bytes) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1814 #if PREDICTIONS_VERBOSE |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1815 _recorded_young_bytes = bytes; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1816 #endif // PREDICTIONS_VERBOSE |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1817 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1818 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1819 void G1CollectorPolicy::set_recorded_rs_lengths(size_t rs_lengths) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1820 _recorded_rs_lengths = rs_lengths; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1821 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1822 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1823 void G1CollectorPolicy::set_predicted_bytes_to_copy(size_t bytes) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1824 _predicted_bytes_to_copy = bytes; |
342 | 1825 } |
1826 | |
1827 void | |
1828 G1CollectorPolicy::end_recording_regions() { | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1829 // The _predicted_pause_time_ms field is referenced in code |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1830 // not under PREDICTIONS_VERBOSE. Let's initialize it. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1831 _predicted_pause_time_ms = -1.0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1832 |
342 | 1833 #if PREDICTIONS_VERBOSE |
1834 _predicted_pending_cards = predict_pending_cards(); | |
1835 _predicted_rs_lengths = _recorded_rs_lengths + predict_rs_length_diff(); | |
1836 if (full_young_gcs()) | |
1837 _predicted_cards_scanned += predict_young_card_num(_predicted_rs_lengths); | |
1838 else | |
1839 _predicted_cards_scanned += | |
1840 predict_non_young_card_num(_predicted_rs_lengths); | |
1841 _recorded_region_num = _recorded_young_regions + _recorded_non_young_regions; | |
1842 | |
1843 _predicted_rs_update_time_ms = | |
1844 predict_rs_update_time_ms(_g1->pending_card_num()); | |
1845 _predicted_rs_scan_time_ms = | |
1846 predict_rs_scan_time_ms(_predicted_cards_scanned); | |
1847 _predicted_object_copy_time_ms = | |
1848 predict_object_copy_time_ms(_predicted_bytes_to_copy); | |
1849 _predicted_constant_other_time_ms = | |
1850 predict_constant_other_time_ms(); | |
1851 _predicted_young_other_time_ms = | |
1852 predict_young_other_time_ms(_recorded_young_regions); | |
1853 _predicted_non_young_other_time_ms = | |
1854 predict_non_young_other_time_ms(_recorded_non_young_regions); | |
1855 | |
1856 _predicted_pause_time_ms = | |
1857 _predicted_rs_update_time_ms + | |
1858 _predicted_rs_scan_time_ms + | |
1859 _predicted_object_copy_time_ms + | |
1860 _predicted_constant_other_time_ms + | |
1861 _predicted_young_other_time_ms + | |
1862 _predicted_non_young_other_time_ms; | |
1863 #endif // PREDICTIONS_VERBOSE | |
1864 } | |
1865 | |
1866 void G1CollectorPolicy::check_if_region_is_too_expensive(double | |
1867 predicted_time_ms) { | |
1868 // I don't think we need to do this when in young GC mode since | |
1869 // marking will be initiated next time we hit the soft limit anyway... | |
1870 if (predicted_time_ms > _expensive_region_limit_ms) { | |
1871 if (!in_young_gc_mode()) { | |
1872 set_full_young_gcs(true); | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1873 // We might want to do something different here. However, |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1874 // right now we don't support the non-generational G1 mode |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1875 // (and in fact we are planning to remove the associated code, |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1876 // see CR 6814390). So, let's leave it as is and this will be |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1877 // removed some time in the future |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1878 ShouldNotReachHere(); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1879 set_during_initial_mark_pause(); |
342 | 1880 } else |
1881 // no point in doing another partial one | |
1882 _should_revert_to_full_young_gcs = true; | |
1883 } | |
1884 } | |
1885 | |
1886 // </NEW PREDICTION> | |
1887 | |
1888 | |
1889 void G1CollectorPolicy::update_recent_gc_times(double end_time_sec, | |
1890 double elapsed_ms) { | |
1891 _recent_gc_times_ms->add(elapsed_ms); | |
1892 _recent_prev_end_times_for_all_gcs_sec->add(end_time_sec); | |
1893 _prev_collection_pause_end_ms = end_time_sec * 1000.0; | |
1894 } | |
1895 | |
1896 double G1CollectorPolicy::recent_avg_time_for_pauses_ms() { | |
751 | 1897 if (_recent_pause_times_ms->num() == 0) return (double) MaxGCPauseMillis; |
342 | 1898 else return _recent_pause_times_ms->avg(); |
1899 } | |
1900 | |
1901 double G1CollectorPolicy::recent_avg_time_for_CH_strong_ms() { | |
1902 if (_recent_CH_strong_roots_times_ms->num() == 0) | |
751 | 1903 return (double)MaxGCPauseMillis/3.0; |
342 | 1904 else return _recent_CH_strong_roots_times_ms->avg(); |
1905 } | |
1906 | |
1907 double G1CollectorPolicy::recent_avg_time_for_G1_strong_ms() { | |
1908 if (_recent_G1_strong_roots_times_ms->num() == 0) | |
751 | 1909 return (double)MaxGCPauseMillis/3.0; |
342 | 1910 else return _recent_G1_strong_roots_times_ms->avg(); |
1911 } | |
1912 | |
1913 double G1CollectorPolicy::recent_avg_time_for_evac_ms() { | |
751 | 1914 if (_recent_evac_times_ms->num() == 0) return (double)MaxGCPauseMillis/3.0; |
342 | 1915 else return _recent_evac_times_ms->avg(); |
1916 } | |
1917 | |
1918 int G1CollectorPolicy::number_of_recent_gcs() { | |
1919 assert(_recent_CH_strong_roots_times_ms->num() == | |
1920 _recent_G1_strong_roots_times_ms->num(), "Sequence out of sync"); | |
1921 assert(_recent_G1_strong_roots_times_ms->num() == | |
1922 _recent_evac_times_ms->num(), "Sequence out of sync"); | |
1923 assert(_recent_evac_times_ms->num() == | |
1924 _recent_pause_times_ms->num(), "Sequence out of sync"); | |
1925 assert(_recent_pause_times_ms->num() == | |
1926 _recent_CS_bytes_used_before->num(), "Sequence out of sync"); | |
1927 assert(_recent_CS_bytes_used_before->num() == | |
1928 _recent_CS_bytes_surviving->num(), "Sequence out of sync"); | |
1929 return _recent_pause_times_ms->num(); | |
1930 } | |
1931 | |
1932 double G1CollectorPolicy::recent_avg_survival_fraction() { | |
1933 return recent_avg_survival_fraction_work(_recent_CS_bytes_surviving, | |
1934 _recent_CS_bytes_used_before); | |
1935 } | |
1936 | |
1937 double G1CollectorPolicy::last_survival_fraction() { | |
1938 return last_survival_fraction_work(_recent_CS_bytes_surviving, | |
1939 _recent_CS_bytes_used_before); | |
1940 } | |
1941 | |
1942 double | |
1943 G1CollectorPolicy::recent_avg_survival_fraction_work(TruncatedSeq* surviving, | |
1944 TruncatedSeq* before) { | |
1945 assert(surviving->num() == before->num(), "Sequence out of sync"); | |
1946 if (before->sum() > 0.0) { | |
1947 double recent_survival_rate = surviving->sum() / before->sum(); | |
1948 // We exempt parallel collection from this check because Alloc Buffer | |
1949 // fragmentation can produce negative collections. | |
1950 // Further, we're now always doing parallel collection. But I'm still | |
1951 // leaving this here as a placeholder for a more precise assertion later. | |
1952 // (DLD, 10/05.) | |
1953 assert((true || ParallelGCThreads > 0) || | |
1954 _g1->evacuation_failed() || | |
1955 recent_survival_rate <= 1.0, "Or bad frac"); | |
1956 return recent_survival_rate; | |
1957 } else { | |
1958 return 1.0; // Be conservative. | |
1959 } | |
1960 } | |
1961 | |
1962 double | |
1963 G1CollectorPolicy::last_survival_fraction_work(TruncatedSeq* surviving, | |
1964 TruncatedSeq* before) { | |
1965 assert(surviving->num() == before->num(), "Sequence out of sync"); | |
1966 if (surviving->num() > 0 && before->last() > 0.0) { | |
1967 double last_survival_rate = surviving->last() / before->last(); | |
1968 // We exempt parallel collection from this check because Alloc Buffer | |
1969 // fragmentation can produce negative collections. | |
1970 // Further, we're now always doing parallel collection. But I'm still | |
1971 // leaving this here as a placeholder for a more precise assertion later. | |
1972 // (DLD, 10/05.) | |
1973 assert((true || ParallelGCThreads > 0) || | |
1974 last_survival_rate <= 1.0, "Or bad frac"); | |
1975 return last_survival_rate; | |
1976 } else { | |
1977 return 1.0; | |
1978 } | |
1979 } | |
1980 | |
1981 static const int survival_min_obs = 5; | |
1982 static double survival_min_obs_limits[] = { 0.9, 0.7, 0.5, 0.3, 0.1 }; | |
1983 static const double min_survival_rate = 0.1; | |
1984 | |
1985 double | |
1986 G1CollectorPolicy::conservative_avg_survival_fraction_work(double avg, | |
1987 double latest) { | |
1988 double res = avg; | |
1989 if (number_of_recent_gcs() < survival_min_obs) { | |
1990 res = MAX2(res, survival_min_obs_limits[number_of_recent_gcs()]); | |
1991 } | |
1992 res = MAX2(res, latest); | |
1993 res = MAX2(res, min_survival_rate); | |
1994 // In the parallel case, LAB fragmentation can produce "negative | |
1995 // collections"; so can evac failure. Cap at 1.0 | |
1996 res = MIN2(res, 1.0); | |
1997 return res; | |
1998 } | |
1999 | |
2000 size_t G1CollectorPolicy::expansion_amount() { | |
1356 | 2001 if ((recent_avg_pause_time_ratio() * 100.0) > _gc_overhead_perc) { |
751 | 2002 // We will double the existing space, or take |
2003 // G1ExpandByPercentOfAvailable % of the available expansion | |
2004 // space, whichever is smaller, bounded below by a minimum | |
2005 // expansion (unless that's all that's left.) | |
342 | 2006 const size_t min_expand_bytes = 1*M; |
2007 size_t reserved_bytes = _g1->g1_reserved_obj_bytes(); | |
2008 size_t committed_bytes = _g1->capacity(); | |
2009 size_t uncommitted_bytes = reserved_bytes - committed_bytes; | |
2010 size_t expand_bytes; | |
2011 size_t expand_bytes_via_pct = | |
751 | 2012 uncommitted_bytes * G1ExpandByPercentOfAvailable / 100; |
342 | 2013 expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes); |
2014 expand_bytes = MAX2(expand_bytes, min_expand_bytes); | |
2015 expand_bytes = MIN2(expand_bytes, uncommitted_bytes); | |
2016 if (G1PolicyVerbose > 1) { | |
2017 gclog_or_tty->print("Decided to expand: ratio = %5.2f, " | |
2018 "committed = %d%s, uncommited = %d%s, via pct = %d%s.\n" | |
2019 " Answer = %d.\n", | |
2020 recent_avg_pause_time_ratio(), | |
2021 byte_size_in_proper_unit(committed_bytes), | |
2022 proper_unit_for_byte_size(committed_bytes), | |
2023 byte_size_in_proper_unit(uncommitted_bytes), | |
2024 proper_unit_for_byte_size(uncommitted_bytes), | |
2025 byte_size_in_proper_unit(expand_bytes_via_pct), | |
2026 proper_unit_for_byte_size(expand_bytes_via_pct), | |
2027 byte_size_in_proper_unit(expand_bytes), | |
2028 proper_unit_for_byte_size(expand_bytes)); | |
2029 } | |
2030 return expand_bytes; | |
2031 } else { | |
2032 return 0; | |
2033 } | |
2034 } | |
2035 | |
2036 void G1CollectorPolicy::note_start_of_mark_thread() { | |
2037 _mark_thread_startup_sec = os::elapsedTime(); | |
2038 } | |
2039 | |
2040 class CountCSClosure: public HeapRegionClosure { | |
2041 G1CollectorPolicy* _g1_policy; | |
2042 public: | |
2043 CountCSClosure(G1CollectorPolicy* g1_policy) : | |
2044 _g1_policy(g1_policy) {} | |
2045 bool doHeapRegion(HeapRegion* r) { | |
2046 _g1_policy->_bytes_in_collection_set_before_gc += r->used(); | |
2047 return false; | |
2048 } | |
2049 }; | |
2050 | |
2051 void G1CollectorPolicy::count_CS_bytes_used() { | |
2052 CountCSClosure cs_closure(this); | |
2053 _g1->collection_set_iterate(&cs_closure); | |
2054 } | |
2055 | |
2056 static void print_indent(int level) { | |
2057 for (int j = 0; j < level+1; ++j) | |
2058 gclog_or_tty->print(" "); | |
2059 } | |
2060 | |
2061 void G1CollectorPolicy::print_summary (int level, | |
2062 const char* str, | |
2063 NumberSeq* seq) const { | |
2064 double sum = seq->sum(); | |
2065 print_indent(level); | |
2066 gclog_or_tty->print_cr("%-24s = %8.2lf s (avg = %8.2lf ms)", | |
2067 str, sum / 1000.0, seq->avg()); | |
2068 } | |
2069 | |
2070 void G1CollectorPolicy::print_summary_sd (int level, | |
2071 const char* str, | |
2072 NumberSeq* seq) const { | |
2073 print_summary(level, str, seq); | |
2074 print_indent(level + 5); | |
2075 gclog_or_tty->print_cr("(num = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", | |
2076 seq->num(), seq->sd(), seq->maximum()); | |
2077 } | |
2078 | |
2079 void G1CollectorPolicy::check_other_times(int level, | |
2080 NumberSeq* other_times_ms, | |
2081 NumberSeq* calc_other_times_ms) const { | |
2082 bool should_print = false; | |
2083 | |
2084 double max_sum = MAX2(fabs(other_times_ms->sum()), | |
2085 fabs(calc_other_times_ms->sum())); | |
2086 double min_sum = MIN2(fabs(other_times_ms->sum()), | |
2087 fabs(calc_other_times_ms->sum())); | |
2088 double sum_ratio = max_sum / min_sum; | |
2089 if (sum_ratio > 1.1) { | |
2090 should_print = true; | |
2091 print_indent(level + 1); | |
2092 gclog_or_tty->print_cr("## CALCULATED OTHER SUM DOESN'T MATCH RECORDED ###"); | |
2093 } | |
2094 | |
2095 double max_avg = MAX2(fabs(other_times_ms->avg()), | |
2096 fabs(calc_other_times_ms->avg())); | |
2097 double min_avg = MIN2(fabs(other_times_ms->avg()), | |
2098 fabs(calc_other_times_ms->avg())); | |
2099 double avg_ratio = max_avg / min_avg; | |
2100 if (avg_ratio > 1.1) { | |
2101 should_print = true; | |
2102 print_indent(level + 1); | |
2103 gclog_or_tty->print_cr("## CALCULATED OTHER AVG DOESN'T MATCH RECORDED ###"); | |
2104 } | |
2105 | |
2106 if (other_times_ms->sum() < -0.01) { | |
2107 print_indent(level + 1); | |
2108 gclog_or_tty->print_cr("## RECORDED OTHER SUM IS NEGATIVE ###"); | |
2109 } | |
2110 | |
2111 if (other_times_ms->avg() < -0.01) { | |
2112 print_indent(level + 1); | |
2113 gclog_or_tty->print_cr("## RECORDED OTHER AVG IS NEGATIVE ###"); | |
2114 } | |
2115 | |
2116 if (calc_other_times_ms->sum() < -0.01) { | |
2117 should_print = true; | |
2118 print_indent(level + 1); | |
2119 gclog_or_tty->print_cr("## CALCULATED OTHER SUM IS NEGATIVE ###"); | |
2120 } | |
2121 | |
2122 if (calc_other_times_ms->avg() < -0.01) { | |
2123 should_print = true; | |
2124 print_indent(level + 1); | |
2125 gclog_or_tty->print_cr("## CALCULATED OTHER AVG IS NEGATIVE ###"); | |
2126 } | |
2127 | |
2128 if (should_print) | |
2129 print_summary(level, "Other(Calc)", calc_other_times_ms); | |
2130 } | |
2131 | |
2132 void G1CollectorPolicy::print_summary(PauseSummary* summary) const { | |
2133 bool parallel = ParallelGCThreads > 0; | |
2134 MainBodySummary* body_summary = summary->main_body_summary(); | |
2135 if (summary->get_total_seq()->num() > 0) { | |
677 | 2136 print_summary_sd(0, "Evacuation Pauses", summary->get_total_seq()); |
342 | 2137 if (body_summary != NULL) { |
2138 print_summary(1, "SATB Drain", body_summary->get_satb_drain_seq()); | |
2139 if (parallel) { | |
2140 print_summary(1, "Parallel Time", body_summary->get_parallel_seq()); | |
2141 print_summary(2, "Update RS", body_summary->get_update_rs_seq()); | |
2142 print_summary(2, "Ext Root Scanning", | |
2143 body_summary->get_ext_root_scan_seq()); | |
2144 print_summary(2, "Mark Stack Scanning", | |
2145 body_summary->get_mark_stack_scan_seq()); | |
2146 print_summary(2, "Scan RS", body_summary->get_scan_rs_seq()); | |
2147 print_summary(2, "Object Copy", body_summary->get_obj_copy_seq()); | |
2148 print_summary(2, "Termination", body_summary->get_termination_seq()); | |
2149 print_summary(2, "Other", body_summary->get_parallel_other_seq()); | |
2150 { | |
2151 NumberSeq* other_parts[] = { | |
2152 body_summary->get_update_rs_seq(), | |
2153 body_summary->get_ext_root_scan_seq(), | |
2154 body_summary->get_mark_stack_scan_seq(), | |
2155 body_summary->get_scan_rs_seq(), | |
2156 body_summary->get_obj_copy_seq(), | |
2157 body_summary->get_termination_seq() | |
2158 }; | |
2159 NumberSeq calc_other_times_ms(body_summary->get_parallel_seq(), | |
2160 7, other_parts); | |
2161 check_other_times(2, body_summary->get_parallel_other_seq(), | |
2162 &calc_other_times_ms); | |
2163 } | |
2164 print_summary(1, "Mark Closure", body_summary->get_mark_closure_seq()); | |
2165 print_summary(1, "Clear CT", body_summary->get_clear_ct_seq()); | |
2166 } else { | |
2167 print_summary(1, "Update RS", body_summary->get_update_rs_seq()); | |
2168 print_summary(1, "Ext Root Scanning", | |
2169 body_summary->get_ext_root_scan_seq()); | |
2170 print_summary(1, "Mark Stack Scanning", | |
2171 body_summary->get_mark_stack_scan_seq()); | |
2172 print_summary(1, "Scan RS", body_summary->get_scan_rs_seq()); | |
2173 print_summary(1, "Object Copy", body_summary->get_obj_copy_seq()); | |
2174 } | |
2175 } | |
2176 print_summary(1, "Other", summary->get_other_seq()); | |
2177 { | |
2178 NumberSeq calc_other_times_ms; | |
2179 if (body_summary != NULL) { | |
2180 // not abandoned | |
2181 if (parallel) { | |
2182 // parallel | |
2183 NumberSeq* other_parts[] = { | |
2184 body_summary->get_satb_drain_seq(), | |
2185 body_summary->get_parallel_seq(), | |
2186 body_summary->get_clear_ct_seq() | |
2187 }; | |
677 | 2188 calc_other_times_ms = NumberSeq(summary->get_total_seq(), |
2189 3, other_parts); | |
342 | 2190 } else { |
2191 // serial | |
2192 NumberSeq* other_parts[] = { | |
2193 body_summary->get_satb_drain_seq(), | |
2194 body_summary->get_update_rs_seq(), | |
2195 body_summary->get_ext_root_scan_seq(), | |
2196 body_summary->get_mark_stack_scan_seq(), | |
2197 body_summary->get_scan_rs_seq(), | |
2198 body_summary->get_obj_copy_seq() | |
2199 }; | |
2200 calc_other_times_ms = NumberSeq(summary->get_total_seq(), | |
677 | 2201 7, other_parts); |
342 | 2202 } |
2203 } else { | |
2204 // abandoned | |
677 | 2205 calc_other_times_ms = NumberSeq(); |
342 | 2206 } |
2207 check_other_times(1, summary->get_other_seq(), &calc_other_times_ms); | |
2208 } | |
2209 } else { | |
2210 print_indent(0); | |
2211 gclog_or_tty->print_cr("none"); | |
2212 } | |
2213 gclog_or_tty->print_cr(""); | |
2214 } | |
2215 | |
2216 void | |
677 | 2217 G1CollectorPolicy::print_abandoned_summary(PauseSummary* summary) const { |
342 | 2218 bool printed = false; |
677 | 2219 if (summary->get_total_seq()->num() > 0) { |
342 | 2220 printed = true; |
677 | 2221 print_summary(summary); |
342 | 2222 } |
2223 if (!printed) { | |
2224 print_indent(0); | |
2225 gclog_or_tty->print_cr("none"); | |
2226 gclog_or_tty->print_cr(""); | |
2227 } | |
2228 } | |
2229 | |
2230 void G1CollectorPolicy::print_tracing_info() const { | |
2231 if (TraceGen0Time) { | |
2232 gclog_or_tty->print_cr("ALL PAUSES"); | |
2233 print_summary_sd(0, "Total", _all_pause_times_ms); | |
2234 gclog_or_tty->print_cr(""); | |
2235 gclog_or_tty->print_cr(""); | |
2236 gclog_or_tty->print_cr(" Full Young GC Pauses: %8d", _full_young_pause_num); | |
2237 gclog_or_tty->print_cr(" Partial Young GC Pauses: %8d", _partial_young_pause_num); | |
2238 gclog_or_tty->print_cr(""); | |
2239 | |
677 | 2240 gclog_or_tty->print_cr("EVACUATION PAUSES"); |
2241 print_summary(_summary); | |
342 | 2242 |
2243 gclog_or_tty->print_cr("ABANDONED PAUSES"); | |
677 | 2244 print_abandoned_summary(_abandoned_summary); |
342 | 2245 |
2246 gclog_or_tty->print_cr("MISC"); | |
2247 print_summary_sd(0, "Stop World", _all_stop_world_times_ms); | |
2248 print_summary_sd(0, "Yields", _all_yield_times_ms); | |
2249 for (int i = 0; i < _aux_num; ++i) { | |
2250 if (_all_aux_times_ms[i].num() > 0) { | |
2251 char buffer[96]; | |
2252 sprintf(buffer, "Aux%d", i); | |
2253 print_summary_sd(0, buffer, &_all_aux_times_ms[i]); | |
2254 } | |
2255 } | |
2256 | |
2257 size_t all_region_num = _region_num_young + _region_num_tenured; | |
2258 gclog_or_tty->print_cr(" New Regions %8d, Young %8d (%6.2lf%%), " | |
2259 "Tenured %8d (%6.2lf%%)", | |
2260 all_region_num, | |
2261 _region_num_young, | |
2262 (double) _region_num_young / (double) all_region_num * 100.0, | |
2263 _region_num_tenured, | |
2264 (double) _region_num_tenured / (double) all_region_num * 100.0); | |
2265 } | |
2266 if (TraceGen1Time) { | |
2267 if (_all_full_gc_times_ms->num() > 0) { | |
2268 gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s", | |
2269 _all_full_gc_times_ms->num(), | |
2270 _all_full_gc_times_ms->sum() / 1000.0); | |
2271 gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times_ms->avg()); | |
2272 gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]", | |
2273 _all_full_gc_times_ms->sd(), | |
2274 _all_full_gc_times_ms->maximum()); | |
2275 } | |
2276 } | |
2277 } | |
2278 | |
2279 void G1CollectorPolicy::print_yg_surv_rate_info() const { | |
2280 #ifndef PRODUCT | |
2281 _short_lived_surv_rate_group->print_surv_rate_summary(); | |
2282 // add this call for any other surv rate groups | |
2283 #endif // PRODUCT | |
2284 } | |
2285 | |
2286 bool | |
2287 G1CollectorPolicy::should_add_next_region_to_young_list() { | |
2288 assert(in_young_gc_mode(), "should be in young GC mode"); | |
2289 bool ret; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2290 size_t young_list_length = _g1->young_list()->length(); |
545 | 2291 size_t young_list_max_length = _young_list_target_length; |
2292 if (G1FixedEdenSize) { | |
2293 young_list_max_length -= _max_survivor_regions; | |
2294 } | |
2295 if (young_list_length < young_list_max_length) { | |
342 | 2296 ret = true; |
2297 ++_region_num_young; | |
2298 } else { | |
2299 ret = false; | |
2300 ++_region_num_tenured; | |
2301 } | |
2302 | |
2303 return ret; | |
2304 } | |
2305 | |
2306 #ifndef PRODUCT | |
2307 // for debugging, bit of a hack... | |
2308 static char* | |
2309 region_num_to_mbs(int length) { | |
2310 static char buffer[64]; | |
2311 double bytes = (double) (length * HeapRegion::GrainBytes); | |
2312 double mbs = bytes / (double) (1024 * 1024); | |
2313 sprintf(buffer, "%7.2lfMB", mbs); | |
2314 return buffer; | |
2315 } | |
2316 #endif // PRODUCT | |
2317 | |
545 | 2318 size_t G1CollectorPolicy::max_regions(int purpose) { |
342 | 2319 switch (purpose) { |
2320 case GCAllocForSurvived: | |
545 | 2321 return _max_survivor_regions; |
342 | 2322 case GCAllocForTenured: |
545 | 2323 return REGIONS_UNLIMITED; |
342 | 2324 default: |
545 | 2325 ShouldNotReachHere(); |
2326 return REGIONS_UNLIMITED; | |
342 | 2327 }; |
2328 } | |
2329 | |
545 | 2330 // Calculates survivor space parameters. |
2331 void G1CollectorPolicy::calculate_survivors_policy() | |
2332 { | |
2333 if (G1FixedSurvivorSpaceSize == 0) { | |
2334 _max_survivor_regions = _young_list_target_length / SurvivorRatio; | |
2335 } else { | |
547
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
2336 _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes; |
545 | 2337 } |
2338 | |
2339 if (G1FixedTenuringThreshold) { | |
2340 _tenuring_threshold = MaxTenuringThreshold; | |
2341 } else { | |
2342 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( | |
2343 HeapRegion::GrainWords * _max_survivor_regions); | |
2344 } | |
2345 } | |
2346 | |
342 | 2347 bool |
2348 G1CollectorPolicy_BestRegionsFirst::should_do_collection_pause(size_t | |
2349 word_size) { | |
2350 assert(_g1->regions_accounted_for(), "Region leakage!"); | |
2351 double max_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0; | |
2352 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2353 size_t young_list_length = _g1->young_list()->length(); |
545 | 2354 size_t young_list_max_length = _young_list_target_length; |
2355 if (G1FixedEdenSize) { | |
2356 young_list_max_length -= _max_survivor_regions; | |
2357 } | |
2358 bool reached_target_length = young_list_length >= young_list_max_length; | |
342 | 2359 |
2360 if (in_young_gc_mode()) { | |
2361 if (reached_target_length) { | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2362 assert( young_list_length > 0 && _g1->young_list()->length() > 0, |
342 | 2363 "invariant" ); |
2364 return true; | |
2365 } | |
2366 } else { | |
2367 guarantee( false, "should not reach here" ); | |
2368 } | |
2369 | |
2370 return false; | |
2371 } | |
2372 | |
2373 #ifndef PRODUCT | |
2374 class HRSortIndexIsOKClosure: public HeapRegionClosure { | |
2375 CollectionSetChooser* _chooser; | |
2376 public: | |
2377 HRSortIndexIsOKClosure(CollectionSetChooser* chooser) : | |
2378 _chooser(chooser) {} | |
2379 | |
2380 bool doHeapRegion(HeapRegion* r) { | |
2381 if (!r->continuesHumongous()) { | |
2382 assert(_chooser->regionProperlyOrdered(r), "Ought to be."); | |
2383 } | |
2384 return false; | |
2385 } | |
2386 }; | |
2387 | |
2388 bool G1CollectorPolicy_BestRegionsFirst::assertMarkedBytesDataOK() { | |
2389 HRSortIndexIsOKClosure cl(_collectionSetChooser); | |
2390 _g1->heap_region_iterate(&cl); | |
2391 return true; | |
2392 } | |
2393 #endif | |
2394 | |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2395 bool |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2396 G1CollectorPolicy::force_initial_mark_if_outside_cycle() { |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2397 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2398 if (!during_cycle) { |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2399 set_initiate_conc_mark_if_possible(); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2400 return true; |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2401 } else { |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2402 return false; |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2403 } |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2404 } |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2405 |
342 | 2406 void |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2407 G1CollectorPolicy::decide_on_conc_mark_initiation() { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2408 // We are about to decide on whether this pause will be an |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2409 // initial-mark pause. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2410 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2411 // First, during_initial_mark_pause() should not be already set. We |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2412 // will set it here if we have to. However, it should be cleared by |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2413 // the end of the pause (it's only set for the duration of an |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2414 // initial-mark pause). |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2415 assert(!during_initial_mark_pause(), "pre-condition"); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2416 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2417 if (initiate_conc_mark_if_possible()) { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2418 // We had noticed on a previous pause that the heap occupancy has |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2419 // gone over the initiating threshold and we should start a |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2420 // concurrent marking cycle. So we might initiate one. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2421 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2422 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2423 if (!during_cycle) { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2424 // The concurrent marking thread is not "during a cycle", i.e., |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2425 // it has completed the last one. So we can go ahead and |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2426 // initiate a new cycle. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2427 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2428 set_during_initial_mark_pause(); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2429 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2430 // And we can now clear initiate_conc_mark_if_possible() as |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2431 // we've already acted on it. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2432 clear_initiate_conc_mark_if_possible(); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2433 } else { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2434 // The concurrent marking thread is still finishing up the |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2435 // previous cycle. If we start one right now the two cycles |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2436 // overlap. In particular, the concurrent marking thread might |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2437 // be in the process of clearing the next marking bitmap (which |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2438 // we will use for the next cycle if we start one). Starting a |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2439 // cycle now will be bad given that parts of the marking |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2440 // information might get cleared by the marking thread. And we |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2441 // cannot wait for the marking thread to finish the cycle as it |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2442 // periodically yields while clearing the next marking bitmap |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2443 // and, if it's in a yield point, it's waiting for us to |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2444 // finish. So, at this point we will not start a cycle and we'll |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2445 // let the concurrent marking thread complete the last one. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2446 } |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2447 } |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2448 } |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2449 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2450 void |
342 | 2451 G1CollectorPolicy_BestRegionsFirst:: |
2452 record_collection_pause_start(double start_time_sec, size_t start_used) { | |
2453 G1CollectorPolicy::record_collection_pause_start(start_time_sec, start_used); | |
2454 } | |
2455 | |
2456 class NextNonCSElemFinder: public HeapRegionClosure { | |
2457 HeapRegion* _res; | |
2458 public: | |
2459 NextNonCSElemFinder(): _res(NULL) {} | |
2460 bool doHeapRegion(HeapRegion* r) { | |
2461 if (!r->in_collection_set()) { | |
2462 _res = r; | |
2463 return true; | |
2464 } else { | |
2465 return false; | |
2466 } | |
2467 } | |
2468 HeapRegion* res() { return _res; } | |
2469 }; | |
2470 | |
2471 class KnownGarbageClosure: public HeapRegionClosure { | |
2472 CollectionSetChooser* _hrSorted; | |
2473 | |
2474 public: | |
2475 KnownGarbageClosure(CollectionSetChooser* hrSorted) : | |
2476 _hrSorted(hrSorted) | |
2477 {} | |
2478 | |
2479 bool doHeapRegion(HeapRegion* r) { | |
2480 // We only include humongous regions in collection | |
2481 // sets when concurrent mark shows that their contained object is | |
2482 // unreachable. | |
2483 | |
2484 // Do we have any marking information for this region? | |
2485 if (r->is_marked()) { | |
2486 // We don't include humongous regions in collection | |
2487 // sets because we collect them immediately at the end of a marking | |
2488 // cycle. We also don't include young regions because we *must* | |
2489 // include them in the next collection pause. | |
2490 if (!r->isHumongous() && !r->is_young()) { | |
2491 _hrSorted->addMarkedHeapRegion(r); | |
2492 } | |
2493 } | |
2494 return false; | |
2495 } | |
2496 }; | |
2497 | |
2498 class ParKnownGarbageHRClosure: public HeapRegionClosure { | |
2499 CollectionSetChooser* _hrSorted; | |
2500 jint _marked_regions_added; | |
2501 jint _chunk_size; | |
2502 jint _cur_chunk_idx; | |
2503 jint _cur_chunk_end; // Cur chunk [_cur_chunk_idx, _cur_chunk_end) | |
2504 int _worker; | |
2505 int _invokes; | |
2506 | |
2507 void get_new_chunk() { | |
2508 _cur_chunk_idx = _hrSorted->getParMarkedHeapRegionChunk(_chunk_size); | |
2509 _cur_chunk_end = _cur_chunk_idx + _chunk_size; | |
2510 } | |
2511 void add_region(HeapRegion* r) { | |
2512 if (_cur_chunk_idx == _cur_chunk_end) { | |
2513 get_new_chunk(); | |
2514 } | |
2515 assert(_cur_chunk_idx < _cur_chunk_end, "postcondition"); | |
2516 _hrSorted->setMarkedHeapRegion(_cur_chunk_idx, r); | |
2517 _marked_regions_added++; | |
2518 _cur_chunk_idx++; | |
2519 } | |
2520 | |
2521 public: | |
2522 ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted, | |
2523 jint chunk_size, | |
2524 int worker) : | |
2525 _hrSorted(hrSorted), _chunk_size(chunk_size), _worker(worker), | |
2526 _marked_regions_added(0), _cur_chunk_idx(0), _cur_chunk_end(0), | |
2527 _invokes(0) | |
2528 {} | |
2529 | |
2530 bool doHeapRegion(HeapRegion* r) { | |
2531 // We only include humongous regions in collection | |
2532 // sets when concurrent mark shows that their contained object is | |
2533 // unreachable. | |
2534 _invokes++; | |
2535 | |
2536 // Do we have any marking information for this region? | |
2537 if (r->is_marked()) { | |
2538 // We don't include humongous regions in collection | |
2539 // sets because we collect them immediately at the end of a marking | |
2540 // cycle. | |
2541 // We also do not include young regions in collection sets | |
2542 if (!r->isHumongous() && !r->is_young()) { | |
2543 add_region(r); | |
2544 } | |
2545 } | |
2546 return false; | |
2547 } | |
2548 jint marked_regions_added() { return _marked_regions_added; } | |
2549 int invokes() { return _invokes; } | |
2550 }; | |
2551 | |
2552 class ParKnownGarbageTask: public AbstractGangTask { | |
2553 CollectionSetChooser* _hrSorted; | |
2554 jint _chunk_size; | |
2555 G1CollectedHeap* _g1; | |
2556 public: | |
2557 ParKnownGarbageTask(CollectionSetChooser* hrSorted, jint chunk_size) : | |
2558 AbstractGangTask("ParKnownGarbageTask"), | |
2559 _hrSorted(hrSorted), _chunk_size(chunk_size), | |
2560 _g1(G1CollectedHeap::heap()) | |
2561 {} | |
2562 | |
2563 void work(int i) { | |
2564 ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size, i); | |
2565 // Back to zero for the claim value. | |
355 | 2566 _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, i, |
2567 HeapRegion::InitialClaimValue); | |
342 | 2568 jint regions_added = parKnownGarbageCl.marked_regions_added(); |
2569 _hrSorted->incNumMarkedHeapRegions(regions_added); | |
2570 if (G1PrintParCleanupStats) { | |
2571 gclog_or_tty->print(" Thread %d called %d times, added %d regions to list.\n", | |
2572 i, parKnownGarbageCl.invokes(), regions_added); | |
2573 } | |
2574 } | |
2575 }; | |
2576 | |
2577 void | |
2578 G1CollectorPolicy_BestRegionsFirst:: | |
2579 record_concurrent_mark_cleanup_end(size_t freed_bytes, | |
2580 size_t max_live_bytes) { | |
2581 double start; | |
2582 if (G1PrintParCleanupStats) start = os::elapsedTime(); | |
2583 record_concurrent_mark_cleanup_end_work1(freed_bytes, max_live_bytes); | |
2584 | |
2585 _collectionSetChooser->clearMarkedHeapRegions(); | |
2586 double clear_marked_end; | |
2587 if (G1PrintParCleanupStats) { | |
2588 clear_marked_end = os::elapsedTime(); | |
2589 gclog_or_tty->print_cr(" clear marked regions + work1: %8.3f ms.", | |
2590 (clear_marked_end - start)*1000.0); | |
2591 } | |
2592 if (ParallelGCThreads > 0) { | |
2593 const size_t OverpartitionFactor = 4; | |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2594 const size_t MinWorkUnit = 8; |
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2595 const size_t WorkUnit = |
342 | 2596 MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor), |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2597 MinWorkUnit); |
342 | 2598 _collectionSetChooser->prepareForAddMarkedHeapRegionsPar(_g1->n_regions(), |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2599 WorkUnit); |
342 | 2600 ParKnownGarbageTask parKnownGarbageTask(_collectionSetChooser, |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1394
diff
changeset
|
2601 (int) WorkUnit); |
342 | 2602 _g1->workers()->run_task(&parKnownGarbageTask); |
355 | 2603 |
2604 assert(_g1->check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
2605 "sanity check"); | |
342 | 2606 } else { |
2607 KnownGarbageClosure knownGarbagecl(_collectionSetChooser); | |
2608 _g1->heap_region_iterate(&knownGarbagecl); | |
2609 } | |
2610 double known_garbage_end; | |
2611 if (G1PrintParCleanupStats) { | |
2612 known_garbage_end = os::elapsedTime(); | |
2613 gclog_or_tty->print_cr(" compute known garbage: %8.3f ms.", | |
2614 (known_garbage_end - clear_marked_end)*1000.0); | |
2615 } | |
2616 _collectionSetChooser->sortMarkedHeapRegions(); | |
2617 double sort_end; | |
2618 if (G1PrintParCleanupStats) { | |
2619 sort_end = os::elapsedTime(); | |
2620 gclog_or_tty->print_cr(" sorting: %8.3f ms.", | |
2621 (sort_end - known_garbage_end)*1000.0); | |
2622 } | |
2623 | |
2624 record_concurrent_mark_cleanup_end_work2(); | |
2625 double work2_end; | |
2626 if (G1PrintParCleanupStats) { | |
2627 work2_end = os::elapsedTime(); | |
2628 gclog_or_tty->print_cr(" work2: %8.3f ms.", | |
2629 (work2_end - sort_end)*1000.0); | |
2630 } | |
2631 } | |
2632 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2633 // Add the heap region at the head of the non-incremental collection set |
342 | 2634 void G1CollectorPolicy:: |
2635 add_to_collection_set(HeapRegion* hr) { | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2636 assert(_inc_cset_build_state == Active, "Precondition"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2637 assert(!hr->is_young(), "non-incremental add of young region"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2638 |
1282 | 2639 if (G1PrintHeapRegions) { |
1388 | 2640 gclog_or_tty->print_cr("added region to cset " |
2641 "%d:["PTR_FORMAT", "PTR_FORMAT"], " | |
2642 "top "PTR_FORMAT", %s", | |
2643 hr->hrs_index(), hr->bottom(), hr->end(), | |
2644 hr->top(), hr->is_young() ? "YOUNG" : "NOT_YOUNG"); | |
342 | 2645 } |
2646 | |
2647 if (_g1->mark_in_progress()) | |
2648 _g1->concurrent_mark()->registerCSetRegion(hr); | |
2649 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2650 assert(!hr->in_collection_set(), "should not already be in the CSet"); |
342 | 2651 hr->set_in_collection_set(true); |
2652 hr->set_next_in_collection_set(_collection_set); | |
2653 _collection_set = hr; | |
2654 _collection_set_size++; | |
2655 _collection_set_bytes_used_before += hr->used(); | |
526 | 2656 _g1->register_region_with_in_cset_fast_test(hr); |
342 | 2657 } |
2658 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2659 // Initialize the per-collection-set information |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2660 void G1CollectorPolicy::start_incremental_cset_building() { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2661 assert(_inc_cset_build_state == Inactive, "Precondition"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2662 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2663 _inc_cset_head = NULL; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2664 _inc_cset_tail = NULL; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2665 _inc_cset_size = 0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2666 _inc_cset_bytes_used_before = 0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2667 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2668 if (in_young_gc_mode()) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2669 _inc_cset_young_index = 0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2670 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2671 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2672 _inc_cset_max_finger = 0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2673 _inc_cset_recorded_young_bytes = 0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2674 _inc_cset_recorded_rs_lengths = 0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2675 _inc_cset_predicted_elapsed_time_ms = 0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2676 _inc_cset_predicted_bytes_to_copy = 0; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2677 _inc_cset_build_state = Active; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2678 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2679 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2680 void G1CollectorPolicy::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:
1391
diff
changeset
|
2681 // This routine is used when: |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2682 // * adding survivor regions to the incremental cset at the end of an |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2683 // evacuation pause, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2684 // * adding the current allocation region to the incremental cset |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2685 // when it is retired, and |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2686 // * updating existing policy information for a region in the |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2687 // incremental cset via young list RSet sampling. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2688 // Therefore this routine may be called at a safepoint by the |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2689 // VM thread, or in-between safepoints by mutator threads (when |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2690 // retiring the current allocation region) or a concurrent |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2691 // refine thread (RSet sampling). |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2692 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2693 double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, true); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2694 size_t used_bytes = hr->used(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2695 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2696 _inc_cset_recorded_rs_lengths += rs_length; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2697 _inc_cset_predicted_elapsed_time_ms += region_elapsed_time_ms; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2698 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2699 _inc_cset_bytes_used_before += used_bytes; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2700 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2701 // Cache the values we have added to the aggregated informtion |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2702 // in the heap region in case we have to remove this region from |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2703 // the incremental collection set, or it is updated by the |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2704 // rset sampling code |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2705 hr->set_recorded_rs_length(rs_length); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2706 hr->set_predicted_elapsed_time_ms(region_elapsed_time_ms); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2707 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2708 #if PREDICTIONS_VERBOSE |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2709 size_t bytes_to_copy = predict_bytes_to_copy(hr); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2710 _inc_cset_predicted_bytes_to_copy += bytes_to_copy; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2711 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2712 // Record the number of bytes used in this region |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2713 _inc_cset_recorded_young_bytes += used_bytes; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2714 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2715 // Cache the values we have added to the aggregated informtion |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2716 // in the heap region in case we have to remove this region from |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2717 // the incremental collection set, or it is updated by the |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2718 // rset sampling code |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2719 hr->set_predicted_bytes_to_copy(bytes_to_copy); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2720 #endif // PREDICTIONS_VERBOSE |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2721 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2722 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2723 void G1CollectorPolicy::remove_from_incremental_cset_info(HeapRegion* hr) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2724 // This routine is currently only called as part of the updating of |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2725 // existing policy information for regions in the incremental cset that |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2726 // is performed by the concurrent refine thread(s) as part of young list |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2727 // RSet sampling. Therefore we should not be at a safepoint. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2728 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2729 assert(!SafepointSynchronize::is_at_safepoint(), "should not be at safepoint"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2730 assert(hr->is_young(), "it should be"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2731 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2732 size_t used_bytes = hr->used(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2733 size_t old_rs_length = hr->recorded_rs_length(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2734 double old_elapsed_time_ms = hr->predicted_elapsed_time_ms(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2735 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2736 // Subtract the old recorded/predicted policy information for |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2737 // the given heap region from the collection set info. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2738 _inc_cset_recorded_rs_lengths -= old_rs_length; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2739 _inc_cset_predicted_elapsed_time_ms -= old_elapsed_time_ms; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2740 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2741 _inc_cset_bytes_used_before -= used_bytes; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2742 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2743 // Clear the values cached in the heap region |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2744 hr->set_recorded_rs_length(0); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2745 hr->set_predicted_elapsed_time_ms(0); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2746 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2747 #if PREDICTIONS_VERBOSE |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2748 size_t old_predicted_bytes_to_copy = hr->predicted_bytes_to_copy(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2749 _inc_cset_predicted_bytes_to_copy -= old_predicted_bytes_to_copy; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2750 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2751 // Subtract the number of bytes used in this region |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2752 _inc_cset_recorded_young_bytes -= used_bytes; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2753 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2754 // Clear the values cached in the heap region |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2755 hr->set_predicted_bytes_to_copy(0); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2756 #endif // PREDICTIONS_VERBOSE |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2757 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2758 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2759 void G1CollectorPolicy::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:
1391
diff
changeset
|
2760 // Update the collection set information that is dependent on the new RS length |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2761 assert(hr->is_young(), "Precondition"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2762 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2763 remove_from_incremental_cset_info(hr); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2764 add_to_incremental_cset_info(hr, new_rs_length); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2765 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2766 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2767 void G1CollectorPolicy::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:
1391
diff
changeset
|
2768 assert( hr->is_young(), "invariant"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2769 assert( hr->young_index_in_cset() == -1, "invariant" ); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2770 assert(_inc_cset_build_state == Active, "Precondition"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2771 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2772 // We need to clear and set the cached recorded/cached collection set |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2773 // information in the heap region here (before the region gets added |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2774 // to the collection set). An individual heap region's cached values |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2775 // are calculated, aggregated with the policy collection set info, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2776 // and cached in the heap region here (initially) and (subsequently) |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2777 // by the Young List sampling code. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2778 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2779 size_t rs_length = hr->rem_set()->occupied(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2780 add_to_incremental_cset_info(hr, rs_length); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2781 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2782 HeapWord* hr_end = hr->end(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2783 _inc_cset_max_finger = MAX2(_inc_cset_max_finger, hr_end); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2784 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2785 assert(!hr->in_collection_set(), "invariant"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2786 hr->set_in_collection_set(true); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2787 assert( hr->next_in_collection_set() == NULL, "invariant"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2788 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2789 _inc_cset_size++; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2790 _g1->register_region_with_in_cset_fast_test(hr); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2791 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2792 hr->set_young_index_in_cset((int) _inc_cset_young_index); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2793 ++_inc_cset_young_index; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2794 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2795 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2796 // Add the region at the RHS of the incremental cset |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2797 void G1CollectorPolicy::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:
1391
diff
changeset
|
2798 // We should only ever be appending survivors at the end of a pause |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2799 assert( hr->is_survivor(), "Logic"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2800 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2801 // Do the 'common' stuff |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2802 add_region_to_incremental_cset_common(hr); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2803 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2804 // Now add the region at the right hand side |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2805 if (_inc_cset_tail == NULL) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2806 assert(_inc_cset_head == NULL, "invariant"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2807 _inc_cset_head = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2808 } else { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2809 _inc_cset_tail->set_next_in_collection_set(hr); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2810 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2811 _inc_cset_tail = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2812 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2813 if (G1PrintHeapRegions) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2814 gclog_or_tty->print_cr(" added region to incremental cset (RHS) " |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2815 "%d:["PTR_FORMAT", "PTR_FORMAT"], " |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2816 "top "PTR_FORMAT", young %s", |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2817 hr->hrs_index(), hr->bottom(), hr->end(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2818 hr->top(), (hr->is_young()) ? "YES" : "NO"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2819 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2820 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2821 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2822 // Add the region to the LHS of the incremental cset |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2823 void G1CollectorPolicy::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:
1391
diff
changeset
|
2824 // Survivors should be added to the RHS at the end of a pause |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2825 assert(!hr->is_survivor(), "Logic"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2826 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2827 // Do the 'common' stuff |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2828 add_region_to_incremental_cset_common(hr); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2829 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2830 // Add the region at the left hand side |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2831 hr->set_next_in_collection_set(_inc_cset_head); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2832 if (_inc_cset_head == NULL) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2833 assert(_inc_cset_tail == NULL, "Invariant"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2834 _inc_cset_tail = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2835 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2836 _inc_cset_head = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2837 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2838 if (G1PrintHeapRegions) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2839 gclog_or_tty->print_cr(" added region to incremental cset (LHS) " |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2840 "%d:["PTR_FORMAT", "PTR_FORMAT"], " |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2841 "top "PTR_FORMAT", young %s", |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2842 hr->hrs_index(), hr->bottom(), hr->end(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2843 hr->top(), (hr->is_young()) ? "YES" : "NO"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2844 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2845 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2846 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2847 #ifndef PRODUCT |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2848 void G1CollectorPolicy::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:
1391
diff
changeset
|
2849 assert(list_head == inc_cset_head() || list_head == collection_set(), "must be"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2850 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2851 st->print_cr("\nCollection_set:"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2852 HeapRegion* csr = list_head; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2853 while (csr != NULL) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2854 HeapRegion* next = csr->next_in_collection_set(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2855 assert(csr->in_collection_set(), "bad CS"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2856 st->print_cr(" [%08x-%08x], t: %08x, P: %08x, N: %08x, C: %08x, " |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2857 "age: %4d, y: %d, surv: %d", |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2858 csr->bottom(), csr->end(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2859 csr->top(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2860 csr->prev_top_at_mark_start(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2861 csr->next_top_at_mark_start(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2862 csr->top_at_conc_mark_count(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2863 csr->age_in_surv_rate_group_cond(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2864 csr->is_young(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2865 csr->is_survivor()); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2866 csr = next; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2867 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2868 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2869 #endif // !PRODUCT |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2870 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2871 bool |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2872 G1CollectorPolicy_BestRegionsFirst::choose_collection_set( |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2873 double target_pause_time_ms) { |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2874 // Set this here - in case we're not doing young collections. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2875 double non_young_start_time_sec = os::elapsedTime(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2876 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2877 // The result that this routine will return. This will be set to |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2878 // false if: |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2879 // * we're doing a young or partially young collection and we |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2880 // have added the youg regions to collection set, or |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2881 // * we add old regions to the collection set. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2882 bool abandon_collection = true; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2883 |
342 | 2884 start_recording_regions(); |
2885 | |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2886 guarantee(target_pause_time_ms > 0.0, |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2887 err_msg("target_pause_time_ms = %1.6lf should be positive", |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2888 target_pause_time_ms)); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2889 guarantee(_collection_set == NULL, "Precondition"); |
342 | 2890 |
2891 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards); | |
2892 double predicted_pause_time_ms = base_time_ms; | |
2893 | |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2894 double time_remaining_ms = target_pause_time_ms - base_time_ms; |
342 | 2895 |
2896 // the 10% and 50% values are arbitrary... | |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2897 if (time_remaining_ms < 0.10 * target_pause_time_ms) { |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2898 time_remaining_ms = 0.50 * target_pause_time_ms; |
342 | 2899 _within_target = false; |
2900 } else { | |
2901 _within_target = true; | |
2902 } | |
2903 | |
2904 // We figure out the number of bytes available for future to-space. | |
2905 // For new regions without marking information, we must assume the | |
2906 // worst-case of complete survival. If we have marking information for a | |
2907 // region, we can bound the amount of live data. We can add a number of | |
2908 // such regions, as long as the sum of the live data bounds does not | |
2909 // exceed the available evacuation space. | |
2910 size_t max_live_bytes = _g1->free_regions() * HeapRegion::GrainBytes; | |
2911 | |
2912 size_t expansion_bytes = | |
2913 _g1->expansion_regions() * HeapRegion::GrainBytes; | |
2914 | |
677 | 2915 _collection_set_bytes_used_before = 0; |
2916 _collection_set_size = 0; | |
342 | 2917 |
2918 // Adjust for expansion and slop. | |
2919 max_live_bytes = max_live_bytes + expansion_bytes; | |
2920 | |
677 | 2921 assert(_g1->regions_accounted_for(), "Region leakage!"); |
342 | 2922 |
2923 HeapRegion* hr; | |
2924 if (in_young_gc_mode()) { | |
2925 double young_start_time_sec = os::elapsedTime(); | |
2926 | |
2927 if (G1PolicyVerbose > 0) { | |
2928 gclog_or_tty->print_cr("Adding %d young regions to the CSet", | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2929 _g1->young_list()->length()); |
342 | 2930 } |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2931 |
342 | 2932 _young_cset_length = 0; |
2933 _last_young_gc_full = full_young_gcs() ? true : false; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2934 |
342 | 2935 if (_last_young_gc_full) |
2936 ++_full_young_pause_num; | |
2937 else | |
2938 ++_partial_young_pause_num; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2939 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2940 // The young list is laid with the survivor regions from the previous |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2941 // pause are appended to the RHS of the young list, i.e. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2942 // [Newly Young Regions ++ Survivors from last pause]. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2943 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2944 hr = _g1->young_list()->first_survivor_region(); |
342 | 2945 while (hr != NULL) { |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2946 assert(hr->is_survivor(), "badly formed young list"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2947 hr->set_young(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2948 hr = hr->get_next_young_region(); |
342 | 2949 } |
2950 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2951 // Clear the fields that point to the survivor list - they are |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2952 // all young now. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2953 _g1->young_list()->clear_survivors(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2954 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2955 if (_g1->mark_in_progress()) |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2956 _g1->concurrent_mark()->register_collection_set_finger(_inc_cset_max_finger); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2957 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2958 _young_cset_length = _inc_cset_young_index; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2959 _collection_set = _inc_cset_head; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2960 _collection_set_size = _inc_cset_size; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2961 _collection_set_bytes_used_before = _inc_cset_bytes_used_before; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2962 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2963 // For young regions in the collection set, we assume the worst |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2964 // case of complete survival |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2965 max_live_bytes -= _inc_cset_size * HeapRegion::GrainBytes; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2966 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2967 time_remaining_ms -= _inc_cset_predicted_elapsed_time_ms; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2968 predicted_pause_time_ms += _inc_cset_predicted_elapsed_time_ms; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2969 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2970 // The number of recorded young regions is the incremental |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2971 // collection set's current size |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2972 set_recorded_young_regions(_inc_cset_size); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2973 set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2974 set_recorded_young_bytes(_inc_cset_recorded_young_bytes); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2975 #if PREDICTIONS_VERBOSE |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2976 set_predicted_bytes_to_copy(_inc_cset_predicted_bytes_to_copy); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2977 #endif // PREDICTIONS_VERBOSE |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2978 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2979 if (G1PolicyVerbose > 0) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2980 gclog_or_tty->print_cr(" Added " PTR_FORMAT " Young Regions to CS.", |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2981 _inc_cset_size); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2982 gclog_or_tty->print_cr(" (" SIZE_FORMAT " KB left in heap.)", |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2983 max_live_bytes/K); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2984 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2985 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2986 assert(_inc_cset_size == _g1->young_list()->length(), "Invariant"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2987 if (_inc_cset_size > 0) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2988 assert(_collection_set != NULL, "Invariant"); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2989 abandon_collection = false; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2990 } |
342 | 2991 |
2992 double young_end_time_sec = os::elapsedTime(); | |
2993 _recorded_young_cset_choice_time_ms = | |
2994 (young_end_time_sec - young_start_time_sec) * 1000.0; | |
2995 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2996 // We are doing young collections so reset this. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2997 non_young_start_time_sec = young_end_time_sec; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2998 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2999 // Note we can use either _collection_set_size or |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3000 // _young_cset_length here |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3001 if (_collection_set_size > 0 && _last_young_gc_full) { |
342 | 3002 // don't bother adding more regions... |
3003 goto choose_collection_set_end; | |
3004 } | |
3005 } | |
3006 | |
3007 if (!in_young_gc_mode() || !full_young_gcs()) { | |
3008 bool should_continue = true; | |
3009 NumberSeq seq; | |
3010 double avg_prediction = 100000000000000000.0; // something very large | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3011 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3012 // Save the current size of the collection set to detect |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3013 // if we actually added any old regions. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3014 size_t n_young_regions = _collection_set_size; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3015 |
342 | 3016 do { |
3017 hr = _collectionSetChooser->getNextMarkedRegion(time_remaining_ms, | |
3018 avg_prediction); | |
677 | 3019 if (hr != NULL) { |
342 | 3020 double predicted_time_ms = predict_region_elapsed_time_ms(hr, false); |
3021 time_remaining_ms -= predicted_time_ms; | |
3022 predicted_pause_time_ms += predicted_time_ms; | |
3023 add_to_collection_set(hr); | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3024 record_non_young_cset_region(hr); |
342 | 3025 max_live_bytes -= MIN2(hr->max_live_bytes(), max_live_bytes); |
3026 if (G1PolicyVerbose > 0) { | |
3027 gclog_or_tty->print_cr(" (" SIZE_FORMAT " KB left in heap.)", | |
3028 max_live_bytes/K); | |
3029 } | |
3030 seq.add(predicted_time_ms); | |
3031 avg_prediction = seq.avg() + seq.sd(); | |
3032 } | |
3033 should_continue = | |
3034 ( hr != NULL) && | |
3035 ( (adaptive_young_list_length()) ? time_remaining_ms > 0.0 | |
3036 : _collection_set_size < _young_list_fixed_length ); | |
3037 } while (should_continue); | |
3038 | |
3039 if (!adaptive_young_list_length() && | |
3040 _collection_set_size < _young_list_fixed_length) | |
3041 _should_revert_to_full_young_gcs = true; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3042 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3043 if (_collection_set_size > n_young_regions) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3044 // We actually added old regions to the collection set |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3045 // so we are not abandoning this collection. |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3046 abandon_collection = false; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3047 } |
342 | 3048 } |
3049 | |
3050 choose_collection_set_end: | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3051 stop_incremental_cset_building(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3052 |
342 | 3053 count_CS_bytes_used(); |
3054 | |
3055 end_recording_regions(); | |
3056 | |
3057 double non_young_end_time_sec = os::elapsedTime(); | |
3058 _recorded_non_young_cset_choice_time_ms = | |
3059 (non_young_end_time_sec - non_young_start_time_sec) * 1000.0; | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
3060 |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3061 // Here we are supposed to return whether the pause should be |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3062 // abandoned or not (i.e., whether the collection set is empty or |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3063 // not). However, this introduces a subtle issue when a pause is |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3064 // initiated explicitly with System.gc() and |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3065 // +ExplicitGCInvokesConcurrent (see Comment #2 in CR 6944166), it's |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3066 // supposed to start a marking cycle, and it's abandoned. So, by |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3067 // returning false here we are telling the caller never to consider |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3068 // a pause to be abandoned. We'll actually remove all the code |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3069 // associated with abandoned pauses as part of CR 6963209, but we are |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3070 // just disabling them this way for the moment to avoid increasing |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3071 // further the amount of changes for CR 6944166. |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3072 return false; |
342 | 3073 } |
3074 | |
3075 void G1CollectorPolicy_BestRegionsFirst::record_full_collection_end() { | |
3076 G1CollectorPolicy::record_full_collection_end(); | |
3077 _collectionSetChooser->updateAfterFullCollection(); | |
3078 } | |
3079 | |
3080 void G1CollectorPolicy_BestRegionsFirst:: | |
3081 expand_if_possible(size_t numRegions) { | |
3082 size_t expansion_bytes = numRegions * HeapRegion::GrainBytes; | |
3083 _g1->expand(expansion_bytes); | |
3084 } | |
3085 | |
3086 void G1CollectorPolicy_BestRegionsFirst:: | |
677 | 3087 record_collection_pause_end(bool abandoned) { |
3088 G1CollectorPolicy::record_collection_pause_end(abandoned); | |
342 | 3089 assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end."); |
3090 } |