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