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