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